Скачать или смотреть Understanding memory_order_relaxed: Guarantees of Atomicity but Not Visibility

Discover how `memory_order_relaxed` in C+ + ensures atomicity when accessing shared variables, and why visibility across threads might not be guaranteed.
---
This video is based on the question https://stackoverflow.com/q/66067554/ asked by the user 'cmutex' ( https://stackoverflow.com/u/3124390/ ) and on the answer https://stackoverflow.com/a/66107935/ provided by the user 'j6t' ( https://stackoverflow.com/u/6868543/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: memory_order_relaxed only guarantees atomicity and not visibility?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding memory_order_relaxed: Guarantees of Atomicity but Not Visibility

In the realm of concurrent programming, especially when using languages like C or C+ + , developers often grapple with complex concepts regarding memory operations. One popular topic is the behavior of the memory_order_relaxed in atomic operations.

The Problem: Can memory_order_relaxed Result in Incorrect Values?

Consider the following scenario: you have a shared variable a_i, and two threads are executing a function f() that increments this variable 100 times each. The code snippet looks like this:

[[See Video to Reveal this Text or Code Snippet]]

When both threads concurrently call f(), you might wonder if the resulting value of a_i could ever be less than 200, especially on hardware platforms with relaxed cache coherency protocols. Specifically, does memory_order_relaxed guarantee only atomic actions while leaving the visibility of writes between threads ambiguous?

The Solution: Guaranteed Results and Memory Order

Understanding Atomicity

The good news is that in this specific case, the resulting value of a_i will always be 200. Here’s why:

Atomic Operations: The atomic_fetch_add_explicit() function is designed to ensure that operations on a_i are atomic. This means each increment operation is executed as a single, uninterrupted step. No thread can see a partial state of the variable during its update.

Concurrence: Even if two threads are modifying a_i simultaneously, due to the atomic nature of the operation, each addition is performed in entirety without interference.

Memory Order Relaxation

However, the term memory_order_relaxed comes into play here. While it guarantees atomic updates, it does not make additional guarantees about visibility between threads. Here's how this works:

Visibility Guarantees: The memory_order_relaxed option does not ensure that changes made by one thread are immediately visible to the other thread. Essentially, while operations on a_i remain atomic, the state of a_i across threads post-operation may not be consistently perceived.

Implication: For example, a thread might be working with a cached version of a_i that hasn’t been updated due to delays in cache coherency. As a result, one thread’s increments might not be reflected in another thread’s view of a_i at all times.

Conclusion

In summary, memory_order_relaxed allows developers to optimize performance by eliminating unnecessary synchronization between threads while ensuring atomic updates. This can lead to significant performance improvements, but it comes with the caveat that one must carefully consider the implications of visibility across threads.

Bottom Line: When using memory_order_relaxed, rest assured that atomicity is preserved, but always design your concurrency logic with visibility in mind, especially across various hardware platforms.

Understanding the nuances of atomic operations and memory effects in concurrent programming can be challenging, but acknowledging the balance between atomicity and visibility can help you eat up the complexities of multi-threaded development.