Atomic Read-Modify-Write with `std::atomic`

1. The Problem: The Anatomy of an Increment

At first glance, an operation like counter++ seems like a single, indivisible step. However, for the CPU, it's a three-part sequence known as a read-modify-write (RMW) operation:

1. Read: Load the current value of counter from memory into a CPU register.
2. Modify: Increment the value in the register.
3. Write: Store the new value from the register back into memory.

When multiple threads execute this sequence on the same variable concurrently, a "data race" can occur. A thread's operation can be preempted between any of these steps, leading to lost updates and incorrect results.

To see this in action, the following video provides a clear, practical demonstration of this exact problem.

As you saw, the problem is that there is no guarantee of atomicity. Another thread can modify the shared variable in the tiny window between one thread's read and its subsequent write, causing that thread's update to be lost.

2. The Solution: std::atomic

C++11 introduced the std::atomic template library (<atomic>) to solve this. By wrapping a variable in std::atomic, you instruct the compiler to use special, hardware-assisted instructions that guarantee any operation on that variable is indivisible.

#include <atomic>

// A non-atomic integer, vulnerable to data races
int regular_counter = 0;

// An atomic integer, safe for concurrent access
std::atomic<int> atomic_counter = 0;

When you perform an operation like atomic_counter++, the compiler generates code that ensures the entire read-modify-write sequence completes as a single, uninterruptible transaction. Other threads will see the state of atomic_counter either before the increment or after it, but never an intermediate state.

The following segment from a talk by Fedor Pikus at CppCon explains how std::atomic works at a conceptual level and introduces some of the key operations.

Built-in Read-Modify-Write Operations

As the video discussed, std::atomic provides several convenient RMW member functions for integer and pointer types:

• fetch_add(): Atomically adds a value and returns the old value.
• fetch_sub(): Atomically subtracts a value and returns the old value.
• fetch_and(), fetch_or(), fetch_xor(): Atomically perform bitwise operations and return the old value.
• exchange(): Atomically replaces the current value with a new one and returns the old value.

The overloaded operators like ++, --, and += are also atomic RMW operations. However, be extremely careful: a seemingly simple expression can hide a data race.

For std::atomic<int> x;:

• x++ is a single atomic operation.
• x = x + 1; is not a single atomic operation. This decomposes into an atomic load() from x, followed by an addition, followed by an atomic store() back to x. Another thread can modify x between the load and the store. For this reason, it's safer and clearer to use the member functions (x.fetch_add(1)) or the dedicated operators (x++, x += 1).

3. The Universal Tool: Compare-and-Swap (CAS)

The built-in operations are great, but what if you need to perform a custom RMW operation that isn't provided, like an atomic multiply, max, or a more complex update?

For this, C++ provides a universal building block: compare-and-swap (CAS). The most common form is the compare_exchange_strong() member function.

Its logic is as follows:
"Atomically, compare the current value of the atomic variable with an expected value. If they match, update the variable to a new desired value and report success (true). If they don't match, do nothing to the variable, but update my expected value with the variable's current value and report failure (false)."

To see how this powerful primitive works, let's study a classic article on the topic.

4. Performing a Custom RMW with a CAS Loop

As the article demonstrates, you can perform any RMW operation by placing it inside a CAS loop. This pattern is the foundation of countless lock-free algorithms. Let's break down the fetch_multiply implementation from the article:

// A custom atomic operation to multiply a value and return the old value.
int fetch_multiply(std::atomic<int>& shared, int multiplier) {
    int oldValue = shared.load(); // 1. Load the current value.
    
    // 4. Loop until the CAS succeeds.
    while (!shared.compare_exchange_weak(oldValue, oldValue * multiplier)) {
        // 5. If CAS fails, oldValue is automatically updated by the function
        // with the latest value from 'shared'. The loop then retries.
    }

    // 2. The CAS call attempts the RMW.
    // 3. 'oldValue' is compared with 'shared'. If they match, 'shared' becomes
    //    'oldValue * multiplier'. The loop condition becomes false, and we exit.
    
    return oldValue; // 6. Return the value from the successful attempt.
}

The logic of the loop:

1. We start by loading the current value of shared into a local variable, oldValue.
2. We then call compare_exchange_weak. It expects the current value of shared to be oldValue. If it is, it atomically updates shared to oldValue * multiplier and returns true. The while loop terminates.
3. However, if another thread modified shared between our load() and our compare_exchange_weak() call, the CAS operation will fail.
4. When it fails, it does two things: it returns false (so the loop continues), and importantly, it updates oldValue with the new value from shared.
5. The loop immediately retries with this fresh value of oldValue.

This "try, and if you fail, get the new value and try again" loop guarantees that the entire fetch_multiply function behaves as a single, atomic operation, without ever using a lock.

int atomic_fetch_max(std::atomic<int>& shared, int val) {
    // Your implementation here
}

int atomic_fetch_max(std::atomic<int>& shared, int val) {
    int oldValue = shared.load();
    int newValue = (val > oldValue) ? val : oldValue;

    // Keep trying to swap until we succeed.
    // If another thread sets a new maximum, 'oldValue' will be updated by CAS,
    // and our next loop iteration will correctly compare against the new max.
    while (newValue > oldValue && !shared.compare_exchange_weak(oldValue, newValue)) {
        // If the CAS fails, oldValue is now updated with the latest value.
        // We recalculate what the new desired value should be.
        newValue = (val > oldValue) ? val : oldValue;
    }
    
    return oldValue;
}

Conclusion

You've just taken a significant step into the world of low-level concurrency. Understanding and using atomic RMW operations is essential for writing high-performance, lock-free code.

Key Takeaways:

• Simple expressions like i++ are actually multi-step read-modify-write (RMW) sequences, which cause data races in multithreaded code.
• std::atomic guarantees that operations on a variable are indivisible (atomic) by using special hardware instructions.
• std::atomic provides built-in RMW functions like fetch_add() and exchange().
• For any custom atomic operation, you can use the compare-and-swap (CAS) loop pattern with compare_exchange_strong or compare_exchange_weak. This is a universal tool for lock-free programming.

What's Next?

So far, we've focused on the atomicity of operations—ensuring they are indivisible. However, there is a second, equally important aspect: memory ordering. How does an atomic operation on one CPU core become visible to another? What guarantees do we have about the order in which different threads see memory writes?

In the next lesson, we will explore the 'happens-before' relationship and the different C++ memory models. This will complete the theoretical picture you need to correctly implement your lock-free ring buffer.