Answer

The restrict keyword is a specifier for pointers introduced in the C99 standard. It tells the compiler that the pointer is the only way to access the memory object within the scope of the pointer. This significantly helps the optimizer generate more efficient machine code, especially when working with large buffers.

For example:

void vector_add(int * restrict a, int * restrict b, int * restrict c, size_t n) {
    for (size_t i = 0; i < n; ++i)
        c[i] = a[i] + b[i];
}

Here, it is assumed that the arrays a, b, and c do not overlap. Violating this requirement leads to undefined behavior and difficult-to-detect errors.

Using restrict is recommended only when you are sure that no other pointers or side accesses point to the same memory.

Trick Question

Can the same memory value be visible through two restrict pointers at the same time?

Answer:

No, this will lead to undefined behavior. There is no guarantee that the compiler will account for changes made through the second pointer. An example of critically incorrect code:

void f(int * restrict x, int * restrict y) {
    x[0] = 1;
    y[0] = 2;
}

int main() {
    int v;
    f(&v, &v); // Violation of restrict condition
}

Examples of real errors due to lack of knowledge on the topic

---

Story

In a financial calculation core, functions optimized arrays with the addition of restrict but did not consider that the arrays might overlap as required by part of the business logic. This led to incorrect balance calculations due to improper usage.

---

Story

The batch matrix multiplication method was accelerated after applying restrict, but in one of the iterations, the result array overlapped with one of the input arrays — the result became unpredictable, and the bug was caught only through load testing.

---

Story

In one of the image processing functions, two pointers to chunks of the same buffer were accidentally declared with restrict. After updating the compiler and its optimizer, the image processing results became severely distorted — the reason was that the compiler began to aggressively reuse the cache and ignored modifications.