我正在运行一个线程，该线程一直运行到设置标志为止。

std::atomic<bool> stop(false);

void f() {
  while(!stop.load(std::memory_order_{relaxed,acquire})) {
    do_the_job();
  }
}

我想知道编译器是否可以像这样展开循环(我不希望它发生)。

void f() {
  while(!stop.load(std::memory_order_{relaxed,acquire})) {
    do_the_job();
    do_the_job();
    do_the_job();
    do_the_job();
    ... // unroll as many as the compiler wants
  }
}

据说波动性和原子性是正交的，但我有点困惑。编译器是否可以自由缓存原子变量的值并展开循环？如果编译器可以展开循环，那么我认为我必须将 volatile 放入标志中，并且我想确定。

我应该放 volatile 吗？

我很抱歉模棱两可。我(想我)理解什么是重新排序以及 memory_order_* 的含义，并且我确信我完全理解 volatile 是什么。

我认为 while() 循环可以像这样转换为无限的 if 语句。

void f() {
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  do_the_job();
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  do_the_job();
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  do_the_job();
  ...
}

由于给定的内存顺序不会阻止前序操作移过原子负载，我认为如果它没有 volatile，它可以重新排列。

void f() {
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  if(stop.load(std::memory_order_{relaxed,acquire})) return;
  ...
  do_the_job();
  do_the_job();
  do_the_job();
  ...
}

如果原子不意味着 volatile ，那么我认为代码在最坏的情况下甚至可以像这样转换。

void f() {
  if(stop.load(std::memory_order_{relaxed,acquire})) return;

  while(true) {
    do_the_job();
  }
}

永远不会有如此疯狂的实现，但我想这仍然是一种可能的情况。我认为防止这种情况的唯一方法是将 volatile 放入原子变量并询问它。

我做了很多猜测，如果其中有什么问题，请告诉我。

最佳答案

Is the compiler free to cache the value of the atomic variable and unroll the loop?

编译器无法缓存原子变量的值。

但是，由于您使用的是 std::memory_order_relaxed，这意味着编译器可以自由地重新排序从/到这个原子变量的加载和存储，以考虑其他加载和存储。

另外请注意，对在此翻译单元中不可用定义的函数的调用是编译器内存屏障。这意味着调用不能根据周围的加载和存储重新排序，并且所有非局部变量必须在调用后从内存中重新加载，就好像它们都被标记为 volatile 一样。 (但地址未在其他地方传递的局部变量不会被重新加载)。

您希望避免的代码转换不是有效的转换，因为这会违反 C++ 内存模型:在第一种情况下，您先加载一个原子变量，然后调用do_the_job，第二个，你有多个调用。观察到的转换代码的行为可能会有所不同。

还有来自 std::memory_order 的注释:

Relationship with volatile

Within a thread of execution, accesses (reads and writes) to all volatile objects are guaranteed to not be reordered relative to each other, but this order is not guaranteed to be observed by another thread, since volatile access does not establish inter-thread synchronization.

In addition, volatile accesses are not atomic (concurrent read and write is a data race) and do not order memory (non-volatile memory accesses may be freely reordered around the volatile access).

该位非 volatile 内存访问可以围绕 volatile 访问自由重新排序对于宽松原子也是如此，因为宽松的加载和存储可以相对于其他加载和存储重新排序。

换句话说，用 volatile 修饰你的 atomic 不会改变你代码的行为。

不管怎样，C++11 原子变量不需要用 volatile 关键字标记。

这里是 g++-5.2 如何尊重原子变量的示例。以下功能:

__attribute__((noinline)) int f(std::atomic<int>& a) {
    return a.load(std::memory_order_relaxed);
}

__attribute__((noinline)) int g(std::atomic<int>& a) {
    static_cast<void>(a.load(std::memory_order_relaxed));
    static_cast<void>(a.load(std::memory_order_relaxed));
    static_cast<void>(a.load(std::memory_order_relaxed));
    return a.load(std::memory_order_relaxed);
}

__attribute__((noinline)) int h(std::atomic<int>& a) {
    while(a.load(std::memory_order_relaxed))
        ;
    return 0;
}

使用 g++ -o- -Wall -Wextra -S -march=native -O3 -pthread -std=gnu++11 test.cc | 编译c++filt > test.S 生成以下程序集:

f(std::atomic<int>&):
    movl    (%rdi), %eax
    ret

g(std::atomic<int>&):
    movl    (%rdi), %eax
    movl    (%rdi), %eax
    movl    (%rdi), %eax
    movl    (%rdi), %eax
    ret

h(std::atomic<int>&):
.L4:
    movl    (%rdi), %eax
    testl   %eax, %eax
    jne .L4
    ret

关于c++ - std::atomic 应该是易变的吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36496692/