aliasing

When it sees 'restrict', it can simply take shortcuts and assume no aliasing possible and no pointer tricks are used.

On the other hand, the approach could do anti-aliasing: average those values being tread over.

Of course aliasing it directly is faster then checking to see if it exists and then using it if it does...

Famously, the Linux kernel does this a lot and needs to be compiled with -fno-strict-aliasing.

Strictly speaking accessing that union both ways ~~~violates the strict aliasing rules~~~ isn't portable.

Argument aliasing rules, discouraging pointer use, lack of 15 layers of templates, 1st class arrays, and so forth.

Also, the Mill loads are orthogonal to cache management and we offer immunity to aliasing and false sharing.

There's a huge amount of aliasing which is distracting and deteriorates the images.

However, it is such a common idiom that GCC and other compilers explicitly allow using unions to get around the strict aliasing rules, so long as the access is always performed through the union.

And I totally agree with the spirit of your argument that pointers and pointer aliasing makes concurrency harder in C/C++.

You write to fresh memory, no aliasing, no coherence, no conflicts.

If you use the aliasing constructor, it's even more confusing.

In practice "sufficiently smart" means "at least as smart as a human", in which case pointer aliasing is the least of your concerns.

My understanding is that C doesn't generally allow this; that's what the strict aliasing rule is, and what's "wrong"[1] with several of the examples in the article.

Although it doesn't exactly have transactions, Rust's strict aliasing and mutability controls is a much better argument for "there are better ways to avoid the problems of shared mutable state".

> Rust's strict aliasing and mutability controls is a much better argument for "there are better ways to avoid the problems of shared mutable state".