Могут ли оба условия быть истинными, если каждое зависит от другого? ⇐ C++

[Anonymous]

Кажется, меня смутили такие два примера. Первый пример:
std::atomic x = 1;
//thread 1:
int expected = 1;
if (x.compare_exchange_strong(expected,0,relaxed,relaxed) == true){ // #1
x.store(2,relaxed); // #2
}
//thread 2:
int expected = 2;
if (x.compare_exchange_strong(expected,3,relaxed,relaxed)==true){ // #3
}

В этом примере невозможно, чтобы #3 считывал значение, записанное #2, но #1 возвращал false. Я доказываю это следующим образом: #2 вызывается только тогда, когда условие #1 истинно, поэтому невозможно, чтобы #1 возвращал false, пока #3< /code> возвращает истину. Я не знаю, существует ли формальный способ доказать, что это невозможно (например, с точки зрения формальной формулировки или порядка внесения изменений).
Рассмотрим второй пример:
std::atomic x = 2;
std::atomic y = 0;
//thread 1:
if(x.exchange(2,Relaxed) == 1) { // #1
y.store(1,Relaxed); // #2
}
//thread 2:
if(y.exchange(2,Acquire) == 1){ // #3
x.store(1,Release); // #4
}

Однако применение приведенной выше логики к этому примеру, похоже, не работает. Во втором примере могут ли оба условия быть истинными? Используя приведенную выше логику, если #1 возвращает 1, это означает, что #1 читает #4, а #4 вызывается только в том случае, если #3 читает #2, а #2 вызывается только в том случае, если #1 возвращает 1, поэтому доказательство, похоже, образует цикл. Однако с точки зрения порядка памяти, поскольку #4 не синхронизируется с #1, а #2 не синхронизируется с #3, истинное условие не выполняется. накладываются на то, как переупорядочиваются операции с другой переменной. Другими словами, когда #3 читает #2, #1 и #4 по-прежнему неупорядочены, так же как #3 и #2 также неупорядочен, когда #1 читает #4.
Есть ли формальный способ работать с обоими примерами?
Обновлено:
Второй пример очень похож на пример в [atomics.order] стр.9
[Note 7: The recommendation similarly disallows r1 == r2 == 42 in the following example, with x and y again initially zero:
// Thread 1:
r1 = x.load(memory_order::relaxed);
if (r1 == 42) y.store(42, memory_order::relaxed);
// Thread 2:
r2 = y.load(memory_order::relaxed);
if (r2 == 42) x.store(42, memory_order::relaxed);
— end note]

[atomics.order] p8 говорит:

Реализации должны гарантировать, что никакие «из воздуха» Значения вычисляются циклически и зависят от собственных вычислений.

Однако в этой формулировке используется просто следует, что не является обязательным. . Итак, во втором примере все еще возможно, что оба условия верны?
А как насчет этого?
std::atomic v = {0};
//thread 1:
if(v.load(acquire) == 1){
v.store(2,release);
}
//thread 2:
if(v.load(relaxed) == 2){
v.store(1,relaxed);
}


Подробнее здесь: https://stackoverflow.com/questions/792 ... on-another