отображения кода из C11 модели в итоговую архитектуру делает компилятор по своему произволу, никакое правило итоговой архитектуры просто так не переносится, пока компилятор не написал нестандартную гарантию

Но почему? Не может же быть ситации чтобы в последнем работающем read было одно значение true, но не было другого? Они ж атамарно работают

Хм... вы физику СТО не учили?) Говорить о том, что Х произошло раньше У, можно только когда между ними возможна причинно-следственная связь, иначе локальные координаты могут их переупорядочить...

Ну по логике программы, если первый поток на чтение получит x == true и завершится с y == false, то второй поток на чтение не пройдет while, пока не получит y == true, а x - уже true и в итоге всегда z > 0. В чем здесь дырка я все-равно не понял. Можно как-то на уровне исполнения описать такую ситуацию для компилятора?

И сама по себе целевая архитектура без перенесенных гарантий компилятора значения не имеет - самый простой пример в данном случае это signed overflow, которое гарантированно на x64, но при этом будет работать неожиданным образом на любом x64 компиляторе

Дырка в том, что вы считаете, что существует некоторый "физический порядок" между событиями записи x и y. Скажем, представьте себе, что потоки стоят в вершинах квадрата в порядке a c b d и передают данные пакетами вдоль по этому квадрату.

Ну я не про порядок в мире железок, а про условия в потоках, кт и задают некий порядок. А то что они работают параллельно я представить могу, почему они могут получать разные комбинации - не понимаю. Как поток кт проверяет в цикле x, может видеть y == false, если в другом потоке y стал true иначе он бы не прошел тот поток и было бы наоборот, но так или иначе z должно быть > 0, потому что таково условие и как компилятор может зареордерить, чтобы это испортить? :0

Вы же понимаете, что не существует некоторого "абсолютного" времени и "абсолютного" порядка между событиями?

Да, но тут то мы его задаем сами, по-крайней мере я это вижу в коде. У нас 2 атомарных флага в общей памяти этих потоков, кт этот порядок и обеспечивают, что может случиться плохого?

То есть если поток видит состояние x == true, y == false, это не значит, что запись x произошла раньше записи y в некотором абсолютном времени?

Это лишь значит, что поток увидел запись х раньше, чем запись у. Но они не были в границах какой-то причинно-следственной связи. Точно так же, если на Земле одновременно принимают сигнал с Венеры и Марса, спутник Венеры получил раньше сигнал с Венеры, а спутник Марса получит раньше сигнал с Марса

Но разве процесс доставки не должен быть неделимым?

То есть мы получим точные данные и другие потоки ниче не делают в этот момент

Ну представьте, что у нас Венера с Марсом общается

сообщения нумеруем автоинкрементом, acquire x означает, что у меня должен быть непрерывный поток сообщений до последнего принятого release x

мы на спутнике Венеры, release x с Венеры приняли, release y вообще никто не посылал, 1 0 всё замечательно

Кажется дошло. Мде, тупанул. Спасибо за помощь, в однопоточной голове сложно все понять xD

Странное желание. Это нужно чтобы руками упаковывать структуры?  Я так понял если объявить uint8_t foo:3, uint8_t bar:2, uint8_t baz:3; они все в 1 байте будут и не надо байтодрочить даже сдвигами

foo(const some_type& ref);

между

foo({});

и

foo(some_type());

есть какая-то разница ? (предполагается, что у some_type есть все конструкторы)
ну и вопрос вдогонку, если так:

foo(some_type&& rref);

- будет разница?

как я понимаю, разницы быть не должно