不能像 store 那样在 x86 上通过稍后加载来放松原子 fetch_add 重新排序吗？

Question

这个程序有时会打印 00，但是如果我注释掉 a.store 和 b.store 并取消注释 a.fetch_add 和 b.fetch_add，它们会做完全相同的事情，即都设置a=1,b=1 的值，我从来没有得到 00。（在 x86-64 Intel i3 上测试，使用 g++ -O2）

我是不是遗漏了什么，或者“00”是不是按照标准永远不会出现？

这是plain store的版本，可以打印00。

// g++ -O2 -pthread axbx.cpp  ; while [ true ]; do ./a.out  | grep "00" ; done
#include<cstdio>
#include<thread>
#include<atomic>
using namespace std;
atomic<int> a,b;
int reta,retb;

void foo(){
        //a.fetch_add(1,memory_order_relaxed);
        a.store(1,memory_order_relaxed);
        retb=b.load(memory_order_relaxed);
}

void bar(){
        //b.fetch_add(1,memory_order_relaxed);
        b.store(1,memory_order_relaxed);
        reta=a.load(memory_order_relaxed);
}

int main(){
        thread t[2]{ thread(foo),thread(bar) };
        t[0].join(); t[1].join();
        printf("%d%d\n",reta,retb);
        return 0;
}

下面从不打印 00

// g++ -O2 -pthread axbx.cpp  ; while [ true ]; do ./a.out  | grep "00" ; done
#include<cstdio>
#include<thread>
#include<atomic>
using namespace std;
atomic<int> a,b;
int reta,retb;

void foo(){
        a.fetch_add(1,memory_order_relaxed);
        //a.store(1,memory_order_relaxed);
        retb=b.load(memory_order_relaxed);
}

void bar(){
        b.fetch_add(1,memory_order_relaxed);
        //b.store(1,memory_order_relaxed);
        reta=a.load(memory_order_relaxed);
}

int main(){
        thread t[2]{ thread(foo),thread(bar) };
        t[0].join(); t[1].join();
        printf("%d%d\n",reta,retb);
        return 0;
}

也看看这个

Answer 1

我在这两种情况下都得到了“10”。第一个线程总是运行更快 a == 1！但是如果你在 foo()

中添加额外的操作

#include<cstdio>
#include<thread>
#include<atomic>
using namespace std;
atomic<int> a,b;
int reta,retb;

void foo(){

    int i=0;
    while(i < 10000000)
        i++;

    a.fetch_add(1,memory_order_relaxed);
    //a.store(1,memory_order_relaxed);
    retb=b.load(memory_order_relaxed);
}

void bar(){
    b.fetch_add(1,memory_order_relaxed);
    //b.store(1,memory_order_relaxed);
    reta=a.load(memory_order_relaxed);
}

int main(){
    thread t[2]{ thread(foo),thread(bar) };
    t[0].join(); t[1].join();
    printf("%d%d\n",reta,retb);
    return 0;
}

您将收到“01”！

Answer 2

这个问题的关键是要认识到 relaxed memory ordering 不能保证线程之间的同步：

Atomic operations tagged memory_order_relaxed are not synchronization operations; they do not impose an order among concurrent memory accesses. They only guarantee atomicity and modification order consistency.

因此在第一个代码中，可能会发生不同的情况。例如：

首先执行 foo() 线程中的代码，然后执行 bar() 线程：retb 为 0，reta 为 1，因此您将得到 10。
首先执行 bar() 线程中的代码，然后执行 foo() 线程：reta 为 0，retb 为 1，因此您将得到 01。
foo() 和 bar() 线程中的代码同时一条一条地执行。那么 reta 和 retb 都是 1，你会得到 11.
宽松的内存排序也允许不同步的情况：两个线程都更新它们的原子并查看它们的当前原子值，但看到另一个线程的未同步值（即原子更改之前的值）。所以你可以 reta 和 retb 在 0 得到你 00.

第二个代码遇到了同样的问题，因为它的顺序很宽松，并且用于设置 reta 和 retb 的访问是对在另一个线程中修改的原子的只读访问。你可以拥有所有四种可能性。

如果你想确保同步按预期发生，你需要确保所有原子操作之间的全局顺序，因此使用 memory_order_seq_cst。这将排除 00 但仍然保留所有其他可能的组合。

（注意：我之前使用 memory_order_acquire 的建议确实不够，因为它仍然保证跨线程对不同原子的操作没有顺序，正如 Peter 在评论中所解释的那样)

Answer 3

标准允许 00，但您永远不会在 x86 上获得它（没有编译时重新排序）。在 x86 上实现原子 RMW 的唯一方法，这是一个“完整的屏障”，足以满足 seq_cst.

在 C++ 术语中，在为 x86 编译时，atomic RMW 被有效地提升为 seq_cst。（只有在可能的编译时排序被确定之后——例如，非原子加载/存储可以通过一个宽松的 fetch_add 重新排序/组合，其他轻松的操作也可以，以及使用获取或释放操作的单向重新排序。尽管编译器不太可能相互重新排序原子操作，因为 , and doing so is one of the 用于编译时重新排序。）

事实上，大多数编译器通过使用 xchg（具有隐含的 lock 前缀）来实现 a.store(1, mo_seq_cst)，因为它比 mov + mfence 在现代 CPU 上，将 0 变成 1 并使用 lock add 作为对每个对象的唯一写入是完全相同的。有趣的事实：只需存储和加载，您的代码将编译为与 https://preshing.com/20120515/memory-reordering-caught-in-the-act/ 相同的 asm，因此那里的讨论适用。

ISO C++ 允许整个宽松的 RMW 使用宽松的负载重新排序，但普通编译器不会在编译时无缘无故地这样做。（DeathStation 9000 C++ 实现 could/would）。所以您终于找到了在不同的 ISA 上进行测试很有用的情况。原子 RMW（或什至它的一部分）可以在运行时间重新排序的方式在很大程度上取决于 ISA。

一个 LL/SC machine that needs a retry loop to implement fetch_add (for example ARM, or AArch64 before ARMv8.1) may be able to truly implement a relaxed RMW that can reorder at run-time because anything stronger than relaxed would require barriers. (Or acquire / release versions of the instructions like ldaxr / stlxr 对比 ldxr/stxr）。因此，如果 relaxed 和 acq and/or rel 之间存在 asm 差异（有时 seq_cst 也不同），则可能需要差异并防止一些运行-time 重新排序。

即使是单指令原子操作，在 AArch64 上也可能真正放松；我没有调查过。大多数弱序 ISA 传统上使用 LL/SC 原子，所以我可能只是将它们混为一谈。

在 LL/SC 机器中，LL/SC RMW 的存储端甚至可以与负载分开重新排序，除非它们都是 seq_cst。 For purposes of ordering, is atomic read-modify-write one operation or two?

要真正看到 00，两次加载都必须在 RMW 的存储部分在另一个线程中可见之前发生。是的，我认为 LL/SC 机器中的硬件重新排序机制与重新排序普通商店非常相似。

不能像 store 那样在 x86 上通过稍后加载来放松原子 fetch_add 重新排序吗？

Can't relaxed atomic fetch_add reorder with later loads on x86, like store can?

c++

multithreading

cpu-architecture

memory-barriers

stdatomic