在C++中轻松的内存排序

Question

我想了解C++ 11的Relaxed Memory Ordering。我的理解是：

This ordering guarantees that the ordering of operations on a 
particular atomic variable doesn't change but ordering 
of operations of different atomic variables can change. The ordering here is 
within the same thread. For example, 

Thread 1 
operation A on atomic X 
operation B on atomic Y 
operation C on atomic Y 
operation D on atomic X 

Relaxed ordering guarantees that operation A will always happen-before 
operation D and operation B will always happen-before operation C. 
Having said that, the ordering of operations between X & Y can still change. 
That is, suppose the original code was like above. One possible execution 
order could be: 
operation A on atomic X 
operation D on atomic X 
operation B on atomic Y 
operation C on atomic Y 

如果我的理解错误，请纠正我。

我在下面写了一个示例代码来测试Relaxed Memory Ordering和预计assert有时会失败。但它永远不会失败。我建Visual Studio 2017这一计划，并与Intel(R) Core(TM) i7-6600U CPU@ 2.60GHz 2.80GHz

class RelaxedMemoryOrdering{ 
#define ARRAY_SIZE 4096 
public: 
    static int var_array[ARRAY_SIZE]; 
    RelaxedMemoryOrdering() { 
    for (int index = 0; index < ARRAY_SIZE; ++index) { 
     var_array[index] = 0; 
    } 
    sync1 = 0; 
    sync2 = 0; 
    sync3 = 0; 
    sync4 = 0; 
    sync5 = 0; 
    } 

    void thread1() { 
    sync1.store(1, std::memory_order_relaxed); 
    sync2.store(1, std::memory_order_relaxed); 
    sync3.store(1, std::memory_order_relaxed); 

    for (int index = 0; index < ARRAY_SIZE; ++index) { 
     var_array[index] = index + 1; 
    } 

    sync4.store(1, std::memory_order_relaxed); 
    sync5.store(1, std::memory_order_relaxed); 
    } 

    void thread2() { 
    while (!sync5.load(std::memory_order_relaxed)) { 
     ; 
    } 

    assert(sync4.load(std::memory_order_relaxed) == 1); 

    for (int index = 0; index < ARRAY_SIZE; ++index) { 
     assert(RelaxedMemoryOrdering::var_array[index] == (index + 1)); 
    } 

    assert(sync3.load(std::memory_order_relaxed) == 1); 
    assert(sync2.load(std::memory_order_relaxed) == 1); 
    assert(sync1.load(std::memory_order_relaxed) == 1); 
    } 

    void Test() { 
    std::thread t1(&RelaxedMemoryOrdering::thread1, this); 
    std::thread t2(&RelaxedMemoryOrdering::thread2, this); 
    t1.join(); 
    t2.join(); 
    } 

private: 
    std::atomic_int sync1{0}; 
    std::atomic_int sync2{0}; 
    std::atomic_int sync3{0}; 
    std::atomic_int sync4{0}; 
    std::atomic_int sync5{0}; 
}; 

static void TestRelaxedMemoryOrdering() { 
    while (1) { 
    { 
     RelaxedMemoryOrdering rmo; 
     rmo.Test(); 
    } 
    std::this_thread::sleep_for(std::chrono::milliseconds(10)); 
    }//while loop 
} 


int main() 
{ 
    TestRelaxedMemoryOrdering(); 
} 

Answer 1

在Intel x86架构的处理器上Windows 10运行时，MOV指令自动拥有获得释放语义，所以它可能无法观察到的重新排序，你会从宽松预期语义。但是，您不应该依赖于此，因为编译器仍然可以对指令进行重新排序以达到优化目的。

见https://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html