嵌入式C基础——循环队列 ringbuffer 讲解

浪矢杂谈2024-04-07 17:14

本期主题：

讲解ARRAY_SIZE的作用以及定义，还有一个踩坑分析

往期链接：

目录

1. Ringbuffer定义及特点

Ringbuffer的定义：

环形缓冲区（Ring Buffer），也称为循环缓冲区、环形队列（Ring Queue）或循环队列（Circular Queue），是一种用于在固定大小的存储区域中存储数据的数据结构。

环形缓冲区通常由一个固定大小的数组和两个指针组成，分别用于指示缓冲区的起始位置和结束位置。数据被顺序地存储在数组中，当到达数组的末尾时，数据会"循环"回到数组的起始位置，实现了环形的存储结构。

Ringbuffer的特点：

环形缓冲区通常用于实现数据在生产者和消费者之间的高效传输，特别是在多线程或多任务环境中。它具有以下特点和优势：

  • 高效性： 环形缓冲区采用循环结构，避免了数据的频繁搬移。这使得对于生产者和消费者来说，插入和删除操作的时间复杂度都是 O(1)。
  • 固定大小： 环形缓冲区有一个固定的大小，这使得其占用的内存是可控的。当缓冲区已满时，生产者会被阻塞，以免过度生产数据，同时保护消费者不会因为数据积压而失去响应能力。
  • 无需动态内存分配： 环形缓冲区一般使用静态数组作为存储空间，无需动态内存分配，因此可以在嵌入式系统等资源受限的环境中使用。
  • 循环利用空间： 环形缓冲区的循环结构使得空间可以被循环利用，即使数据已经被消费，存储空间也可以被后续的数据重新利用。
  • 并发安全： 当环形缓冲区被多个线程或任务访问时，需要通过互斥锁或其他同步机制来保护共享资源，以确保线程安全。

使用环形缓冲区时，需要注意处理好生产者和消费者之间的同步和竞态条件，以及处理好缓冲区空间不足和溢出的情况。同时，还需要考虑如何优雅地处理缓冲区已满和已空时的阻塞与唤醒机制。

2.ringbuffer实例（rtos实例）

ringbuffer比较难处理的一个问题就是 当read_ptr = write_ptr 时，此时并不是很确定ringbuffer是empty还是full，rtos和Linux中的设计使用的是 镜像法，具体的意思是：

镜像扩展位是环形缓冲区中的一个额外的标志位或变量，用于指示缓冲区的填充状态。它通常有两种取值：

  • 未填满（Not Full）： 表示缓冲区还有空闲空间，可以继续向缓冲区写入数据。
  • 填满（Full）： 表示缓冲区已经填满，不能再继续向缓冲区写入数据。此时，继续写入数据可能会覆盖已有的数据，造成数据丢失。

使用镜像扩展位，当缓冲区填满时，生产者可以根据镜像扩展位的状态来判断是否继续写入数据。如果缓冲区未填满，生产者可以继续写入数据；如果缓冲区已经填满，则生产者应该等待，直到缓冲区有空间可用。

2.1 ringbuffer结构体

看rtos的实例代码：

c 复制代码 
struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;
    /* use the msb of the {read,write}_index as mirror bit. You can see this as
     * if the buffer adds a virtual mirror and the pointers point either to the
     * normal or to the mirrored buffer. If the write_index has the same value
     * with the read_index, but in a different mirror, the buffer is full.
     * While if the write_index and the read_index are the same and within the
     * same mirror, the buffer is empty. The ASCII art of the ringbuffer is:
     *
     *          mirror = 0                    mirror = 1
     * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+
     * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Full
     * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+
     *  read_idx-^                   write_idx-^
     *
     * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+
     * | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Empty
     * +---+---+---+---+---+---+---+|+~~~+~~~+~~~+~~~+~~~+~~~+~~~+
     * read_idx-^ ^-write_idx
     */

    rt_uint32_t read_mirror : 1;
    rt_uint32_t read_index : 31;
    rt_uint32_t write_mirror : 1;
    rt_uint32_t write_index : 31;
    /* as we use msb of index as mirror bit, the size should be signed and
     * could only be positive. */
    rt_int32_t buffer_size;
};

结构体中有一个read_mirror和write_mirror，看注释可以知道是表示，read/write的指针是否到了mirror区，并且：

  1. read_index = write_index， read_mirror和write_mirror不同，此时为FULL
  2. read_index = write_index， read_mirror和write_mirror相同，此时为EMPTY

2.2 ringbuffer获取当前长度

RTOS中代码：

c 复制代码 
rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
    switch (rt_ringbuffer_status(rb))
    {
    case RT_RINGBUFFER_EMPTY:
        return 0;
    case RT_RINGBUFFER_FULL:
        return rb->buffer_size;
    case RT_RINGBUFFER_HALFFULL:
    default:
    {
        rt_size_t wi = rb->write_index, ri = rb->read_index;

        if (wi > ri)
            return wi - ri;
        else
            return rb->buffer_size - (ri - wi);
    }
    }
}

有三种情况：

  1. 当rt_status为空时，len为0
  2. 当rt_status为满时，len为buffer_size
  3. 当ringbuffer非空/满时，如果write_index>read_index，那么buffer_size为 wi-ri，否则为 rb->buffer_size - (ri - wi)

2.3 ringbuffer put

put代码如下：

c 复制代码 
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
                            const rt_uint8_t     *ptr,
                            rt_uint32_t           length)
{
    rt_uint32_t size;

    RT_ASSERT(rb != RT_NULL);

    /* whether has enough space */
    size = rt_ringbuffer_space_len(rb);

    /* no space */
    if (size == 0)
        return 0;

    /* drop some data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        rt_memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;
        return length;
    }

    rt_memcpy(&rb->buffer_ptr[rb->write_index],
              &ptr[0],
              rb->buffer_size - rb->write_index);
    rt_memcpy(&rb->buffer_ptr[0],
              &ptr[rb->buffer_size - rb->write_index],
              length - (rb->buffer_size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    return length;
}

逻辑是：

  1. 判断剩余空间的size是否足够放下数据，如果不够则需要drop一些数据
  2. 如果可以直接放，不需要循环回来，那么就直接Memcpy就行
  3. 如果需要循环回来，write_mirror需要取反

3.根据rtos代码，设计ringbuffer，并测试

代码如下：

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include "main.h"

struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;
    rt_uint32_t read_mirror : 1;
    rt_uint32_t read_index : 31;
    rt_uint32_t write_mirror : 1;
    rt_uint32_t write_index : 31;
    rt_int32_t buffer_size;
};

enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb)
{
    if (rb->read_index == rb->write_index)
    {
        if (rb->read_mirror == rb->write_mirror)
            return RT_RINGBUFFER_EMPTY;
        else
            return RT_RINGBUFFER_FULL;
    }
    return RT_RINGBUFFER_HALFFULL;
}

int rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
    switch (rt_ringbuffer_status(rb))
    {
    case RT_RINGBUFFER_EMPTY:
        return 0;
    case RT_RINGBUFFER_FULL:
        return rb->buffer_size;
    case RT_RINGBUFFER_HALFFULL:
    default:
    {
        rt_size_t wi = rb->write_index, ri = rb->read_index;

        if (wi > ri)
            return wi - ri;
        else
            return rb->buffer_size - (ri - wi);
    }
    }
}

struct rt_ringbuffer *ringbuffer_init(rt_int32_t size)
{
	struct rt_ringbuffer *rb;
	rt_uint8_t *pool;
	
	rb = (struct rt_ringbuffer *)malloc(sizeof(struct rt_ringbuffer));
	if (!rb) {
		printf("rb is null\n");
		return NULL;
	}
	
	pool = (rt_uint8_t *)malloc(size);
	if (!pool) {
		printf("pool is null\n");
		return NULL;
	}
	
	rb->buffer_ptr = pool;
	rb->buffer_size = size;
	
	rb->read_mirror = rb->read_index = 0;
	rb->write_mirror = rb->write_index = 0;
	
	return rb;
} 

/** return the size of empty space in rb */
#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))

int rt_ringbuffer_put(struct rt_ringbuffer *rb,
                      const rt_uint8_t     *ptr,
                      rt_uint32_t           length)
{
    rt_uint32_t size;

    /* whether has enough space */
    size = rt_ringbuffer_space_len(rb);

    /* no space */
    if (size == 0)
        return 0;

    /* drop some data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;
        return length;
    }

    memcpy(&rb->buffer_ptr[rb->write_index],
              &ptr[0],
              rb->buffer_size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
              &ptr[rb->buffer_size - rb->write_index],
              length - (rb->buffer_size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    return length;
}

int rt_ringbuffer_get(struct rt_ringbuffer *rb,
                      rt_uint8_t           *ptr,
                      rt_uint32_t           length)
{
    int size;

    /* whether has enough data  */
    size = rt_ringbuffer_data_len(rb);

    /* no data */
    if (size == 0)
        return 0;

    /* less data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->read_index > length)
    {
        /* copy all of data */
        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->read_index += length;
        return length;
    }

    memcpy(&ptr[0],
              &rb->buffer_ptr[rb->read_index],
              rb->buffer_size - rb->read_index);
    memcpy(&ptr[rb->buffer_size - rb->read_index],
              &rb->buffer_ptr[0],
              length - (rb->buffer_size - rb->read_index));

    /* we are going into the other side of the mirror */
    rb->read_mirror = ~rb->read_mirror;
    rb->read_index = length - (rb->buffer_size - rb->read_index);

    return length;
}

int main(void)
{
	int ret;
	struct rt_ringbuffer *rb = NULL;

	rb = ringbuffer_init(4);
	if (!rb) {
		printf("rb init failed\n");
		return -1;
	}
	
	uint8_t a[4] = {0x1, 0x2, 0x3, 0x4};
	uint8_t read[4] = { 0 };

	ret = rt_ringbuffer_put(rb, a, 4);
	ret = rt_ringbuffer_get(rb, read, 1);
	
	for (int i = 0; i < 4; i++) {
		printf("0x%x\n", read[i]);
	}
	
	ret = rt_ringbuffer_put(rb, a, 4);
	ret = rt_ringbuffer_get(rb, read, 4);
		for (int i = 0; i < 4; i++) {
		printf("0x%x\n", read[i]);
	}

	return 0;
}
c 复制代码 
//main.h
#ifndef __MAIN_H__
#define __MAIN_H__

#include <stdio.h>
#include <stdint.h>

typedef uint8_t rt_uint8_t;
typedef uint32_t rt_uint32_t;
typedef int32_t rt_int32_t;
typedef int 	rt_size_t;

enum rt_ringbuffer_state
{
    RT_RINGBUFFER_EMPTY,
    RT_RINGBUFFER_FULL,
    /* half full is neither full nor empty */
    RT_RINGBUFFER_HALFFULL,
};

#endif

测试结果：

相关推荐
EterNity_TiMe_11 分钟前
【论文复现】（CLIP）文本也能和图像配对
python·学习·算法·性能优化·数据分析·clip
陌小呆^O^17 分钟前
Cmakelist.txt之win-c-udp-client
c语言·开发语言·udp
机器学习之心22 分钟前
一区北方苍鹰算法优化+创新改进Transformer！NGO-Transformer-LSTM多变量回归预测
算法·lstm·transformer·北方苍鹰算法优化·多变量回归预测·ngo-transformer
儿时可乖了25 分钟前
使用 Java 操作 SQLite 数据库
java·数据库·sqlite
ruleslol27 分钟前
java基础概念37：正则表达式2-爬虫
java
yyt_cdeyyds33 分钟前
FIFO和LRU算法实现操作系统中主存管理
算法
xmh-sxh-131443 分钟前
jdk各个版本介绍
java
alphaTao1 小时前
LeetCode 每日一题 2024/11/18-2024/11/24
算法·leetcode
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10量化方法怎么选？如何评估量化后的大模型LLM？