是否应该将内存栅栏与互斥获取交换循环（或队列获取加载循环）结合起来，还是应该避免？

假设重复获取操作，尝试加载或交换值，直到观察到的值是所需值。

让我们来cppreference 原子标志示例作为起点：

void f(int n)
{
    for (int cnt = 0; cnt < 100; ++cnt) {
        while (lock.test_and_set(std::memory_order_acquire))  // acquire lock
             ; // spin
        std::cout << "Output from thread " << n << '\n';
        lock.clear(std::memory_order_release);               // release lock
    }
}

现在让我们考虑一下这种旋转的增强。两个著名的是：

• 不要永远旋转，而是在某个时刻进入操作系统等待；
• 使用指令，例如pause or yield而不是无操作旋转。

我可以想到第三种，我想知道它是否有意义。 我们可以用std::atomic_thread_fence对于获取语义：

void f(int n)
{
    for (int cnt = 0; cnt < 100; ++cnt) {
        while (lock.test_and_set(std::memory_order_relaxed))  // acquire lock
             ; // spin
        std::atomic_thread_fence(std::memory_order_acquire);  // acquire fence
        std::cout << "Output from thread " << n << '\n';
        lock.clear(std::memory_order_release);               // release lock
    }
}

我预计对于 x86 来说这不会有任何变化。

我在想：

• 在存在差异的平台（ARM）上，此更改是否有好处或缺点？
• 是否会干扰使用或不使用的决定yield操作说明？

我不仅感兴趣atomic_flag::clear / atomic_flag::test_and_set一对，我也感兴趣atomic<uint32_t>::store / atomic<uint32_t>::load pair.

更改为松弛负载可能是有意义的：

void f(int n)
{
    for (int cnt = 0; cnt < 100; ++cnt) {
        while (lock.test_and_set(std::memory_order_acquire))  // acquire lock
             while (lock.test(std::memory_order_relaxed))
                 YieldProcessor(); // spin
        std::cout << "Output from thread " << n << '\n';
        lock.clear(std::memory_order_release);               // release lock
    }
}

是的，避免失败重试路径内的获取障碍的总体想法可能是有用的，尽管如果您只是旋转，则失败情况下的性能几乎不相关。pause or yield节省电力。在 x86 上，pause还提高了 SMT 友好性，并避免在另一个核心修改了您正在旋转的内存位置后离开循环时内存顺序错误推测。

但这就是为什么 CAS 有单独的memory_order成功和失败的参数。宽松的失败可以让编译器仅在离开循环路径上设置障碍。

atomic_flag test_and_set但没有这个选项。手动执行此操作可能会损害像 AArch64 这样的 ISA，这些 ISA 本来可以获取 RMW 并避免显式的栅栏指令。 （例如与ldarb)

Godbolt：原始循环与lock.test_and_set(std::memory_order_acquire):

# AArch64 gcc8.2 -O3
.L6:                            # do{
    ldaxrb  w0, [x19]           # acquire load-exclusive
    stxrb   w1, w20, [x19]      # relaxed store-exclusive
    cbnz    w1, .L6            # LL/SC failure retry
    tst     w0, 255
    bne     .L6             # }while(old value was != 0)
  ... no barrier after this

（是的，它看起来像是一个错过的优化，它只测试低 8 位tst而不仅仅是cbnz w1, .L6)

while(宽松的RMW) +std::atomic_thread_fence(std::memory_order_acquire);

.L14:                          # do {
    ldxrb   w0, [x19]             # relaxed load-exclusive
    stxrb   w1, w20, [x19]        # relaxed store-exclusive
    cbnz    w1, .L14             # LL/SC retry
    tst     w0, 255
    bne     .L14               # }while(old value was != 0)
    dmb     ishld         #### Acquire fence
   ...

对于 32 位 ARMv8 来说更糟 where dmb ishld不可用，或者编译器不使用它。你会得到一个dmb ish全屏障。

Or with -march=armv8.1-a

.L2:
    swpab   w20, w0, [x19]
    tst     w0, 255
    bne     .L2
    mov     x2, 19
  ...

vs.

.L9:
    swpb    w20, w0, [x19]
    tst     w0, 255
    bne     .L9
    dmb     ishld                   # acquire barrier (load ordering)
    mov     x2, 19
...