c++ - 在具有获取一致性与宽松一致性的原子负载上旋转

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 是两个不同的物理核心(即，它们不是共同位于同一物理核心上的两个超线程)。上面的 Core 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 机器上)，或者做一些事情else 强制写入其他两个 CPU 的存储原子性。
第二个问题是屏障影响所有先前的负载，而不仅仅是 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();
      }
    }
  }