You should really check out this article: http://brooker.co.za/blog/2012/09/10/volatile.html. The blog article argues volatile reads can be a lot slower (also for x86) than non-volatile reads on x86. Test 1 is a parallel read and write to a non-volatile variable. There is no visibility mechanism and the results of the reads are potentially stale. Test 2 … Read more
volatile can be used for such purposes. However this is an extension to standard C++ by Microsoft: Microsoft Specific Objects declared as volatile are (…) A write to a volatile object (volatile write) has Release semantics; (…) A read of a volatile object (volatile read) has Acquire semantics; (…) This allows volatile objects to be … Read more
Consider this example: int i = 5; System.out.println(i); The compiler may optimize this to just print 5, like this: System.out.println(5); However, if there is another thread which can change i, this is the wrong behaviour. If another thread changes i to be 6, the optimized version will still print 5. The volatile keyword prevents such … Read more
Volatile –> Guarantees visibility and NOT atomicity Synchronization (Locking) –> Guarantees visibility and atomicity (if done properly) Volatile is not a substitute for synchronization Use volatile only when you are updating the reference and not performing some other operations on it. Example: volatile int i = 0; public void incrementI(){ i++; } will not be … Read more
asm volatile(“” ::: “memory”); creates a compiler level memory barrier forcing optimizer to not re-order memory accesses across the barrier. For example, if you need to access some address in a specific order (probably because that memory area is actually backed by a different device rather than a memory) you need to be able tell … Read more
I’ve used volatile where I’m not sure it is necessary. Let me be very clear on this point: If you are not 100% clear on what volatile means in C# then do not use it. It is a sharp tool that is meant to be used by experts only. If you cannot describe what all … Read more
Rather than explaining what volatile does, allow me to explain when you should use volatile. When inside a signal handler. Because writing to a volatile variable is pretty much the only thing the standard allows you to do from within a signal handler. Since C++11 you can use std::atomic for that purpose, but only if … Read more
Before I go into this explanation, you need to understand one optimization that compilers do (my explanation is very simplified). Suppose that somewhere in your code you have such a sequence: int x = a; int y = a; It is perfectly valid for a compiler to re-order these into: // reverse the order int … Read more
ostream::operator<< has the following overloads, among others: ostream& operator<< (bool val ); ostream& operator<< (const void* val ); When you pass in a volatile pointer, the second overload can’t apply because volatile pointers cannot be converted to non-volatile without an explicit cast. However, any pointer can be converted to bool, so the first overload is … Read more
Basically, volatile announces that a value might change behind your program’s back. That prevents compilers from caching the value (in a CPU register) and from optimizing away accesses to that value when they seem unnecessary from the POV of your program. What should trigger usage of volatile is when a value changes despite the fact … Read more