Скотт Мейерс - Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14

Квалификатор volatileпредставляет собой способ сообщить компиляторам, что мы имеем дело с такой особой памятью. Для компилятора это означает “не выполняй никаких оптимизаций над операциями с этой памятью”. Так что если переменная xсоответствует особой памяти, она должна быть объявлена как volatile:

volatileint x;

Рассмотрим влияние этого квалификатора на последовательность нашего исходного кода:

auto y = x; // Чтение x

y = x; // Чтение x еще раз (не может быть устранено)

x = 10; // Запись x (не может быть устранена)

x = 20; // Запись x еще раз

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

Вопрос на засыпку: какой тип у в последнем фрагменте кода: intили volatile int [28] Тип y получается с помощью вывода auto , так что используются правила, описанные в разделе 1.2. Эти правила предписывают, чтобы для объявления типов, не являющихся ссылочными или типами указателей (что и выполняется о случае y ), квалификаторы const и volatile были опущены. Следовательно, типом y является просто int . Это означает, что избыточные чтения и записи y могут быть удалены. В приведенном примере компиляторы должны выполнять и инициализацию, и присваивание y , поскольку x объявлена как volatile , так что второе чтение x может давать другое значение, отличное от первого. ?

Тот факт, что кажущиеся избыточными загрузки и бессмысленные сохранения должны оставаться на месте при работе с особой памятью, объясняет, кстати, почему для такого рода работы не подходят объекты std::atomic. Компиляторам разрешается устранять такие избыточные операции у std::atomic. Код написан не в точности так же, как и для volatile, но если мы на минуту отвлечемся от этого и сосредоточимся на том, что компиляторам разрешается делать, то можно сказать, что концептуально компиляторы могут, получив код

std::atomic<int >x;

auto y = x; // Концептуально читает x (см. ниже)

y = x; // Концептуально читает x еще раз (см. ниже)

x = 10; // Записывает x

х = 20; // Записывает x еще раз

оптимизировать его до

auto y = x; // Концептуально читает x (см. ниже)

x = 20; // Записывает x

Очевидно, что это неприемлемое поведение при работе с особой памятью.

Но если xимеет тип std::atomic, ни одна из этих инструкций компилироваться не будет:

auto y = x; // Ошибка!

y = x; // Ошибка!

Дело в том, что копирующие операции в std::atomicудалены (см. раздел 3.5). И не зря. Рассмотрим, что произошло бы, если бы инициализация у значением x компилировалась. Поскольку xимеет тип std::atomic, тип у был бы также выведен как std::atomic(см. раздел 1.2). Ранее я отмечал, что одна из лучших возможностей std::atomicзаключается в атомарности всех их операций, но чтобы копирующее конструирование yиз xбыло атомарным, компиляторы должны генерировать код для чтения xи записи yкак единую атомарную операцию. В общем случае аппаратное обеспечение не в состоянии это сделать, так что копирующее конструирование типами std::atomicне поддерживается. Копирующее присваивание удалено по той же причине, а потому присваивание xпеременной yтакже не компилируется. (Перемещающие операции не объявлены в std::atomicявно, так что в соответствии с правилами генерации специальных функций, описанных в разделе 3.11, std::atomicне предоставляет ни перемещающего конструирования, ни перемещающего присваивания.)

Можно получить значение xв переменную y, но это требует использования функций- членов loadи storeтипа std::atomic. Функция-член loadатомарно считывает значение std::atomic, а функция-член storeатомарно его записывает. Для инициализации yзначением x, после которой выполняется размещение значения xв y, код должен иметь следующий вид:

std::atomic y( x.load()); // Чтение x

y.store( x.load()); // Чтение x еще раз

Этот код компилируется, но тот факт, что чтение x(с помощью x.load()) является отдельным от инициализации или сохранения значения увызовом функции, делает очевидным то, что нет никаких оснований ожидать, что целая инструкция будет выполняться как единая атомарная операция.

Компиляторы могут “оптимизировать” приведенный код, сохраняя значение xв регистре вместо двойного его чтения: