C++ 0x модель памяти и спекулятивные загрузки/хранилища

Я не знаком со всем, на что вы ссылаетесь, но заметьте, что в случае y==2, в первом битке кода, x вообще не написан (или прочитан, если уж на то пошло). Во втором бите кода он написан дважды. Это больше разница, чем просто написать один раз против двух (по крайней мере, в существующих потоковых моделях, таких как pthreads). Кроме того, хранение значения, которое в противном случае вообще не хранилось бы, имеет большую разницу, чем просто запись один раз против записи дважды. По обеим этим причинам не следует, чтобы компиляторы просто заменяли no-op на tmp = x; x = 17; x = tmp;.

Предположим, поток A хочет предположить, что никакой другой поток не изменяет x. Разумно ожидать, что если y равен 2, а он записывает значение в x, то прочитает его обратно, и он получит обратно записанное значение. Но если поток B одновременно выполняет ваш второй бит кода, то поток A может написать в x, а затем прочитать его, и получить обратно исходное значение, потому что поток B сохранил "до" написания и восстановил "после" его. Или он может получить обратно 17, потому что поток B сохранил 17 "после" записи и сохранил tmp обратно "после" чтения потока A. Поток A может делать любую синхронизацию, которая ему нравится, и это не поможет, потому что поток B не синхронизирован. Причина, по которой он не синхронизирован (в случае y==2), заключается в том, что он не использует x. Таким образом, понятие о том, что конкретный бит кода "использует x", важно для модели потоков, а это значит, что компиляторы не могут позволить изменить код, чтобы использовать x, когда он "не должен".

Короче говоря, если бы предлагаемое преобразование было разрешено, введя ложную запись, то никогда не было бы возможности проанализировать бит кода и сделать вывод, что он не изменяет x (или любую другую область памяти). Поэтому существует ряд удобных идиом, которые были бы невозможны, например, обмен неизменяемыми данными между потоками без синхронизации.

Итак, хотя я не знаком с определением "гонки данных" в Си++0x, я предполагаю, что оно включает в себя некоторые условия, при которых программисту разрешается предполагать, что объект не записывается, и что это преобразование нарушит эти условия. Я предполагаю, что если y==2, то ваш исходный код вместе с параллельным: x = 42; x = 1; z = x в другом потоке, не определяется как гонка данных. Или, по крайней мере, если это гонка данных, то она не позволяет z закончить значением 17 или 42.

Считайте, что в этой программе значение 2 в y может быть использовано, чтобы указать, что "выполняются другие потоки: не модифицируйте x, потому что здесь мы не синхронизированы, так что это приведет к гонке данных". Возможно, причина, по которой синхронизация вообще отсутствует, в том, что во всех остальных случаях y нет других потоков, выполняющихся с доступом к x. Мне кажется разумным, что C++0x захотел бы поддерживать такой код:

if (single_threaded) {
    x = 17;
} else {
    sendMessageThatSafelySetsXTo(17);
}

Очевидно, что в таком случае вы не захотите, чтобы это преобразовывалось:

tmp = x;
x = 17;
if (!single_threaded) {
    x = tmp;
    sendMessageThatSafelySetsXTo(17);
}

Это в основном то же самое преобразование, что и в вашем примере, но только в двух случаях, вместо того, чтобы его было достаточно, чтобы оно выглядело как хорошая оптимизация в коде