c++, std::atomic, what is std::memory_order and how to use them?

by

The std::memory_order values allow you to specify fine-grained constraints on the memory ordering provided by your atomic operations. If you are modifying and accessing atomic variables from multiple threads, then passing the std::memory_order values to your operations allow you to relax the constraints on the compiler and processor about the order in which the operations on those atomic variables become visible to other threads, and the synchronization effects those operations have on the non-atomic data in your application.

The default ordering of std::memory_order_seq_cst is the most constrained, and provides the “intuitive” properties you might expect: if thread A stores some data and then sets an atomic flag using std::memory_order_seq_cst, then if thread B sees the flag is set then it can see that data written by thread A. The other memory ordering values do not necessarily provide this guarantee, and must therefore be used very carefully.

The basic premise is: do not use anything other than std::memory_order_seq_cst (the default) unless (a) you really really know what you are doing, and can prove that the relaxed usage is safe in all cases, and (b) your profiler demonstrates that the data structure and operations you are intending to use the relaxed orderings with are a bottleneck.

My book, C++ Concurrency in Action devotes a whole chapter (45 pages) to the details of the C++ memory model, atomic operations and the std::memory_order constraints, and a further chapter (44 pages) to using atomic operations for synchronization in lock-free data structures, and the consequences of relaxed ordering constraints.

My blog entries on Dekker’s algorithm and Peterson’s algorithm for mutual exclusion demonstrate some of the issues.

More Related Contents:

  1. Acquire/release semantics with 4 threads
  2. C++11 memory_order_acquire and memory_order_release semantics?
  3. Acquire/Release versus Sequentially Consistent memory order
  4. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  5. When to use volatile with multi threading?
  6. Can num++ be atomic for ‘int num’?
  7. Will two atomic writes to different locations in different threads always be seen in the same order by other threads?
  8. Why don’t compilers merge redundant std::atomic writes?
  9. Atomicity on x86
  10. What exactly is std::atomic?
  11. How to implement multithread safe singleton in C++11 without using
  12. Where is the lock for a std::atomic?
  13. Mixing C++11 atomics and OpenMP
  14. What do each memory_order mean?
  15. When do I really need to use atomic instead of bool? [duplicate]
  16. Acquire/release semantics with non-temporal stores on x64
  17. For purposes of ordering, is atomic read-modify-write one operation or two?
  18. C++ How is release-and-acquire achieved on x86 only using MOV?
  19. C++11: the difference between memory_order_relaxed and memory_order_consume
  20. How do memory_order_seq_cst and memory_order_acq_rel differ?
  21. Do I have to use atomic for “exit” bool variable?
  22. Does std::mutex create a fence?
  23. Understanding std::atomic::compare_exchange_weak() in C++11
  24. Are C/C++ fundamental types atomic?
  25. Double-Checked Lock Singleton in C++11
  26. [[carries_dependency]] what it means and how to implement
  27. Is a memory barrier required to read a value that is atomically modified?
  28. Thread pooling in C++11
  29. Memory order consume usage in C11
  30. Making a C++ class a Monitor (in the concurrent sense)

Leave a Comment