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上构建了此程序，并使用Windows 10

在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架构处理器上，MOV指令自动具有获取释放语义，因此可能无法观察到轻松语义所需的重新排序。但是，您不应该依赖于此，因为仍然允许编译器对指令进行重新排序以进行优化。

请参阅https://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html

用C ++编写的轻松内存排序

1 个答案: