модель производитель - потребитель в контексте потоков

Question

Есть два потока, один из которых выступает производителем данных, а второй - их потребителем. Так же есть общий пул данных, например, массив структур типа :

struct D{
char fl_busy;
char data[256];
}; 

Поток-производитель выполняет только следующие 3 действия :

1. просматривает пул на предмет наличия пустого элемента (перебирает элементы до первого, в котором fl_busy = 0);
2. если такой элемент найден, помечает его занятым (fl_busy = 1), заполняет оставшуюся часть структуры data;
3. передает указатель на только что заполненный элемент пула потоку-потребителю (например, добавляет указатель в очередь, которую мониторит поток-потребитель).

Поток-потребитель, в свою очередь, выполняет только свои 3 действия :

1. ожидает, когда в очереди появится указатель на элемент пула, и изымает его из очереди;
2. получив указатель, как-то обрабатывает данные data в структуре (модифицирует, копирует куда-то);
3. помечает данные элемент пула свободным (fl_busy = 0);

Вопросы:

1. Какие вообще механизмы лучше использовать в подобных задачах, чтобы не снижать производительность, но при этом добиться, чтобы значение флагов в элементах пула было видимым и актуальным в обоих потоках и гарантировать правильную последовательность действий в потоках? Volatile в каждом элементе пула использовать совсем не хочется из-за производительности, да и все проблемы он, вероятно, не решит. Кажется, что тут имеет смысл использовать барьеры памяти, но я пока плохо с ними освоилась, и мне не помешал бы пример.
2. Нужны ли тут атомарные функции и объявление fl_busy как atomic, с учетом что флаг всего байт?

Answer 1

Прямо отвечая на ваши требования - Вам нужно использовать std::atomic_flag.

Он гарантирует вам атомарность и когерентность операций. volatile - это устаревший подход из мира C++98, когда компиляторы ничего не знали о том, что программа может выполняться параллельно.

Относительно барьеров памяти. Если вы внимательно почитаете, какие параметры кушают атомарные переменные в C++, вы там эти самые memory orders увидите. По умолчанию они как раз обеспечивают то, что вы просите - когерентность.

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

Потому что это может быть, как минимум

mov память, регистр
add регистр
mov регистр, память

А теперь пришел планировщик, и после первого mov все сломал.

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

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

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

Answer 2

флаг всего байт - какая разница?! Хоть полбайта! :-) АТОМАРНОСТЬ в многопотоковом программировании означает нечто совсем другое. Конкретно, вот вы пишете:

1. проверям fl_busy = 0
2. помечаем fl_busy = 1

Вы понимаете, что в момент МЕЖДУ пунктом 1 и пунктом 2 может произойти прерывание и управление передано будет на другую нить? И вся программа рухнет..

Так вот АТОМАРНОЙ будет операция, объединяющая пункты 1 и 2 и которая не может быть прервана. Эта операция в большинстве ОС реализована с помощью механизма мьютексов. Читайте !!! Это большая и сложная тема.