In fact, the very example given in the article shows that without the ACCESS_ONCE, the compiler moved the access outside of the loop---thereby ensuring that it's accessed just once, ironically!!! Whereas by using ACCESS_ONCE, we ensure that it's accessed as many times as the loop is iterated, not only once.
Basically this just does some kind of volatile access, and so the name should reflect that:
foo = VOLATILE_READ(bar);
But that is just a consequence of putting a call to ACCESS_ONCE inside a loop. But it is retaining the property that it is only read from memory once per iteration.
It would be way more confusing if the programmer only wanted read once for the whole loop and still put the statement inside the loop.
I do think that knowing that it is being called in a loop context, implies that it should only be accessed once per iteration
for (;;) {
/* ... */
if (pthread_once(&once_var, once_routine))
/* error */;
/* ... */
}
ACCESS_ONCE to me strongly suggests that the value is accessed once and cached forever. E.g. ACCESS_ONCE(x) could expand to something like:
({
static __flag;
static typeof(x) __cached;
if (!__flag) {
__cached = (x);
__flag = 1;
}
__cached;
})
(defun myfunc ()
(let ((foo (bar))
... ;; deeply nested
(let ((x (load-time-value (whatever))))
...))))
But if you always access a certain object through casts to ((volatile )&x), I don't see how this should be different than accesses to a globally declared "volatile x" variable, as pointers are guaranteed to not change if casted hence-and-forth (§6.3.2.3/7).