Files
templates/c/set-protocol/src/pcan_ring.c
T

107 lines
4.0 KiB
C

/*
* Кольцевая очередь байтов для одного производителя и одного потребителя. Размер хранилища
* должен быть степенью двойки; одна позиция резервируется для различения пустого и полного
* состояния.
*/
#include "pcan_ring.h"
/* storage живёт не меньше контекста очереди. Степень двойки позволяет
* заменять остаток от деления маской size - 1 во всех операциях. */
bool pcan_ring_init(pcan_ring_t *rb, uint8_t *storage, uint16_t size)
{
if ((rb == NULL) || (storage == NULL) || (size < 2U) ||
((size & (uint16_t)(size - 1U)) != 0U)) {
return false;
}
rb->buf = storage;
rb->size = size;
rb->head = 0U;
rb->tail = 0U;
rb->dropped = 0U;
return true;
}
uint16_t pcan_ring_count(const pcan_ring_t *rb)
{
return (uint16_t)((rb->head - rb->tail) & (uint16_t)(rb->size - 1U));
}
/* head == tail обозначает пустую очередь, поэтому одна ячейка всегда
* остаётся незанятой: полезная вместимость равна size - 1. */
uint16_t pcan_ring_free(const pcan_ring_t *rb)
{
return (uint16_t)(rb->size - 1U - pcan_ring_count(rb));
}
bool pcan_ring_put(pcan_ring_t *rb, uint8_t byte)
{
uint16_t next = (uint16_t)((rb->head + 1U) & (uint16_t)(rb->size - 1U));
if (next == rb->tail) {
rb->dropped++;
return false;
}
/* Сначала данные, затем публикация индекса: потребитель не должен
* увидеть новую позицию до того, как байт записан в хранилище. */
rb->buf[rb->head] = byte;
PCAN_BARRIER();
rb->head = next;
return true;
}
bool pcan_ring_get(pcan_ring_t *rb, uint8_t *byte)
{
if (rb->head == rb->tail) {
return false;
}
*byte = rb->buf[rb->tail];
PCAN_BARRIER();
rb->tail = (uint16_t)((rb->tail + 1U) & (uint16_t)(rb->size - 1U));
return true;
}
/* Блок добавляется целиком либо отклоняется целиком. Это сохраняет
* границы отправляемого кадра при недостатке свободного места. */
bool pcan_ring_write(pcan_ring_t *rb, const uint8_t *data, uint16_t len)
{
if (pcan_ring_free(rb) < len) {
rb->dropped += len;
return false;
}
uint16_t mask = (uint16_t)(rb->size - 1U);
uint16_t head = rb->head;
for (uint16_t i = 0U; i < len; i++) {
rb->buf[head] = data[i];
head = (uint16_t)((head + 1U) & mask);
}
/* Публикуем весь блок одной записью: читатель никогда не увидит
кадр наполовину. */
PCAN_BARRIER();
rb->head = head;
return true;
}
/* Возвращает непрерывный участок до конца массива, а не обязательно всё
* содержимое кольца. После обработки вызывающий сдвигает tail через consume. */
uint16_t pcan_ring_linear(const pcan_ring_t *rb, const uint8_t **ptr)
{
uint16_t head = rb->head;
uint16_t tail = rb->tail;
if (head == tail) {
*ptr = NULL;
return 0U;
}
*ptr = &rb->buf[tail];
return (head > tail) ? (uint16_t)(head - tail)
: (uint16_t)(rb->size - tail);
}
/* Предусловие: len не превышает число доступных байтов. Проверка здесь
* не выполняется; обычно передают размер реально обработанного участка. */
void pcan_ring_consume(pcan_ring_t *rb, uint16_t len)
{
rb->tail = (uint16_t)((rb->tail + len) & (uint16_t)(rb->size - 1U));
}