c++ - volatile 但不 protected 读取能否产生无限期的陈旧值？ (在真实硬件上)

Question

在回答 this question关于 OP 情况的另一个问题出现了，我不确定:这主要是处理器架构问题，但也有一个关于 C++ 11 内存模型的链式问题。

基本上，由于以下代码(为简单起见稍作修改)，OP 的代码在更高的优化级别无限循环:

while (true) {
    uint8_t ov = bits_; // bits_ is some "uint8_t" non-local variable
    if (ov & MASK) {
        continue;
    }
    if (ov == __sync_val_compare_and_swap(&bits_, ov, ov | MASK)) {
        break;
    }
}

其中 __sync_val_compare_and_swap() 是 GCC 的内置原子 CAS。在进入循环之前检测到 bits_ & mask 为 true 的情况下，GCC(合理地)将其优化为无限循环，完全跳过 CAS 操作，所以我建议以下更改(有效):

while (true) {
    uint8_t ov = bits_; // bits_ is some "uint8_t" non-local variable
    if (ov & MASK) {
        __sync_synchronize();
        continue;
    }
    if (ov == __sync_val_compare_and_swap(&bits_, ov, ov | MASK)) {
        break;
    }
}

在我回答之后，OP 注意到将 bits_ 更改为 volatile uint8_t 似乎也可以。我建议不要走那条路，因为 volatile 通常不应该用于同步，而且在这里使用栅栏似乎没有太大的缺点。

但是，我考虑得更多，在这种情况下，语义使得 ov & MASK 检查是否基于陈旧值并不重要，只要它是不是基于无限陈旧的(即只要循环最终被打破)，因为更新 bits_ 的实际尝试是同步的。如果 bits_ 被另一个线程更新，例如 bits_ & MASK == false，volatile 是否足以保证此循环最终终止，例如任何现有的处理器？换句话说，在没有显式内存栅栏的情况下，实际上是否可以无限期地由处理器有效地优化未由编译器优化的读取？ (编辑:为了清楚起见，我在这里询问现代硬件实际上可能会做什么，假设读取是由编译器在循环中发出的，因此尽管表达它，但从技术上讲这不是语言问题在 C++ 语义方面是方便的。)

这是它的硬件角度，但要稍微更新它并使其也成为有关 C++11 内存模型的可回答问题，请考虑对上面代码的以下变体:

// bits_ is "std::atomic<unsigned char>"
unsigned char ov = bits_.load(std::memory_order_relaxed);
while (true) {
    if (ov & MASK) {
        ov = bits_.load(std::memory_order_relaxed);
        continue;
    }
    // compare_exchange_weak also updates ov if the exchange fails
    if (bits_.compare_exchange_weak(ov, ov | MASK, std::memory_order_acq_rel)) {
        break;
    }
}

cppreference声称 std::memory_order_relaxed 意味着“对围绕原子变量的内存访问的重新排序没有限制”，因此独立于实际硬件会或不会做什么，确实暗示 bits_.load( std::memory_order_relaxed) 可以在技术上永远在 bits_ 在符合实现的另一个线程上更新后读取更新的值？

编辑:我在标准(29.4 p13)中找到了这个:

Implementations should make atomic stores visible to atomic loads within a reasonable amount of time.

显然，等待更新值“无限长”是不可能的(大多数情况下？)，但没有硬性保证任何特定的新鲜时间间隔应该是“合理的”；不过，关于实际硬件行为的问题仍然存在。

Answer 1

C++11 原子处理三个问题:

1. 确保在没有线程切换的情况下读取或写入完整的值；这样可以防止撕裂。

2. 确保编译器不会在原子读取或写入的线程中重新排序指令；这确保了线程内的排序。

3. ensuring (for appropriate choices of memory order parameters) that data written within a thread prior to an atomic write will be seen by a thread that reads the atomic variable and sees the value that was written.这就是可见性。

当您使用 memory_order_relaxed 时，您无法从宽松的存储或加载中获得可见性保证。你确实得到了前两个保证。

实现“应该”(即鼓励)使内存写入在合理的时间内可见，即使是在宽松的顺序下也是如此。这是可以说的最好的了；这些东西迟早会出现的。

所以，是的，正式地，从不让轻松写入对轻松读取可见的实现符合语言定义。实际上，这不会发生。

关于 volatile 的作用，请咨询您的编译器供应商。这取决于实现。