переменные с переменным переменным C++

Question

Я пишу приложение на C++.

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

В C++ все, что может быть изменено без компилятора, «реализующего» его изменение, должно быть отмечено волатильным справа? Так что, если мой код многопоточен, и один поток может писать в var, а другой читает из него, мне нужно отметить var volaltile?

[У меня нет условия гонки, так как я, опираясь на запись в Интс быть атомным]

Спасибо!

Answer 1

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

volatile не обеспечит никакой синхронизации, и ваше предположение о том, что запись в атом атома является почти реалистичной!

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

Answer 2

Без блокировки вы все равно можете получить «невозможные» повторные заказы, выполненные компилятором или процессором. И нет никакой гарантии, что записи в ints являются атомарными.

Лучше использовать правильную блокировку.

Answer 3

У C++ еще нет ни одного условия для многопоточности. На практике volatile не делает то, что вы имеете в виду (он был разработан для аппаратного обеспечения с адресами памяти, а в то время как две проблемы подобны, они достаточно различны, что волатильность не делает правильные вещи - обратите внимание, что volatile был использован в других язык для использования в контекстах mt).

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

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

Answer 4

Volatile решит вашу проблему, т.е. это гарантирует согласованность между всеми кэшами системы. Однако это будет неэффективно, поскольку он обновит переменную в памяти для каждого доступа R или W. Вместо этого вы можете использовать индикатор памяти, только тогда, когда это необходимо. Если вы работаете с или GCC/МЦМ взгляд на синхронизацию встроенных модулях: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html

EDIT (в основном о PM100 комментариях): Я понимаю, что мои убеждения не ссылка, так что я нашел что-то процитировать :)

Было разработано ключевое слово volatile , чтобы предотвратить оптимизацию компилятора, которая могла бы сделать код неправильным при наличии определенных асинхронных событий.Например,если объявить примитивную переменные летучей, компилятор не допускается кэшировать его в регистре

От Dr Dobb's

Больше интересный:

Летучих поля линеаризуемы. Чтение изменчивого поля похоже на приобретение блокировки; рабочая память недействительна, и текущее значение летучего поля перечитывается из памяти. Написание изменчивого поля похоже на освобождение блокировки: энергозависимое поле немедленно записывается обратно в память. (это все о последовательности, а не о атомарности)

из Искусства многопроцессорного программирования Морис Herlihy & Nir Shavit

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

Answer 5

Да, неустойчивый - это абсолютный минимум, Мне нужно. Это гарантирует, что генератор кода не будет генерировать код, который сохраняет переменную в регистре и всегда выполняет чтение и запись из/в память. Большинство генераторов кода могут обеспечить гарантии атомарности для переменных, которые имеют тот же размер, что и родное слово ЦП, они обеспечат выравнивание адреса памяти, чтобы переменная не могла оседлать границу линии кэша.

Это, однако, не очень сильный контракт на современные многоядерные процессоры. Volatile not обещает, что другой поток, который работает на другом ядре, может видеть обновления переменной. Для этого требуется барьер памяти, обычно это инструкция, которая очищает кеш процессора. Если вы не обеспечите барьер, поток фактически продолжит работать, пока такой флеш не произойдет естественным образом. Это в конечном итоге произойдет, планировщик потоков обязательно предоставит один. Это может занять миллисекунды.

После того, как вы позаботились о таких деталях, вы в конце концов повторно изобрели переменную условия (событие aka), которая вряд ли будет быстрее, чем та, которая предоставляется библиотекой потоков. Или же проверено. Не придумывайте свои собственные, резьба достаточно сложна, чтобы получить право, вам не нужно FUD, чтобы не быть уверенным в том, что основные примитивы прочны.

Answer 6

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

Он может быть использован, чтобы сообщить компилятору не считать, что, как только он прочитал из ячейки памяти, что значение не изменится:

while (*p) 
{ 
    // ... 
} 

В приведенном выше коде, если *p не записывается внутри цикла, то компилятор может принять решение перейти на чтение вне цикла, примерно так:

cached_p=*p 
while (cached_p) 
{ 
    // ... 
} 

Если p является указателем на порт ввода/вывода отображаемой памяти, вы хотели бы первый вариант, где порт проверяется до ввода петли e очень время.

Если p является указателем на память в многопоточном приложении, вам все равно не гарантируется, что записи являются атомарными.