Why do we use volatile keyword? [duplicate]

by

Consider this code,

int some_int = 100;

while(some_int == 100)
{
   //your code
}

When this program gets compiled, the compiler may optimize this code, if it finds that the program never ever makes any attempt to change the value of some_int, so it may be tempted to optimize the while loop by changing it from while(some_int == 100) to something which is equivalent to while(true) so that the execution could be fast (since the condition in while loop appears to be true always). (if the compiler doesn’t optimize it, then it has to fetch the value of some_int and compare it with 100, in each iteration which obviously is a little bit slow.)

However, sometimes, optimization (of some parts of your program) may be undesirable, because it may be that someone else is changing the value of some_int from outside the program which compiler is not aware of, since it can’t see it; but it’s how you’ve designed it. In that case, compiler’s optimization would not produce the desired result!

So, to ensure the desired result, you need to somehow stop the compiler from optimizing the while loop. That is where the volatile keyword plays its role. All you need to do is this,

volatile int some_int = 100; //note the 'volatile' qualifier now!

In other words, I would explain this as follows:

volatile tells the compiler that,

“Hey compiler, I’m volatile and, you
know, I can be changed by some XYZ
that you’re not even aware of. That
XYZ could be anything. Maybe some
alien outside this planet called
program. Maybe some lightning, some
form of interrupt, volcanoes, etc can
mutate me. Maybe. You never know who
is going to change me! So O you
ignorant, stop playing an all-knowing
god, and don’t dare touch the code
where I’m present. Okay?”

Well, that is how volatile prevents the compiler from optimizing code. Now search the web to see some sample examples.

Quoting from the C++ Standard ($7.1.5.1/8)

[..] volatile is a hint to the
implementation to avoid aggressive
optimization involving the object
because the value of the object might
be changed by means undetectable by an
implementation.[…]

Related topic:

Does making a struct volatile make all its members volatile?

More Related Contents:

  1. When to use volatile with multi threading?
  2. Why are elementwise additions much faster in separate loops than in a combined loop?
  3. gcc optimization flag -O3 makes code slower than -O2
  4. Replacing a 32-bit loop counter with 64-bit introduces crazy performance deviations with _mm_popcnt_u64 on Intel CPUs
  5. Why don’t compilers merge redundant std::atomic writes?
  6. What kind of optimization does const offer in C/C++?
  7. What C/C++ compiler can use push pop instructions for creating local variables, instead of just increasing esp once?
  8. Volatile in C++11
  9. Change default value of CMAKE_CXX_FLAGS_DEBUG and friends in CMake
  10. Why does std::cout convert volatile pointers to bool?
  11. Why does GCC generate 15-20% faster code if I optimize for size instead of speed?
  12. Does the C++ volatile keyword introduce a memory fence?
  13. Why is the empty base class optimization (EBO) is not working in MSVC?
  14. Why does the enhanced GCC 6 optimizer break practical C++ code?
  15. Preventing compiler optimizations while benchmarking
  16. Why is std::fill(0) slower than std::fill(1)?
  17. Is volatile bool for thread control considered wrong?
  18. Why is the volatile qualifier used through out std::atomic?
  19. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  20. Optimization of raw new[]/delete[] vs std::vector
  21. GCC: Difference between -O3 and -Os
  22. When do programmers use Empty Base Optimization (EBO)
  23. GCC -Wuninitialized / -Wmaybe-uninitialized issues
  24. Why is volatile deprecated in C++20?
  25. Why am I not provided with a default copy constructor from a volatile?
  26. Can I hint the optimizer by giving the range of an integer?
  27. What are these seemingly-useless callq instructions in my x86 object files for?
  28. C/C++: casting away volatile considered harmful?
  29. Is ‘volatile’ needed in this multi-threaded C++ code?
  30. Do non-static member variables in a C++ struct/class need to be marked as volatile to be treated as volatile in a member function?

Leave a Comment