Acquire/Release versus Sequentially Consistent memory order

by

The C++11 memory ordering parameters for atomic operations specify constraints on the ordering. If you do a store with std::memory_order_release, and a load from another thread reads the value with std::memory_order_acquire then subsequent read operations from the second thread will see any values stored to any memory location by the first thread that were prior to the store-release, or a later store to any of those memory locations.

If both the store and subsequent load are std::memory_order_seq_cst then the relationship between these two threads is the same. You need more threads to see the difference.

e.g. std::atomic<int> variables x and y, both initially 0.

Thread 1:

x.store(1,std::memory_order_release);

Thread 2: 

y.store(1,std::memory_order_release);

Thread 3: 

int a=x.load(std::memory_order_acquire); // x before y
int b=y.load(std::memory_order_acquire);

Thread 4:

int c=y.load(std::memory_order_acquire); // y before x
int d=x.load(std::memory_order_acquire);

As written, there is no relationship between the stores to x and y, so it is quite possible to see a==1, b==0 in thread 3, and c==1 and d==0 in thread 4.

If all the memory orderings are changed to std::memory_order_seq_cst then this enforces an ordering between the stores to x and y. Consequently, if thread 3 sees a==1 and b==0 then that means the store to x must be before the store to y, so if thread 4 sees c==1, meaning the store to y has completed, then the store to x must also have completed, so we must have d==1.

In practice, then using std::memory_order_seq_cst everywhere will add additional overhead to either loads or stores or both, depending on your compiler and processor architecture. e.g. a common technique for x86 processors is to use XCHG instructions rather than MOV instructions for std::memory_order_seq_cst stores, in order to provide the necessary ordering guarantees, whereas for std::memory_order_release a plain MOV will suffice. On systems with more relaxed memory architectures the overhead may be greater, since plain loads and stores have fewer guarantees.

Memory ordering is hard. I devoted almost an entire chapter to it in my book.

More Related Contents:

  1. Will two atomic writes to different locations in different threads always be seen in the same order by other threads?
  2. c++, std::atomic, what is std::memory_order and how to use them?
  3. C++11 memory_order_acquire and memory_order_release semantics?
  4. When to use volatile with multi threading?
  5. Why is integer assignment on a naturally aligned variable atomic on x86?
  6. Can modern x86 hardware not store a single byte to memory?
  7. Where is the lock for a std::atomic?
  8. What do each memory_order mean?
  9. When do I really need to use atomic instead of bool? [duplicate]
  10. How to atomically update a maximum value?
  11. For purposes of ordering, is atomic read-modify-write one operation or two?
  12. C++ How is release-and-acquire achieved on x86 only using MOV?
  13. C++11: the difference between memory_order_relaxed and memory_order_consume
  14. How do memory_order_seq_cst and memory_order_acq_rel differ?
  15. Acquire/release semantics with 4 threads
  16. Do I have to use atomic for “exit” bool variable?
  17. [[carries_dependency]] what it means and how to implement
  18. Why set the stop flag using `memory_order_seq_cst`, if you check it with `memory_order_relaxed`?
  19. Can num++ be atomic for ‘int num’?
  20. Why don’t compilers merge redundant std::atomic writes?
  21. Atomic double floating point or SSE/AVX vector load/store on x86_64
  22. Atomicity on x86
  23. What exactly is std::atomic?
  24. Mixing C++11 atomics and OpenMP
  25. How to declare a vector of atomic in C++
  26. Can a bool read/write operation be not atomic on x86? [duplicate]
  27. C++ memory model and race conditions on char arrays
  28. Parallel Loops in C++
  29. Making a C++ class a Monitor (in the concurrent sense)
  30. How to perform atomic operations on Linux that work on x86, arm, GCC and icc?

Leave a Comment