volatile means not to store the volatile variable in a register (common compiler optimization), and instead actually access it every time. This wouldn't work without volatile.
The compiler may optimize out the recurring read of the lock by storing the value of a lock in a register. We want to prevent this, so we make the lock a volatile variable.
Unfortunately volatile doesn't meet this spec for many compilers.
This comment was marked helpful 0 times.
sfackler
Compilers correctly implement the C specification with respect to volatile. Volatile was not intended to and does not correctly support this kind of operation.
There appear to be three classes of volatile use that are actually portable. Though such uses appear relatively rare, they would be slowed down on some platforms if we adopted stronger semantics. These are:
volatile may be used to mark local variables in the same scope as a setjmp whose value should be preserved across a longjmp. It is unclear what fraction of such uses would be slowed down, since the atomicity and ordering constraints have no effect if there is no way to share the local variable in question. (It is even unclear what fraction of such uses would be slowed down by requiring all variables to be preserved across a longjmp, but that is a separate matter and is not considered here.)
volatile may be used when variables may be "externally modified", but the modification in fact is triggered synchronously by the thread itself, e.g. because the underlying memory is mapped at multiple locations.
A volatile sigatomic_t may be used to communicate with a signal handler in the same thread, in a restricted manner. One could consider weakening the requirements for the sigatomic_t case, but that seems rather counterintuitive.
Volatile works (mostly) to perform synchronization of memory between processors on x86 because x86's memory model is extremely strong.
Unfortunately, C historically had no concept of a memory model, so there was no platform independent way of correctly synchronizing state. C11 adds a memory model and the stdatomic.h header which provides such functionality.
volatile means not to store the volatile variable in a register (common compiler optimization), and instead actually access it every time. This wouldn't work without volatile.
This comment was marked helpful 0 times.
In general, this "double-checked locking" approach is dubious, although it's a good idea here: http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
This comment was marked helpful 0 times.
Reason for volatile:
The compiler may optimize out the recurring read of the lock by storing the value of a lock in a register. We want to prevent this, so we make the lock a volatile variable.
Unfortunately volatile doesn't meet this spec for many compilers.
This comment was marked helpful 0 times.
Compilers correctly implement the C specification with respect to
volatile. Volatile was not intended to and does not correctly support this kind of operation.From here:
Volatile works (mostly) to perform synchronization of memory between processors on x86 because x86's memory model is extremely strong.
Unfortunately, C historically had no concept of a memory model, so there was no platform independent way of correctly synchronizing state. C11 adds a memory model and the
stdatomic.hheader which provides such functionality.This comment was marked helpful 1 times.