Understanding Atomic Variables in C+ + : Do They Require Locks for Read-Modify-Store Operations?

A deep dive into whether atomic variables in C+ + need locking for read-modify-store operations, with clear examples and insights into the mechanics behind atomicity across different architectures.
---
This video is based on the question stackoverflow.com/q/67034400/ asked by the user 'SungJinKang' ( stackoverflow.com/u/7138899/ ) and on the answer stackoverflow.com/a/67034919/ provided by the user 'Lintong He' ( stackoverflow.com/u/9742394/ ) 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: atomic variable also require lock on read-modify-store operation?

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

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Atomic Variables in C+ + : Do They Require Locks for Read-Modify-Store Operations?

In the realm of multithreading and concurrency in C+ + , atomic variables provide a means to handle shared data without the need for traditional locking mechanisms. However, there is often confusion about whether certain operations, specifically read-modify-store methods, require additional locking to ensure thread safety. Let’s break this down for better understanding.

The Core of the Confusion

The concern arises when considering operations like std::atomic::fetch_add, which modifies an atomic variable. The question at hand is: Does this operation actually execute atomically? And if so, does it inherently require locking to prevent interference from other operations?

Clarifying Atomic Operations

Lock-Free Nature: Atomic operations are generally considered lock-free. This means that these operations do not block threads; instead, they utilize hardware support to manage concurrent access to shared data.

Read-Modify-Store Operations: Operations such as fetch_add involve multiple steps:

Read the current value

Add a specified value to it

Store the new result back

While this appears to be a multi-step operation, atomic variables ensure that these steps happen in a way that other threads cannot interject between the read and store phases.

Architectures and Locking Mechanisms

Early x86 Architecture

In earlier x86 architectures, atomic operations utilized a LOCK prefix to maintain coherence, which effectively locked the memory bus. Here’s what that meant:

Inefficient: Locking the bus is costly in terms of performance, as other CPU cores are prevented from accessing the bus during this lock.

Modern x86 Processors

Modern x86 processors implement atomic operations efficiently through hardware that typically uses the Compare-And-Swap (CAS) instruction. This means that:

No Bus Locking: Instead of locking the entire bus, these implementations allow local cache blocks to be managed, leading to less contention among CPU threads.

Example Code of Atomic Operation

To illustrate how atomic operations are executed, let’s look at a simple example using std::atomic in C+ + :

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

Breakdown of the Assembly Translation

When compiled, the do_work function translates into assembly instructions that utilize lock xadd for atomicity:

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

Conclusion

In conclusion, while atomic variables do not require traditional locking mechanisms for read-modify-store operations, the implementation details can vary significantly across architectures. Understanding the context and mechanics behind these operations can help developers write efficient and thread-safe code without unnecessary locking overhead.

By leveraging atomic variables correctly, you can achieve safe multithreaded applications while minimizing contention and maximizing performance.