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

Ответ 1

Я не знаком со всем, на что вы ссылаетесь, но обратите внимание, что в случае 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. Thread 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. Мне кажется разумным, что С++ 0x хотел бы поддерживать такой код:

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

Ясно, что вы не хотите, чтобы это преобразовало:

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

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

Ответ 2

Если y==2, а другой поток изменяет или читает x, как в исходном образце есть условие гонки? Эта нить никогда не касается x, поэтому другие потоки могут делать это свободно.

Но с измененной версией наш поток изменяет x, если только временно, поэтому, если другой поток также манипулирует им, теперь мы имеем условие гонки, в котором ни один из них не присутствовал раньше.