Does the C++ volatile keyword introduce a memory fence?

by

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 the atomic is lock-free.
  • When dealing with setjmp according to Intel.
  • When dealing directly with hardware and you want to ensure that the compiler does not optimize your reads or writes away.

For example:

volatile int *foo = some_memory_mapped_device;
while (*foo)
    ; // wait until *foo turns false

Without the volatile specifier, the compiler is allowed to completely optimize the loop away. The volatile specifier tells the compiler that it may not assume that 2 subsequent reads return the same value.

Note that volatile has nothing to do with threads. The above example does not work if there was a different thread writing to *foo because there is no acquire operation involved.

In all other cases, usage of volatile should be considered non-portable and not pass code review anymore except when dealing with pre-C++11 compilers and compiler extensions (such as msvc’s /volatile:ms switch, which is enabled by default under X86/I64).

More Related Contents:

  1. Start thread with member function
  2. When to use volatile with multi threading?
  3. C++0x has no semaphores? How to synchronize threads?
  4. How do I terminate a thread in C++11?
  5. Thread pooling in C++11
  6. Why don’t compilers merge redundant std::atomic writes?
  7. std::thread pass by reference calls copy constructor
  8. What does the thread_local mean in C++11?
  9. How to check if a std::thread is still running?
  10. What exactly is std::atomic?
  11. How would you implement your own reader/writer lock in C++11?
  12. Mixing C++11 atomics and OpenMP
  13. std::unique_lock or std::lock_guard?
  14. How to set the stacksize with C++11 std::thread
  15. How to use std::async on a member function?
  16. How to give priority to privileged thread in mutex locking?
  17. C++0x thread interruption
  18. What causes runtime error message: std::system_error – operation not permitted, including mult-threading? [duplicate]
  19. What is the difference between packaged_task and async
  20. Is volatile bool for thread control considered wrong?
  21. std::thread is not a member of namespace std using Eclipse Kepler MinGW
  22. Waiting for multiple futures?
  23. What is different between join() and detach() for multi threading in C++?
  24. std::thread error (thread not member of std)
  25. MinGW error: ‘thread’ is not a member of ‘std’
  26. Double-Checked Lock Singleton in C++11
  27. I want to kill a std::thread using its thread object? [duplicate]
  28. Is ‘volatile’ needed in this multi-threaded C++ code?
  29. C++11 Implementation of Spinlock using header “
  30. About thread-safety of weak_ptr

Leave a Comment