使用获取释放内存排序的传递同步

Question

I have been following an example in a Book "C++ Concurrency in Action" to better understand acquire-release model, but I have some issues :

std::atomic<int> data[3];
std::atomic<bool> sinc1(false), sinc2(false);

void thread_1() {
    data[0].store(1,std::memory_order_relaxed);
    data[1].store(2,std::memory_order_relaxed);
    data[2].store(3,std::memory_order_relaxed);
    sinc1.store(true,std::memory_order_release);
}

void thread_2() {   
    while(!sinc1.load(std::memory_order_acquire))
    sinc2.store(true,std::memory_order_release);
}

void thread_3() {      
    while(!sinc2.load(std::memory_order_acquire))     
    assert(data[0].load(std::memory_order_relaxed)==1);
    std::cout << data[0] << std::endl;
    assert(data[1].load(std::memory_order_relaxed)==2);
    std::cout << data[1] << std::endl;
    assert(data[2].load(std::memory_order_relaxed)==3);
    std::cout  << data[2] << std::endl;
}

int main() {    
    std::thread t1(thread_1);
    std::thread t2(thread_2);
    std::thread t3(thread_3);
    t1.join();
    t2.join();
    t3.join();

    return 0;
}

Now, the store in sinc1 happen-before the load in sinc1 in thread_2, which is sequenced-before the store in sinc2. The store in sinc2 forms another release-acquire pair with load in sinc2 in thread_3, which happens-before the load of data. Because of transition, the store of data in thread_1 happens before of load of data in thread_3. The "asserts should NOT fire.

Instead when I run it sometime I get what i expect, but sometimes :

Assertion failed: (data[0].load(std::memory_order_relaxed)==1)....

I have 2 questions :

1. Am I missing something ?

2. when it does not fail I got these output:

either :

1 2 3  

or

0 1 2

Shouldn't the release-acquire memory model on sync1 give certain memory order on store data ?

Why do I use relaxed if I want follow a strick orders.

I understood I could reach certain order using relaxed and release together. But apparently it does not work

0 1 2

Someone could clarify me these points ?

Thank you.

Answer 1

From cppreference

memory_order_relaxed Relaxed ordering: there are no synchronization or ordering constraints, only atomicity is required of this operation.

C++14 has some further restrictions on the ordering that should not be applicable here.

void thread_1() {
    data[0].store(1,std::memory_order_relaxed);
    data[1].store(2,std::memory_order_relaxed);
    data[2].store(3,std::memory_order_relaxed);

---context switch---

These can now become visible to the other threads in "random" order as they guarantee only atomic operations. So the other threads can see any combination of 0/1, 0/2, 0/3 for example 0, 2, 0 but not 0, 1, 2 ... unless data had these values before start so change the first line to

std::atomic<int> data[3] = { -1,-1,-1 }; // lets make sure we know what we have

Before the last line in thread_1 finished

    sinc1.store(true,std::memory_order_release);
}

All previous writes to memory must have finished.

memory_order_release A store operation with this memory order performs the release operation: prior writes to other memory locations become visible to the threads that do a consume or an acquire on the same location.

Luckily thread_2 does an acquire on the same location

void thread_2() {   
    while(!sinc1.load(std::memory_order_acquire))  <----------- bug here missing ;
    sinc2.store(true,std::memory_order_release);
}

So while !sinc1 we set sinc2 to true I guess that was not what you wanted. To avoid problems like this always put a {} behind while.

Answer 2

The problem seems to be that your code misses ; after the while loops.

But otherwise I agree with you: with semicolons in both these places the assert must never fire and the code will always print 1 2 3 .