Допустим, у меня есть структура:
struct Foo {
char a; // read and written to by thread 1 only
char b; // read and written to by thread 2 only
};
Из того, что я понимаю, стандарт C++ гарантирует безопасность вышеуказанного, когда два потока работают в двух разных местах памяти.
Я думаю, однако, что, поскольку char a и char b попадают в одну и ту же строку кэша, компилятор должен выполнить дополнительную синхронизацию.
Что именно здесь происходит?
Это зависит от оборудования. На оборудовании, с которым я знаком, C++ не нужно делать ничего особенного, потому что с точки зрения аппаратного обеспечения доступ к разным байтам даже в кэшированной строке обрабатывается "прозрачно". От аппаратного обеспечения эта ситуация на самом деле не отличается от
char a[2];
// or
char a, b;
В приведенных выше случаях речь идет о двух смежных объектах, которые гарантированно будут доступны независимо.
Тем не менее, я поставил "прозрачно" в кавычки по причине. Когда у вас действительно есть такой случай, вы можете страдать (с точки зрения производительности) от "ложного совместного использования", которое происходит, когда два (или более) потока одновременно обращаются к смежной памяти, и это заканчивается кэшированием в нескольких кэшах ЦП. Это приводит к постоянной недействительности кэша. В реальной жизни следует позаботиться о том, чтобы этого не было, когда это возможно.
Как объяснили другие, ничего общего на обычном оборудовании. Однако есть одна загвоздка: компилятор должен воздерживаться от выполнения определенных оптимизаций, если только он не может доказать, что другие потоки не обращаются к рассматриваемым областям памяти, например:
std::array<std::uint8_t, 8u> c;
void f()
{
c[0] ^= 0xfa;
c[3] ^= 0x10;
c[6] ^= 0x8b;
c[7] ^= 0x92;
}
Здесь, в модели однопоточной памяти, компилятор может генерировать код, подобный следующему (псевдо-сборка; предполагается, что аппаратные средства с прямым порядком байтов):
load r0, *(std::uint64_t *) &c[0]
xor r0, 0x928b0000100000fa
store r0, *(std::uint64_t *) &c[0]
Скорее всего, это будет быстрее на обычном оборудовании, чем на xor'ing отдельных байтов. Однако он считывает и записывает незатронутые (и не упомянутые) элементы c с индексами 1, 2, 4 и 5. Если другие потоки записывают данные в эти области памяти одновременно, эти изменения могут быть перезаписаны.
По этой причине подобные оптимизации часто невозможно использовать в многопоточной модели памяти. Пока компилятор выполняет только загрузку и сохранение соответствующей длины или объединяет доступы только при отсутствии промежутка (например, доступ к c[6] и c[7] все еще может быть объединен), аппаратное обеспечение обычно уже обеспечивает необходимые гарантии для правильного исполнения.
(Тем не менее, существуют/были некоторые архитектуры со слабыми и неинтуитивными гарантиями порядка памяти, например, DEC Alpha не отслеживает указатели как зависимость данных, как это делают другие архитектуры, поэтому в некоторых случаях необходимо ввести явный барьер памяти в низкоуровневом коде. В этом вопросе Линуса Торвальдса есть довольно известная маленькая сплетня. Однако соответствующая реализация C++, как ожидается, оградит вас от таких проблем.)