出典(authority):フリー百科事典『ウィキペディア(Wikipedia)』「2015/06/15 15:23:53」(JST)
In the C programming language, as of the C99 standard, restrict
is a keyword that can be used in pointer declarations. The restrict
keyword is a declaration of intent given by the programmer to the compiler. It says that for the lifetime of the pointer, only it or a value directly derived from it (such as pointer + 1
) will be used to access the object to which it points. This limits the effects of pointer aliasing, aiding optimizations. If the declaration of intent is not followed and the object is accessed by an independent pointer, this will result in undefined behavior. The use of the restrict
keyword in C, in principle, allows non-obtuse C to achieve the same performance as the same program written in Fortran.[1]
C++ does not have standard support for restrict
, but many compilers have equivalents which usually work in both C++ and C, such as the GNU Compiler Collection and Clang __restrict__
, and Visual C++ __restrict
and __declspec(restrict)
.
If the compiler knows that there is only one pointer to a memory block, it can produce better optimized code. For instance:
void updatePtrs(size_t *ptrA, size_t *ptrB, size_t *val) { *ptrA += *val; *ptrB += *val; }
In the above code, the pointers ptrA
, ptrB
, and val
might refer to the same memory location, so the compiler may generate less optimal code:
load R1 ← *val ; Load the value of val pointer load R2 ← *ptrA ; Load the value of ptrA pointer add R2 += R1 ; Perform Addition set R2 → *ptrA ; Update the value of ptrA pointer ; Similarly for ptrB, note that val is loaded twice, ; because ptrA may be equal to (points to the same location as) val. load R1 ← *val load R2 ← *ptrB add R2 += R1 set R2 → *ptrB
However, if the restrict
keyword is used and the above function is declared as
void updatePtrs(size_t *restrict ptrA, size_t *restrict ptrB, size_t *restrict val);
then the compiler is allowed to assume that ptrA
, ptrB
, and val
point to different locations and updating one pointer will not affect the other pointers. The programmer, not the compiler, is responsible for ensuring that the pointers do not point to identical locations.
Now the compiler can generate better code as follows:
load R1 ← *val load R2 ← *ptrA add R2 += R1 set R2 → *ptrA ; Note that val is not reloaded, ; because the compiler knows it is unchanged load R2 ← *ptrB add R2 += R1 set R2 → *ptrB
Note that the above assembly code is shorter because val
is loaded once.
...The default aliasing rules of the C and C++ languages do not help the compiler making these decisions (unless restrict is used, all pointer accesses are potential sources of aliasing). This is why Fortran is still a preferred language for numeric programming: it makes writing fast code easier. (In theory the restrict keyword introduced into the C language in the 1999 revision should solve the problem. Compilers have not caught up yet, though. The reason is mainly that too much incorrect code exists which would mislead the compiler and cause it to generate incorrect object code.)
全文を閲覧するには購読必要です。 To read the full text you will need to subscribe.
リンク元 | 「restraint」「restrain」「definite」「limit」「限定」 |
拡張検索 | 「type I restriction enzyme」「restriction enzyme HindIII」「restriction enzyme BamHI」「intrauterine growth restriction」 |
.