Understanding `memory_order_acquire` and `memory_order_release` in C++11

Question

I'm reading through the documentation and more specifically

memory_order_acquire: A load operation with this memory order performs the acquire operation on the affected memory location: no reads or writes in the current thread can be reordered before this load. All writes in other threads that release the same atomic variable are visible in the current thread (see Release-Acquire ordering below).

memory_order_release: A store operation with this memory order performs the release operation: no reads or writes in the current thread can be reordered after this store. All writes in the current thread are visible in other threads that acquire the same atomic variable (see Release-Acquire ordering below) and writes that carry a dependency into the atomic variable become visible in other threads that consume the same atomic (see Release-Consume ordering below)

These two bits:

from memory_order_acquire

... no reads or writes in the current thread can be re-ordered before this load...

from memory_order_release

... no reads or writes in the current thread can be re-ordererd after this store...

What exactly do they mean?

There's also this example

#include <thread>
#include <atomic>
#include <cassert>
#include <string>

std::atomic<std::string*> ptr;
int data;

void producer()
{
    std::string* p  = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == "Hello"); // never fires
    assert(data == 42); // never fires
}

int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

But I cannot really figure where the two bits I've quoted apply. I understand what's happening but I don't really see the re-ordering bit because the code is small.

rustyx rustyx · Accepted Answer · 2020-01-07T11:55:10

The work done by a thread is not guaranteed to be visible to other threads.

To make data visible between threads, a synchronization mechanism is needed. A non-relaxed atomic or a mutex can be used for that. It's called the acquire-release semantics. Writing a mutex "releases" all memory writes before it and reading the same mutex "acquires" those writes.

Here we use ptr to "release" work done so far (data = 42) to another thread:

    data = 42;
    ptr.store(p, std::memory_order_release); // changes ptr from null to not-null

And here we wait for that, and by doing that we synchronize ("acquire") the work done by the producer thread:

    while (!ptr.load(std::memory_order_acquire)) // assuming initially ptr is null
        ;
    assert(data == 42);

Note two distinct actions:

we wait between threads (the synchronization step)
as a side effect of the wait, we get to transfer work from the provider to the consumer (the provider releases and the consumer acquires it)

In the absence of (2), e.g. when using memory_order_relaxed, only the atomic value itself is synchronized. All other work done before/after isn't, e.g. data won't necessarily contain 42 and there may not be a fully constructed string instance at the address p (as seen by the consumer).

For more details about acquire/release semantics and other details of the C++ memory model I would recommend watching Herb's excellent atomic<> weapons talk on channel9, it's long but is fun to watch. And for even more details there's a book called "C++ Concurrency in Action".

Understanding `memory_order_acquire` and `memory_order_release` in C++11

3 Answers