在具有获取一致性与松散一致性的原子负载上自旋

Question

考虑以下代码：

// Class member initialization:
std::atomic<bool> ready_ = false;

...

// Core A:
while (!ready_.load(std::memory_order_acquire)) {
  // On x86, you would probably put a `pause` instruction here.
}
// Core A now accesses memory written by Core B.

...

// Core B:
// Core B writes memory.
ready_.store(true, std::memory_order_release);

假设核心 A 和核心 B 是两个不同的物理核心（即，它们不是位于同一物理核心上的两个超线程）。核心 A 上面的代码比下面的代码性能更差还是性能相等？请注意，Core A 只是在加载；这不是涉及写入的经典比较交换示例。我对几种架构的答案很感兴趣。

// Core A:
while (!ready_.load(std::memory_order_relaxed)) {
  // On x86, you would probably put a `pause` instruction here.
}
std::atomic_thread_fence(std::memory_order_acquire);
// Core A now accesses memory written by Core B.

此 reference page 上的邮箱代码暗示底部代码具有更好的性能，因为底部代码避免了“不必要的同步”。但是，邮箱代码在许多原子上迭代，因此获取一致性的同步开销是一个问题，因为您可以使用宽松的一致性来避免对不属于您的邮箱进行排序约束。我不清楚在单个获取负载上旋转对性能有何影响。

Answer 1

有两种方式可以使第一种代码的效率低于第二种，至少在某些假设的体系结构上是这样。在 x86 上，我的猜测是它们编译为相同的代码。

第一个问题是原子加载可能会影响其他处理器的性能。在 alpha 上，这通常是研究内存一致性的一个很好的“异常值”案例，你会一遍又一遍地发出内存屏障指令，这可能会锁定内存总线（在非 NUMA 机器上），或者做一些事情否则强制由另外两个 CPUs.

写入存储的原子性

第二个问题是屏障会影响所有之前的负载，而不仅仅是 ready_ 的负载。因此，也许在 NUMA 机器上，ready_ 实际上命中了缓存，因为没有争用，并且您的 CPU 已经以独占模式缓存它，但是之前的一些加载正在等待内存系统。现在您必须停止 CPU 以等待之前的加载，而不是可能继续执行与停止的加载不冲突的指令。这是一个例子：

int a = x.load(memory_order_relaxed);
while (!ready_.load(std::memory_order_relaxed))
  ;
std::atomic_thread_fence(std::memory_order_acquire);
int b = y;

在这种情况下，y 的加载可能会等待 x，而如果 ready_ 的加载是通过获取语义完成的，那么 x 可以并行继续，直到需要该值。

出于第二个原因，您实际上可能想要以不同方式构建自旋锁。以下是 Erik Rigtorp 建议如何在 x86 上实现自旋锁，您可以轻松地适应您的用例：

  void lock() {
    for (;;) {
      if (!lock_.exchange(true, std::memory_order_acquire)) {
        break;
      }
      while (lock_.load(std::memory_order_relaxed)) {
        __builtin_ia32_pause();
      }
    }
  }

在具有获取一致性与松散一致性的原子负载上自旋

Spinning on an atomic load with acquire consistency vs. relaxed consistency

c++

atomic

stdatomic