1

I'm having quite hard time making proper usage of restrict keyword in C. I wrote this function to in-place reverse a string:

void my_strrev(char *restrict str, const size_t len) {
    char *restrict strr = str + len - 1;
    char temp;
    while (str < strr) {
        temp = *str;
        *str++ = *strr;
        *strr-- = temp;
    }
}

Here, although both str and strr are pointing to same array, I'm using those pointers to access individual characters, and they never point to same characters. Hence I think this is a proper use of restrict. Also I got expected output when I run this program with few sample inputs. But I'm unsure of my usage of restrict. So, please correct me if I'm doing wrong.

Dharman
  • 30,962
  • 25
  • 85
  • 135
Sourav Kannantha B
  • 2,860
  • 1
  • 11
  • 35
  • 1
    I suggest to compare the assembly of two variants of this function - one with the restrict keyword and one without it. (use objdump). – Arnon Charas Feb 02 '22 at 08:02
  • @ArnonCharas There is no reason why `restrict` would give different machine code here though, so it doesn't sound very meaningful to compare the disassembly. I would be very surprised if there were any differences. – Lundin Feb 02 '22 at 09:14
  • And to prove in practice that I'm right: https://godbolt.org/z/5nbEW495a – Lundin Feb 02 '22 at 09:17

2 Answers2

1

restrict has pretty much one single use - a contract that the programmer signs up with the compiler saying "I promise that I won't pass parameters pointing at the same data to this function with external linkage." This is still to this day mostly based on the compiler trusting the programmer, rather than the compiler giving diagnostic messages when the programmer "breaks the contract".

If the compiler can assume that the programmer kept their side of the bargain, it can make optimizations:

  • It can assume that buffers passed to a function won't overlap - no need for temporary storage. (See memcpy vs memmove for example.)
  • It can assume that different pointer parameters aren't aliases of each other, pointing to the same data. (Which could be possible if you have for example a char* and an int* parameter.)
  • It can assume that pointer parameters aren't modifying any external linkage resources ("globals") used by the function, but that all access to what the pointer points at happens through that pointer.

Using restrict for a local pointer variable isn't very meaningful since it doesn't relate to any of the above situations. It will compile but there will be no benefits of using it. As far as I know, no additional diagnostics is currently provided by any of the mainstream compilers, should you use a restrict pointer inappropriately.

Lundin
  • 195,001
  • 40
  • 254
  • 396
  • `restrict` in block scope may not be meaningful here. But if anyone want to see it's actual use case, can see one example [here](https://en.cppreference.com/w/c/language/restrict#:~:text=.-,Block%20scope,-A%20block%20scope) – Sourav Kannantha B Feb 02 '22 at 10:09
  • If I have a `char*` and an `int*` as argument to a function, is it required to use `restrict` for optimization? or can compiler infer `restrict`ness based on different datatype. – Sourav Kannantha B Feb 02 '22 at 11:37
  • @SouravKannanthaB `char*` can be a pointer alias of `int*` so it can't do that optimization. Had it been `double*` and `int*` it would be another story. This is all about the "strict aliasing rules". – Lundin Feb 02 '22 at 11:38
1

restrict essentially says that all the memory the function accesses through that pointer will not be accessed any other way, i.e., not also through another parameter or pointers loaded in any other way or via external objects.

It is okay to assign the parameter to other variables and to use those variables to access memory. Those accesses still derive from the original pointer. They are not derived from a different parameter or other source.

Eric Postpischil
  • 195,579
  • 13
  • 168
  • 312
  • Should I use `restrict` in `struct`s having multiple pointers as members? – Sourav Kannantha B Feb 03 '22 at 06:33
  • @SouravKannanthaB: That depends on what the pointers point to. `restrict` is used to tell the compiler that an object will be accessed only through the pointer marked `restrict` (unless the object is not modified by any means during execution of the applicable code). If a pointer points to data that may be shared through different pointers, it should not be marked `restrict`. If it points to data that “belongs” only to that pointer, it can be marked `restrict`. Whether it is useful or not depends on circumstances; `restrict` is intended to let the compiler optimize in certain cases. – Eric Postpischil Feb 03 '22 at 14:14