Ключевое слово «volatile» C/C++

Я бы уточнил, что, например, переменная countPeople может быть изменена не только программой, а и контроллером лифта. Это и будет то самое "извне", которое должен уважать компилятор.

Стоит дополнить примерами того для чего мы отключаем оптимизации для переменной: регистры в периферийных устройствах; глобальные переменные, используемые в обработчиках прерываний; глобальные переменные, используемые совместно несколькими задачами в многопотоковом приложении; для дебага.

Никогда, слышите, никогда не используйте volatile в одном предложении с multithreading. Единственное исключение: предыдущее предложение.

https://stackoverflow.com/questions/4557979/when-to-use-volatile-with-multi-threading

Пример из статьи, где переменная объявляется volatile и якобы из-за этого можно мониторить, что она изменяется в другом потоке - абсолютно неверен.

про цикл как то не очевидно по моему, одна инструкция аля decfsz для счетчика и погнали, небось как всегда за один такт?

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

Самая затратная операция в этом примере не присваивание ячейке массива какого-либо значения и не инкремент счетчика, а именно операция сравнения, поэтому компилятор оптимизирует это примерно вот так.

Операция сравнения не является самой затратной. Откройте страницу из Интел мануала на ваш процессор и посмотрите что занимает она один такт. Оптимизация, которую выполнил компилятор в данном случае называется loop unrolling и она нужна для того, чтобы увеличить количество полезной работы за одну итерацию цикла. Грубо говоря мы уменьшаем количество проверок на конец цикла, а значит повышаем быстродействие.

volatile нужен по нескольким очевидным причинам. И главная, это запретить компилятору убирать эту переменную в результате dead code ellimination и прочих подстановок с упрощением выражений и вытаскиваний инвариантов. volatile для межпоточного взаимодействия это очень плохой пример, потому как это должен быть как минимум atomic.

volatile это вообще зло непонятно как пропущенное в стандарт. В С# то-же самое. Как им правильно пользоваться, никто не знает, но на всякий случай "если меняете переменную в трэдах пишите volatile", типа не ошибетесь.

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

C#

On a multiprocessor system, a volatile read operation is not guaranteed to obtain the latest value written to that memory location by any processor. Similarly, a volatile write operation does not guarantee that the value written would be immediately visible to other processors.

On a uniprocessor system, volatile reads and writes ensure that a value is read or written to memory and not cached (for example, in a processor register). Thus, you can use these operations to synchronize access to a field that can be updated by another thread or by hardware.

• For non-volatile fields, optimization techniques that reorder instructions can lead to unexpected and unpredictable results in multi-threaded programs that access fields without synchronization such as that provided by the lock_statement (§12.13). These optimizations can be performed by the compiler, by the run-time system, or by hardware.

volatile (C++)

A type qualifier that you can use to declare that an object can be modified in the program by the hardware.

You can use the volatile qualifier to provide access to memory locations that are used by asynchronous processes such as interrupt handlers.

This enables volatile objects to be used for memory locks and releases in multithreaded applications.

When it relies on the enhanced guarantee that's provided when the /volatile:ms compiler option is used, the code is non-portable.

Java

The volatile keyword does not cache the value of the variable and always read the variable from the main memory. The volatile keyword cannot be used with classes or methods. However, it is used with variables. It also guarantees visibility and ordering. It prevents the compiler from the reordering of code.

The contents of the particular device register could change at any time, so you need the volatile keyword to ensure that such accesses are not optimized away by the compiler.

Типовая проблема - типовое решение.

const MAX_COUNT_PEOPLE = 4;

Каков тип этой постоянной?

Ну если уж придираться ко всем примерам, то и к вынесению strlen за пределы цикла много вопросов. Сделать это можно очевидно не всегда, а точнее довольно редко. Компилятору для этого надо доказать, что строка не может быть изменена внутри цикла, включая вызываемые функции которым передаются указатели на ее содержимое.

const MAX_COUNT_PEOPLE = 4;
size_t countPeole = 0;
...
if(countPeople > MAX_COUNT_PEOPLE)
...

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

Я чего-то не понял, или все-таки условие всегда будет ложно?

компилятор оптимизирует это примерно вот так:

at[i] = ..;

ar[i + 1] = ...;

ar[i + 2] = ...;

ar[i + 3] = ...;

Проверял. Нет, GCC не настолько крут.

Самая затратная операция в этом примере не присваивание ячейке массива какого-либо значения и не инкремент счетчика, а именно операция сравнения

Чем же инструкция сравнения "дороже"любой другой операции?

Да, за один проход цикла обрабатывать 4 ячейки массива будет быстрее, чем одну, но это из-за микроархитектуры современных процов, а не отсутствия "лишних" сравнений.

пример, в котором имеем массив символов, с помощью цикла проходим по всей строке

for(size_t i = 0; i < strlen(str); i++)

{

...

}

В Си строка и массив байтового размера — несколько разные вещи. Для массива надо проходить именно по длине, а для циклов по символам строки достаточно:

while (*str) {...}

Правда, если у вас массив char не имеет последним символом '\0', то и strlen(char* str) работать не будет.

int ar[1024];

for(size_t i = 0; i < 1024 / 4; i += 4)

{

ar[i] = ...;

ar[i + 1] = ...;

ar[i + 2] = ...;

ar[i + 3] = ...;

}

Раз уж далее речь о замене умножения сложением, то и здесь надо побитовый сдвиг применить. Ещё, если вам нужна обработка всего массива, то делить на 4 лист массива — ошибочное решение.

Видимо, вы хотели как-то вот так;

#define sz 1024
...
int ar[sz] = {0}, *pa = &ar;
size_t n4 = sz >> 2;
  while (n4-- > 0) {
    *pa++ = ... ;
    *pa++ = ... ;
    *pa++ = ... ;
    *pa++ = ... ;
  }
pa = &ar;

volatile - это в первую очередь сообщение компилятору, что содержимое переменной в любой момент может измениться по внешним причинам. Например, если это регистр, связанный с оборудованием, или элемент буфера DMA, или её может изменить другой процесс (если программа работает в среде операционной системы). Соответственно, оптимизация по отношению к ней будет иной.

Особенно это хорошо проявляется на процессорах RISC с гарвардской архитектурой (ARM, RISC-V и т.п.).

Допустим, мы объявили регистр ввода-вывода обычной переменной и каким-то образом назначили ей корректный адрес размещения в памяти, отраженный на физический регистр. А теперь нам нужно дрыгнуть один раз выходом операцией "чтение-модификация-запись". То есть, прочитать регистр, изменить один бит, записать, потом снова изменить, потом снова записать.

int reg_0;
reg_0 |= 0x01;
reg_0 &= 0xFE;

Что произойдет? Процессор загрузит содержимое регистра в регистр общего назначения. Потом изменит бит, потом снова изменит и запишет обратно. На выходе импульса не будет.

LDR R0, REG_0 ;Чтение регистра
ORI R0, 0x01	;Изменение содержимого
ANDI R0, 0xFE	;Изменение содержимого
STR REG_0, R0	;Запись изменений

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

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

LDR R0, REG_0 ;Чтение регистра
ORI R0, 0x01	;Изменение содержимого
STR REG_0, R0	;Запись изменений

LDR R0, REG_0 ;Чтение регистра
ANDI R0, 0xFE	;Изменение содержимого
STR REG_0, R0	;Запись изменений

Это же касается и операций чтения. При каждом обращении в Сишной программе к этому регистру, будут всегда производиться чтения с физического регистра.

volatile у переменной означает, что чтение и запись этой переменной --- непосредственные элементы наблюдаемого поведения (разновидность ввода и вывода программы, соответственно, а не операции над ячейками абстрактной памяти C/C++). Невозможность тех или иных преобразований кода компилятором --- это уже следствие.

Оптимизации не могут сломать корректный код. В свою очередь, запрет оптимизаций не может сделать некорректный код корректным. Если volatile используется для запрета оптимизаций, то он используется не по назначению. Использование volatile вместо атомиков --- яркий тому пример.