C语言之-restrict 用法

现在的位置: 首页 > 综合 > 正文

C语言之-restrict 用法

2013年07月03日 ⁄ 综合 ⁄ 共 2330字 ⁄ 字号小中大 ⁄ 评论关闭

refer:http://en.wikipedia.org/wiki/Restrict

From Wikipedia, the free encyclopedia

Jump to: navigation
,
search

This article is about the C programming language keyword. For other uses, see Restriction (disambiguation)
.

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 caching optimizations. If the declaration of intent is not
followed and the object is accessed by an independent pointer, this will
result in undefined behavior
.

[edit
]
Optimization

If the compiler knows that there is only one pointer to a memory
block, it can produce better code. The following hypothetical example
makes it clearer:

void
 updatePtrs(
size_t *
ptrA,
 size_t *
ptrB,
 size_t *
val)

{

*
ptrA +=
 *
val;

*
ptrB +=
 *
val;

}

In the above code, the pointers ptrA
, ptrB
, val
might
refer to the same memory location
, so the compiler will generate a 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.


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
, 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