C＆＃x2b;＆＃x2B;

Question

我已经阅读了有关std :: memory_order在C ++中的信息，并部分理解。但是我仍然对此有一些疑问。

1. no读取或写入。这是否意味着编译器和CPU不允许移动获取语句下方的任何指令？

auto y = x.load(std::memory_order_acquire);
z = a;  // is it leagal to execute loading of shared `b` above acquire? (I feel no)
b = 2;  // is it leagal to execute storing of shared `a` above acquire? (I feel yes)

我可以理解为什么在获取之前执行加载是非法的。但是，为什么这对商店来说是非法的呢？

2. 从aromic对象跳过无用的加载或存储是非法的吗？由于它们不是挥发性，而且据我所知，只有挥发性才有此要求。

auto y = x.load(std::memory_order_acquire);  // `y` is never used
return;

即使使用放松内存顺序，这种优化也不会发生。

3. 是否允许编译器移动上面存在的指令获取语句，下面是吗？

z = a;  // is it leagal to execute loading of shared `b` below acquire? (I feel yes)
b = 2;  // is it leagal to execute storing of shared `a` below acquire? (I feel yes)
auto y = x.load(std::memory_order_acquire);

4. 可以在不交叉获得边界的情况下重新排序两个负载或商店吗？

auto y = x.load(std::memory_order_acquire);
a = p;  // can this move below the below line?
b = q;  // shared `a` and `b`

与发行语义相似和相应的4个疑问。

与第二和第三个问题有关，为什么没有编译器是优化f（f（），，如下代码中的g（）具有积极性吗？

#include <atomic>

int a, b;

void dummy(int*);

void f(std::atomic<int> &x) {
    int z;
    z = a;  // loading shared `a` before acquire
    b = 2;  // storing shared `b` before acquire
    auto y = x.load(std::memory_order_acquire);
    z = a;  // loading shared `a` after acquire
    b = 2;  // storing shared `b` after acquire
    dummy(&z);
}

void g(int &x) {
    int z;
    z = a;
    b = 2;
    auto y = x;
    z = a;
    b = 2;
    dummy(&z);
}

f(std::atomic<int>&):
        sub     rsp, 24
        mov     eax, DWORD PTR a[rip]
        mov     DWORD PTR b[rip], 2
        mov     DWORD PTR [rsp+12], eax
        mov     eax, DWORD PTR [rdi]
        lea     rdi, [rsp+12]
        mov     DWORD PTR b[rip], 2
        mov     eax, DWORD PTR a[rip]
        mov     DWORD PTR [rsp+12], eax
        call    dummy(int*)
        add     rsp, 24
        ret
g(int&):
        sub     rsp, 24
        mov     eax, DWORD PTR a[rip]
        mov     DWORD PTR b[rip], 2
        lea     rdi, [rsp+12]
        mov     DWORD PTR [rsp+12], eax
        call    dummy(int*)
        add     rsp, 24
        ret
b:
        .zero   4
a:
        .zero   4

Answer 1

Q1

通常，是的。任何负载或Store （按程序顺序）收购负载，在其之前不得可见。

这是一个重要的示例：

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> x{0};
std::atomic<bool> finished{false};
int xval;
bool good;

void reader() {
    xval = x.load(std::memory_order_relaxed);
    finished.store(true, std::memory_order_release);
}

void writer() {
    good = finished.load(std::memory_order_acquire);
    x.store(42, std::memory_order_relaxed);
}

int main() {
    std::thread t1(reader);
    std::thread t2(writer);
    t1.join();
    t2.join();
    if (good) {
        std::cout << xval << std::endl;
    } else {
        std::cout << "too soon" << std::endl;
    }
    return 0;
}

尝试使用Godbolt

此程序无UB，必须打印<<代码> 0 或太早。如果Writer在完成的加载之前，可以重新排序42至x的存储，那么Reader < /code> x返回42和writer 完成返回 true 的加载，在这种情况下，程序会不当打印42。

Q2

是的，编译器可以删除从未使用的值的原子负载，因为没有办法适应程序来检测负载是否完成。但是，当前的编译器通常不进行此类优化。部分出于谨慎的态度，因为对原子的优化很难正确，并且错误可能非常微妙。这也可能部分是支持程序员编写与实现相关的代码，该代码能够通过非标准功能检测到负载是否完成。

Q3

是的，这种重新排序是完全合法的，现实世界的架构将做到这一点。获取障碍只是一种方式。

Q4

是的，这也是合法的。如果a，b不是原子，而其他一些线程正在同时读取它们，则代码具有数据竞赛，并且是UB，因此，如果其他线程观察到在此中发生的写入，则可以错误的订单（或召唤鼻恶魔）。 （如果它们是原子质，并且您正在做放松的商店，那么您将无法获得鼻恶魔，但是您仍然可以从订单中观察商店；在关系之前没有发生相反的关系。）

优化比较

您的f vers g示例并不是一个公平的比较：在g中，非原子变量的加载x没有副作用及其值不使用，因此编译器完全省略了它。如上所述，编译器不会忽略x在f中的不必要的原子负载。

关于为什么编译器不陷入a和b之后的a> b 的原因：我相信这只是错过的优化。同样，大多数编译器故意不会尝试通过原子来进行所有可能的法律优化。但是，您可以注意到，在ARM64上，x的负载 f 编译为ldar，CPU肯定可以通过早期重新排序普通载荷和存储