独立读取-修改-写入顺序

我通过Relacy运行了一堆算法来验证它们的正确性，但我偶然发现了一些我并不真正理解的东西。这是它的简化版本：

#include <thread>
#include <atomic>
#include <iostream>
#include <cassert> 
struct RMW_Ordering
{
std::atomic<bool> flag {false};
std::atomic<unsigned> done {0}, counter {0};
unsigned race_cancel {0}, race_success {0}, sum {0};
void thread1() // fail
{
race_cancel = 1; // data produced
if (counter.fetch_add(1, std::memory_order_release) == 1 &&
!flag.exchange(true, std::memory_order_relaxed))
{
counter.store(0, std::memory_order_relaxed);
done.store(1, std::memory_order_relaxed);
}
}
void thread2() // success
{
race_success = 1; // data produced
if (counter.fetch_add(1, std::memory_order_release) == 1 &&
!flag.exchange(true, std::memory_order_relaxed))
{
done.store(2, std::memory_order_relaxed);
}
}
void thread3()
{
while (!done.load(std::memory_order_relaxed)); // livelock test
counter.exchange(0, std::memory_order_acquire);
sum = race_cancel + race_success;
}
};
int main()
{
for (unsigned i = 0; i < 1000; ++i)
{
RMW_Ordering test;
std::thread t1([&]() { test.thread1(); });    
std::thread t2([&]() { test.thread2(); });
std::thread t3([&]() { test.thread3(); });
t1.join();
t2.join();
t3.join();
assert(test.counter == 0);
}
std::cout << "Done!" << std::endl;
}

两个线程争相进入受保护区域，最后一个线程修改done，从无限循环中释放第三个线程。这个例子有点做作，但原始代码需要通过标志声明这个区域，以表示"完成"。

最初，fetch_add具有acq_rel排序，因为我担心交换可能在它之前被重新排序，这可能会导致一个线程声明该标志，首先尝试fetch_add检查，并阻止另一个线程(通过增量检查)成功修改计划。在使用Relacy进行测试时，我想如果我从acq_rel切换到发布，我会看到我预期发生的活锁是否会发生，但令我惊讶的是，它没有发生。然后，我用放松来做任何事情，再次，没有活栓。

我试图在C++标准中找到任何关于这方面的规则，但只找到了以下规则：

1.10.7此外，还有非同步操作的宽松原子操作和原子读-修改-写操作，它们具有特殊的特性。

29.3.11原子读取-修改-写入操作应始终读取写入关联之前写入的最后一个值(按修改顺序)通过读取-修改-写入操作。

我可以一直依赖RMW操作不被重新排序吗？即使它们影响不同的内存位置？标准中有什么可以保证这种行为吗

编辑：

我想出了一个更简单的设置，可以更好地说明我的问题。下面是它的CppMem脚本：

int main() 
{
atomic_int x = 0; atomic_int y = 0;
{{{
{
if (cas_strong_explicit(&x, 0, 1, relaxed, relaxed))
{
cas_strong_explicit(&y, 0, 1, relaxed, relaxed);
}
}
|||
{
if (cas_strong_explicit(&x, 0, 2, relaxed, relaxed))
{
cas_strong_explicit(&y, 0, 2, relaxed, relaxed);
}
}
|||
{
// Is it possible for x and y to read 2 and 1, or 1 and 2?
x.load(relaxed).readsvalue(2);
y.load(relaxed).readsvalue(1);
}
}}}
return 0; 
}

我认为该工具不够复杂，无法评估这种情况，尽管它似乎确实表明这是可能的。以下是几乎等效的松弛设置：

#include "relacy/relacy_std.hpp"
struct rmw_experiment : rl::test_suite<rmw_experiment, 3>
{
rl::atomic<unsigned> x, y;
void before()
{
x($) = y($) = 0;
}
void thread(unsigned tid)
{
if (tid == 0)
{
unsigned exp1 = 0;
if (x($).compare_exchange_strong(exp1, 1, rl::mo_relaxed))
{
unsigned exp2 = 0;
y($).compare_exchange_strong(exp2, 1, rl::mo_relaxed);
}
}
else if (tid == 1)
{
unsigned exp1 = 0;
if (x($).compare_exchange_strong(exp1, 2, rl::mo_relaxed))
{
unsigned exp2 = 0;
y($).compare_exchange_strong(exp2, 2, rl::mo_relaxed);
}
}
else
{
while (!(x($).load(rl::mo_relaxed) && y($).load(rl::mo_relaxed)));
RL_ASSERT(x($) == y($));
}
}
};
int main()
{
rl::simulate<rmw_experiment>();
}

断言从未被违反，因此根据Relacy，1和2(或相反)是不可能的。