Добрый день!
В моём проекте не используется ОС, но, думаю, что актуальнее всего будет задать вопрос именно в этом форуме.
Есть драйвер (SPI), который использует кольцевую очередь.
У очереди есть "методы" Write и Read


в драйвере SPI метод Write вызывается из основного потока программы:

а метод Read вызывается из прерывания:

и всё работает хорошо при не очень интенсивном обмене данными, а если данных много, бывает, что прерывание по передаче возникает в момент, когда идёт выполнение функции Write, т.е. QUEUE_Read вызывается во время выполнения QUEUE_Write, данные в структуре очереди портятся и наступает жвах!
В данный момент приходится запрещать прерывания от SPI в начале функции SPI_Write и заного разрешать их в конце - но такой подход мне не очень нравится, т.к.
1) Нужно помнить и следить за всеми вызовами функций очереди и обрамлять их в подобные критическии секции, очень велик риск забыть и получить труднообнаруживаемый глюк при эксплуатации.
2) Много времени система проводит при запрещённых прерываниях, т.е. увеличивается время реакции на прерывание -> велик риск пропустить входящий байт (если SPI в слейве).
Может быть есть способ красиво разрулить эту ситуацию, внеся какие-то изменения в функции QUEUE_Read и QUEUE_Write, чтобы они не мешали друг-другу, будучи вызванными одновременно из разных потоков?
Извиняюсь за "многабуков"

Запрет прерываний в таком случае - вполне приемлимый способ.


Вставте критическую секцию в функцию SPI_WriteByte. На выходе из функции разрешайте прерывания.


Если запрещать прырывания только на запись байта, то запрет недолгий.

Если операции с _queue->Count атомарны, то достаточно объявить его volatile.
Если нет, то придётся или взводить флаг на время операций с _queue->Count вне прерываний, или добавлять критические секции там же.

Если у процессора нет атомарных операций (или LL/SC, или HTM и т.д.), то без запрещения прерываний на время работы с _queue->Count не обойтись.
С флагом не получится, т.к. ждать в прерывании пока отработает QUEUE_Write() можно до бесконечности.

Разве я сказал, что в прерывании нужно ждать сброса флага?

Операция инкремента (INC) - атомарна, а разыменование указателя - нет

Процессор - stm8

А что вы предлагаете делать? Код ошибки вернуть нельзя, вызвать UnderflowFunc() тоже...

UPD: Нужны атомарные чтение-запись + инкремент. Разыменование это тоже чтение. Правда, с stm8 я не работал.

Сообщение отредактировал vshemm - Oct 29 2012, 13:26

По-моему, очевидно - ничего не делать.

Содержимого ... не знаю, может потребуются уточнения.


Как-то не похоже оно на атомарность. С stm8 тоже не работал, но конструкция для современного проца и компилятора выглядит чудесато.

Есть же неблокирующий вариант очереди с read_ptr и write_ptr, без count-а.

Очень интересно, не могли бы Вы дать ссылку или привести пример? Count, по большому счёту, нужен только чтобы отслеживать переполнение и опустошение очереди, не хотелось бы потерять эту функцию.

Да там всё элементарно. Есть два индекса - put и get. Буфер пуст, если put == get. Буфер полон, если put + 1 == get.
запись в буфер:

temp = (put + 1) % SIZE;
if (temp == get) return -1; // buffer full
buffer[put] = ch;
put = temp;

чтение из буфера:
if (put == get) return -1; // empty
ch = buffer[get++];
get %= SIZE; // limit the pointer
return ch

При условии: один писатель, один читатель - прерывания можно не запрещать.

для случая sizeof(put) <= sizeof(sig_atomic_t)
Иначе надо подумать о возможных эффектах при прерывании, например, в середине чтения основной програмой индекса, изменяемого в прерывании.

Да, точно. Я не придумал, как это сформулировать
В этом случае можно читать индекс до совпадения результатов двух последовательных чтений.

Фьютексы же.

Можно использовать два буфера (что, собственно, реализуется большинством ОС) - один на чтение, второй на запись. Буфер на запись можно использовать свободно.

Дальше используем две дополнительные переменные - lockFlag и readed.

в основной программе:

lockFlag = 1;
<read data here>
readed += <readed size>
lockFlag = 0;

в обработчике:

if (!lockFlag)
{
real_size -= readed;
readed = 0;
}