[wvenable]

C loses some optimization potential because of aliasing; it can't be guaranteed that some pointer operation isn't going to change a variable anywhere in memory so that limits certain reordering and loop optimizations.

Languages without arbitrary pointers don't have this issue and safely assume they knows all the assignments done to values in memory allowing for optimizations.

[kevin_thibedeau]

The restrict keyword helps with this.

[m_mueller]

That, or switching to FORTRAN. For numeric / HPC it is much easier to get a decently fast implementation there.

[pjmlp]

Provided their user knows what they are doing and never do the mistake to lie to the compiler.

[coliveira]

The C language has provided the restrict keyword to solve these aliasing issues since the C99 standard. That is, 20 years ago.

[tachyonbeam]

I think this generally doesn't have much of an impact on performance.

[_dps]

Just a personal anecdote, but it regularly makes a substantial (like 2x+) difference for me in tight linear algebra loops. It seems to be required if you want to coax clang to emit vfmad instructions for common C linear algebra idioms. Narrow use case, I know, but it can definitely make a big difference in some domains.

[tachyonbeam]

I'll take your word for it. I guess I live in a world where the code I see is rarely tight algebra loops, but I can see that in certain domains you would definitely care.

[cozzyd]

It certainly does... it's the main reason fortran was often faster than C, isn't it? Aliasing prevents automatic vectorization, among other things.

Whether or not the compiler will be smart enough to autovectorize is a different question.

[pjmlp]

The developer must also be smart enough not to do the mistake to lie to the compiler, by actually doing aliasing with restricted variables as it is UB and nasal dragons beware.

C compilers don't validate correct use of restrict.

[Arnavion]

Not all C compilers handle even correct uses of `restrict` properly. For about three years, Rust has been unable to use the LLVM equivalent of `restrict` when downleveling its references, because it keeps finding LLVM miscompilation bugs around it.

These LLVM bugs don't get noticed with C because C programs rarely use `restrict` as pervasively as a downleveled Rust program ends up doing.

[cozzyd]

I wonder if these same LLVM issues affect LLVM fortran attempts?