restrict

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 the pointer itself 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 that usually work in both C++ and C, such as the GNU Compiler Collection's and Clang's __restrict__, and Visual C++'s __restrict and __declspec(restrict).

Optimization

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 val (i.e., point to the same location).
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.

References

• "ISO/IEC 9899:TC2 Committee Draft" (PDF). ISO. May 6, 2005: 108–112. Retrieved 2008-12-22. 

External links

• Demystifying The Restrict Keyword: explanation and examples of use
• Walls, Douglas. "How to Use the restrict Qualifier in C". Oracle™. Retrieved 2012-11-21. 
• Restricted Pointers in C: the original rationale behind the definition