Как происходит C++23 перед применением к std::memory_order_seq_cst? ⇐ C++

[Anonymous]

Рассмотрим следующую программу на C++23:

Код: Выделить всё

#include 
#include 
#include 

#define LOAD_ORDER std::memory_order_seq_cst
#define STORE_ORDER std::memory_order_seq_cst

std::atomic_int v[2]{0, 0};
int r[2];

void
f(int i)
{
v[i].store(1, STORE_ORDER);
r[i] = v[1-i].load(LOAD_ORDER);
}

int
main()
{
{
std::jthread t0(f, 0);
std::jthread t1(f, 1);
}
assert(r[0] || r[1]);
return 0;
}

Один поток сохраняет 1 в v[0], а затем загружает v[1]. Одновременно другой поток сохраняет 1 в v[1], а затем загружает v[0]. Я хочу убедиться, что хотя бы одна загрузка возвращает 1. Мои вопросы:

• На высоком уровне последовательно согласованные операции не могут быть переупорядочены, поэтому это должно работать. Но как доказать правильность приведенного выше кода, используя только последовательность перед, синхронизацию с, межпоточное взаимодействие происходит раньше и видимые побочные эффекты в спецификации языка? Например, похоже, что одно хранилище происходит раньше другого.
• Будет ли код правильным, если я изменил LOAD_ORDER на std::memory_order_relaxed и оставил STORE_ORDER как std::memory_order_seq_cst? А как насчет обратного варианта: ослабить STORE_ORDER, но не загружать?
• Какое самое простое или эффективное значение я могу установить LOAD_ORDER< /code> и STORE_ORDER, чтобы и при этом гарантировать, что утверждение не будет ошибочным?

Предположим, что все переменные находятся в разных строках кэша – я просто не добавил дополнение, чтобы сделать пример проще. Также предположим, что никаких операций потребления нет, поэтому мы можем игнорировать различия между слабыми, сильными и простыми событиями, произошедшими ранее.

Подробнее здесь: https://stackoverflow.com/questions/792 ... er-seq-cst