ringbuff

已于 2022-03-30 17:03:22 修改
阅读量212 收藏
点赞数
文章标签： 单片机 stm32
于 2022-03-19 17:10:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694204/article/details/123598364
版权

 rb.h

/**********************************************************************
 *   Copyright (C) 2022 ()).inc All rights reserved.
 *   
 *   @file:        rb.h
 *   @brief:       环形缓冲数组
 *                  1.写满了就没法继续写入
 *                  2.数组空间会自动扩展为2的幂次方
 *                  3.尽量使用宏的函数
 *   @author:      GuoKai (Kane)
 *   @maintainer:  835430683@qq.com
 *   @versioin:    1.0
 *   @data:        2022-03-30
 *   
**********************************************************************/

#ifndef _RB_H_
#define _RB_H_

#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>

#ifndef MIN
#define MIN(l, r) (((l) < (r)) ? (l) : (r))
#endif

typedef struct
{
    uint8_t *buf;
    uint32_t size;
    uint32_t read_pos;
    uint32_t wirte_pos;
} ringbuff_t;

//初始化函数
#define rb_init_8(r, sz) rb_init(r, sz)
#define rb_init_16(r, sz) rb_init(r, sz * 2)
#define rb_init_32(r, sz) rb_init(r, sz * 4)

//已经使用的空间，数据数量
#define rb_length_8(r) rb_length(r, 1)
#define rb_length_16(r) rb_length(r, 2)
#define rb_length_32(r) rb_length(r, 4)

//数组剩余空间，数据数量
#define rb_remain_8(r) rb_remain(r, 1)
#define rb_remain_16(r) rb_remain(r, 2)
#define rb_remain_32(r) rb_remain(r, 4)

//写数据，写多少个数据，不关心类型
#define rb_write_8(r, buf, sz) rb_write(r, buf, sz, 1)
#define rb_write_16(r, buf, sz) rb_write(r, buf, sz, 2)
#define rb_write_32(r, buf, sz) rb_write(r, buf, sz, 4)

//从ringbuff里面读取sz个数据到buf里面，不关心类型
#define rb_read_8(r, buf, sz) rb_read(r, buf, sz, 1)
#define rb_read_16(r, buf, sz) rb_read(r, buf, sz, 2)
#define rb_read_32(r, buf, sz) rb_read(r, buf, sz, 4)

static inline int32_t rb_isempty(ringbuff_t *r); //满
static inline int32_t rb_isfull(ringbuff_t *r);  //空
static inline int32_t is_power_of_two(uint32_t sz);
static inline uint32_t roundup_power_of_two(uint32_t sz);
void rb_init(ringbuff_t *r, uint32_t sz);
void rb_clear(ringbuff_t *r);
void rb_free(ringbuff_t *r);
uint32_t rb_length(ringbuff_t *r, uint32_t byteNum);
uint32_t rb_remain(ringbuff_t *r, uint32_t byteNum);
uint32_t rb_write(ringbuff_t *r, void *buf, uint32_t sz, uint32_t byteNum);
uint32_t rb_read(ringbuff_t *r, void *buf, uint32_t sz, uint32_t byteNum);

#endif // header content

rb.c 

/**********************************************************************
 *   Copyright (C) 2022 ().inc All rights reserved.
 *   
 *   @file:        rb.c
 *   @brief:       环形缓冲数组
 *                  1.写满了就没法继续写入
 *                  2.数组空间会自动扩展为2的幂次方
 *                  3.尽量使用宏的函数
 *   @author:      GuoKai (Kane)
 *   @maintainer:  835430683@qq.com
 *   @versioin:    1.0
 *   @data:        2022-03-30
 *   
**********************************************************************/

//核心在于size是不是2的幂
//一直加，直到溢出变为0
//ringbuff只解决了数据移动频繁问题，但是没有解决固定内存分配和生产消费速度问题

//多线程环境下
//1.一对一的情况下可以不加锁，但是需要加内存屏障，类似volatile
//2.多读多写的情况下，需要加锁，并且加内存屏障，如果是自旋锁可以不加

/**
 * @name     rb_isempty()
 * @brief    判断数据是否满(无法一次性写入所有数据)
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
static inline int32_t rb_isempty(ringbuff_t *r) //满
{
    return r->read_pos == r->wirte_pos; //相等为1，即为true
}

/**
 * @name     rb_isfull()
 * @brief    判断数据是否是空的
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
static inline int32_t rb_isfull(ringbuff_t *r) //空
{
    return r->size == r->wirte_pos - r->read_pos;
}

//是不是2的幂
// m%2=m&(n-1)
// m%n = m - n * (floor(m/n))
/**
 * @name     is_power_of_two()
 * @brief    判断数组空间是不是2的幂
 * @uint32_t sz：多少个数据，与类型无关
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
static inline int32_t is_power_of_two(uint32_t sz)
{
    if (sz < 2)
        return sz;
    return (sz & (sz - 1)) == 0;
}

// 2的幂 优化
/**
 * @name     roundup_power_of_two()
 * @brief    将数组空间调整为2的幂的长度
 * @uint32_t sz：多少个数据，与类型无关
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
static inline uint32_t roundup_power_of_two(uint32_t sz)
{
    if (sz < 2)
        sz = 2;
    // 5 -> 101  应该为8，即1000
    //******右移3次后就没有1了，然后return 1左移3次
    int32_t i = 0;

    for (; sz != 0; ++i)
        sz = sz >> 1;

    return 1U << i;
}

/**
 * @name     rb_init()
 * @brief    初始化ringbuff，默认是uint8_t类型,
 * @author   Kane (835430683@qq.com)
 * @uint32_t sz：多少个数据，与类型无关
 * @return   void 
*/
void rb_init(ringbuff_t *r, uint32_t sz)
{
    r->buf = (uint8_t *)malloc(sz * sizeof(uint8_t));

    if (!is_power_of_two(sz)) //如果不是2的幂，就重新计算size的大小
        sz = roundup_power_of_two(sz);

    r->size = sz;

    r->read_pos = r->wirte_pos = 0;
}

/**
 * @name     rb_clear()
 * @brief    ringbuff清空数据
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
void rb_clear(ringbuff_t *r)
{
    if (r == NULL)
        return;
    memset(r->buf, 0, r->size);
    r->read_pos = r->wirte_pos = 0;
}

/**
 * @name     rb_free()
 * @brief    销毁ringbuff
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
void rb_free(ringbuff_t *r)
{

    if (r->buf != 0)
    {
        free(r->buf);
        r->buf = 0;
    }

    r->read_pos = r->wirte_pos = r->size = 0;
}

/**
 * @name     rb_length()
 * @brief    已经使用了多少空间(除每个数据占用的字节数）
 * uint32_t  byteNum：每个数据占用的字节数，由宏自动填充
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
uint32_t rb_length(ringbuff_t *r, uint32_t byteNum)
{
    if (r->wirte_pos >= r->read_pos)
        return (r->wirte_pos - r->read_pos) / byteNum;
    else
        return (r->size - r->read_pos + r->wirte_pos) / byteNum;
}

/**
 * @name     rb_remain()
 * @brief    已经使用了多少空间(除每个数据占用的字节数）
 * uint32_t  byteNum：每个数据占用的字节数，由宏自动填充
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
uint32_t rb_remain(ringbuff_t *r, uint32_t byteNum)
{
    if (r->wirte_pos > r->read_pos)
        return (r->size - r->wirte_pos + r->read_pos) / byteNum;
    else if (r->wirte_pos < r->read_pos)
        return (r->read_pos - r->wirte_pos) / byteNum;
    else //==0
        return r->size;
}

/**
 * @name     rb_write()
 * @brief    将buf里面sz个数据写到ringbuff里面
 * ringbuff_t *r：句柄，内涵了rb，被写的
 * void      *buf：要写的数据
 * uint32_t  sz：写多少
 * uint32_t  byteNum：要写入几个数据，不关心数据的byte，由宏自动填充
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
uint32_t rb_write(ringbuff_t *r, void *buf, uint32_t sz, uint32_t byteNum)
{
    sz = sz * byteNum;
    if (sz > rb_remain_8(r))
        return 0;

#ifdef USER_MB
    //内存屏障，类似 volatile
    //确保开始移动buffer时read_pos
    smp_mb(); // atomic_thread_fence()
#endif

    //要写的长度和剩余的长度做比较
    //剩余的长度采用位运算
    uint32_t i = MIN(sz, r->size - (r->wirte_pos & (r->size - 1)));

    if (sz < r->size - (r->wirte_pos & (r->size - 1))) //要写的长度小于剩余的长度，直接写
    {
        memcpy(r->buf + (r->wirte_pos & (r->size - 1)), buf, i);
        r->wirte_pos += i;
    }
    else
    {
        uint8_t *retAddr = (uint8_t *)buf;
        memcpy(r->buf + (r->wirte_pos & (r->size - 1)), &retAddr[0], i);
        memcpy(r->buf, &retAddr[i], sz - i);
        r->wirte_pos = sz - i; //写指针偏位
    }

#ifdef USER_MB
    //内存屏障，类似 volatile
    //确保write_pos 不会被优化到前面
    smp_mb(); // atomic_thread_fence()
#endif

    return sz;
}

/**
 * @name     rb_read()
 * @brief    将ringbuff里面sz个数据读取到buf里面
 * ringbuff_t *r：句柄，内涵了rb，要读的
 * void      *buf：度到哪儿
 * uint32_t  sz：读多少个
 * uint32_t  byteNum：不关心数据的byte，由宏自动填充
 * @author   Kane (835430683@qq.com)
 * @return   void 
*/
uint32_t rb_read(ringbuff_t *r, void *buf, uint32_t sz, uint32_t byteNum)
{
    if (rb_isempty(r))
    {
        return 0;
    }

    sz = sz * byteNum;
    sz = MIN(sz, rb_length_8(r));

#ifdef USER_MB
    //内存屏障，类似 volatile
    //确保开始移动buffer时read_pos
    smp_mb(); // atomic_thread_fence()
#endif

    uint32_t i = MIN(sz, r->size - (r->read_pos & (r->size - 1)));

    if (sz < r->size - (r->read_pos & (r->size - 1))) //要读的数据不需要回车
    {
        memcpy(buf, r->buf + (r->read_pos & (r->size - 1)), i);
        r->read_pos += sz;
    }
    else //需要回车读取
    {
        printf("\nenter\n");
        uint8_t *retAddr = (uint8_t *)buf;

        memcpy(retAddr, r->buf + (r->read_pos & (r->size - 1)), i);
        memcpy(&retAddr[i], r->buf, sz - i);

        r->read_pos = sz - i;
    }

#ifdef USER_MB
    //内存屏障，类似 volatile
    //确保read_pos 不会被优化到前面
    smp_mb(); // atomic_thread_fence()
#endif

    return sz;
}

demo
// int main()
// {

//     ringbuff_t rb = {0};
//     rb_init_8(&rb, 7); //9被提升到8，17被提升到8,u8字节空间
//     uint8_t buf[8] = {1, 2, 3, 4, 5, 6, 7, 0};
//     uint8_t put1 = rb_write_8(&rb, (void *)buf, 7);

//     printf("put1=%u, wr=%u, rd=%u, l=%u sy=%u\n", put1, rb.wirte_pos, rb.read_pos, rb_length_8(&rb), rb_remain_8(&rb));
//     uint8_t buf2[1024] = {0};
//      //应该先读length，再read的
//     uint8_t get1 = rb_read_8(&rb, buf2, 6); //是否需要双倍读出
//     printf("get1=%u, wr=%u, rd=%u, l=%u sy=%u\n", get1, rb.wirte_pos, rb.read_pos, rb_length_8(&rb), rb_remain_8(&rb));
//     for (int i = 0; i < 8; ++i)
//     {
//         printf("%d ", buf2[i]);
//     }
//     printf("\n");
//     printf("put-------------------\n");
//     uint8_t put2 = rb_write_8(&rb, (void *)buf, 4);
//     printf("put2=%u, wr=%u, rd=%u, l=%u sy=%u\n", put2, rb.wirte_pos, rb.read_pos, rb_length_8(&rb), rb_remain_8(&rb));

//     printf("\nget-------------------\n");
//     uint8_t buf3[1024] = {0};
//     uint8_t get3 = rb_read_8(&rb, buf3, 5); //是否需要双倍读出
//     printf("get3=%u, wr=%u, rd=%u, l=%u sy=%u\n", get3, rb.wirte_pos, rb.read_pos, rb_length_8(&rb), rb_remain_8(&rb));
//     for (int i = 0; i < 5; ++i)
//     {
//         printf("%d ", buf3[i]);
//     }

//     return 0;
// }

墨子非阿萨德
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
通用FIFO环形缓冲区实现的开源库.zip
03-04
通用FIFO环形缓冲区实现的开源库.zip
[缓存] RingBuff 环形队列、环形缓冲区及有锁无锁实现
最新发布
小田的专栏
02-20 1369
由于自旋锁不需要进行线程切换，所以它完全在用户态下实现，加锁开销低，但是由于其采用忙等待的策略，对于短期加锁来说没问题，但是长期锁定的时候就会导致CPU资源的大量消耗。如果读取数据的速度跟不上写入数据的速度，旧的数据将被新写入的数据覆盖。所以当互斥锁加锁失败的时候，就伴随着两次上下文切换的开销，而如果我们锁定的时间较短，可能上下文切换的时间会比锁定的时间还要长。由于自旋锁和互斥锁的失败策略不同，自旋锁采用忙等待的策略，而互斥锁采用线程切换的策略，由于策略不同，它们的应用场景也不同。
c语言图文详解 实现ringbuff 源码详解
杀手的博客
08-28 3641
一 什么是ringbuff ringbuff是环形buff，是buff缓存的一种，可以用来存放程序运行过程的暂时数据。一般的buff即是一个数组，而环形buff就是将数组的头和尾链接起来的数组。 老规矩，源码先放这：https://gitee.com/killerp/ringbuff.git 1，ringbuff的优点 ringbuff比普通的buff使用更加高效灵活，可以边读数据边写数据。 二 ringbuff的实现 一个ringbuff的实现至少需要以下四个功能： 创建ringbuff 数据写入rin
Ring Buffer 原理
xiandang8023的博客
08-24 3799
因为这些新的节点的确已经写入了数据（Ring Buffer本身的序号已经更新），而且消费者对这些节点的唯一操作是读而不是写，因此访问不用加锁。在上面的例子中，消费者处理完了Ring Buffer里序号8之前（包括8）的所有数据，那么它期待访问的下一个序号是9。现在序号12到了，消费者可以让ConsumerBarrier去拿这些序号节点里的数据了。另一个好处是——你可以用多个消费者(Consumer)去读同一个RingBuffer ，不需要加锁，也不需要用另外的队列来协调不同的线程(消费者)。
ringbuff-develop.zip
03-19
环形缓冲区（Ring Buffer），又称为循环队列，是一种高效的数据结构，广泛应用于各种实时系统和嵌入式系统中，特别是在数据传输、缓存管理、多线程通信等领域。在C语言中实现环形缓冲区，需要理解其基本原理，并掌握...
Rt-thead studio软件下使用ringbuffer
04-21
在嵌入式系统开发中，实时操作系统（RTOS）如RT-Thread经常被用来管理多任务并确保系统的高效、稳定运行。RT-Thread Studio是一款强大的集成开发环境，它为RT-Thread提供了一站式的开发工具链，包括编辑、编译、调试...
消息队列方式实现串口数据不定长接收 —- RT-thread&STM32
01-20
Life moves pretty fast. If you don’t stop and look around once in a while, you could miss it. 人生匆匆，若不偶尔停下来看看周围，便会错过许多风景。 一、串口数据不定长接收的实现 通常在裸机中，我们使用...
ringbuffer:固定大小，异常安全的STL样式循环缓冲区的C ++ 1114实现，用于单线程和多线程上下文
04-28
环形缓冲区线程安全和非线程安全的固定大小，模板化，STL样式的atomic_ringbuffer.hpp缓冲区（分别为atomic_ringbuffer.hpp和ringbuffer.hpp ）的单头C ++实现。 两种版本均完全支持RAII / RRID，并在可能的情况下...
STM32F4_URAT.zip
11-08
在给定的"STM32F4_URAT.zip"压缩包中，我们可以看到一系列与STM32F4微控制器相关的文件，涉及的主要知识点包括双串口通信、USART（通用同步/异步收发传输器）以及RINGBUFF（环形缓冲区）。 首先，双串口通信是指在...
无锁队列ringbuff实现以及性能
zhqblog的博客
06-29 369
以上场景对于有锁队列和无锁队列都可以使用的，但还如果对性能要求比较高，比如需要达到上万ops，就可以考虑优先使用无锁队列。相反如果性能达不到这么高使用有锁队列和无锁队列性能差别并不大，但是有锁队列实现会更加简单。以同样的数据结构（环形队列）实现一个有锁的队列，进行对比测试，两者的区别就在于一个加锁一个无锁，消费者在取出数据后会进行1000 次 empty loop。系统：Debian x86_64虚拟机，4核4G。本文采用的是循环队列的实现方式。
C语言，环形队列
嵌入式Linux
11-15 2016
什么是环形队列？环形缓冲区是一个非常典型的数据结构，这种数据结构符合生产者，消费者模型，可以理解它是一个水坑，生产者不断的往里面灌水，消费者就不断的从里面取出水。那就可能...
服务器正文16：缓冲区设计（ringbuffer、用libevent配合ringbuffer做无锁队列）
谢白羽
06-06 846
文章目录一、为什么用户层需要设计网络缓冲区二、寿司ringbuffer以及多线程换将下数据安全思考三、libevent中event buffer的设计 一、为什么用户层需要设计网络缓冲区 二、寿司ringbuffer以及多线程换将下数据安全思考 三、libevent中event buffer的设计 https://www.bilibili.com/video/BV1ZL411M7Qz?spm_id_from=333.337.search-card.all.click ...............
单片机常用环形队列--ringbuff
路过的熊的博客
02-20 688
单片机环形队列的一种实现
ringbuff | 通用FIFO环形缓冲区实现库
Mculover666的博客（嵌入式）
06-06 6547
嵌入式开源项目精选专栏 本专栏由Mculover666创建，主要内容为寻找嵌入式领域内的优质开源项目，一是帮助开发者使用开源项目实现更多的功能，二是通过这些开源项目，学习大佬的代码及背后的实现思想，提升自己的代码水平，和其它专栏相比，本专栏的优势在于： 不会单纯的介绍分享项目，还会包含作者亲自实践的过程分享，甚至还会有对它背后的设计思想解读。 目前本专栏包含的开源项目有： cJSON | 一个轻量级C语言JSON解析器 paho | 支持10种语言编写mqtt客户端，总有一款适合你！ MultiButt.
Ring Buffer的常规用法（循环缓存区）
热门推荐
Wildfire（野火）的博客
08-26 1万+
Ring Buffer的常规用法与高级用法（一） 在涉及到模块与模块间数据传输缓存处理、通信程序中，经常使用环形缓冲区（Ring Buffer）作为数据结构来存放通信中发送和接收的数据，下面我将从以下几个方面介绍的是环形缓冲区（Ring Buffer）的常规用法与高级用法。 目录 Ring Buffer的常规用法与高级用法（一） 目录 环形缓冲区（Ring Buffer）的实现原理 ...
RT-Thread 隐藏的宝藏之ringbuff
whj123999的博客
03-21 3170
一，什么是 ringbuff ringbuff: 翻译成中文就是环形缓冲区。 网上关于 ringbuff 的介绍已经非常多了，我也分享一下我对 ringbuff 的认识。ringbuff 可以理解为学校操场上的跑道，ringbuff 初始化就是新建了一个 400 的环形操场跑道，跑道上有 2 名同学 (write 和 read)，每次写入一个数据，write 往前跑一步，每次读一个数据，read 往前跑一步，read永远不可以超过 write。刚开始起点都是 0 ，如果 write 写的速度慢了，被 re
从uart到serial-ringbuff（环形缓存）
心碎乌托邦
10-17 9226
最近在写一个serial 的应用想起以前写过的一些单片机上的uart 程序，有着许许多多的圈圈点点的，也就来扒一扒串口机制的事情了。 学习单片机都会接触到串口这个东西，多数的教程都是讲讲如何把寄存器配置好，然后可以发出数据、接收数据，而对如何应用基本完全不谈。而其实不管是哪一类CPU，串口的模式基本相同，毕竟这东西从单片机诞生至今也算是个白发老头的年纪了。uart 寄存器配置不说，每个CPU有自己...
ring buffer 环形队列 C++实现
隔壁老王呀的专栏
08-24 1397
#include <iostream> using namespace std; template <class T> class RingBuff { private: unsigned int m_size; int m_in; int m_out; T *m_data; public: R...
用STM32F407ZET6的HAL库写一个串口接收，发送代码，支持ringbuff
02-18
你可以参考这个示例代码：...这个示例教你如何使用STM32F407ZET6的HAL库实现串口接收和发送，并支持ringbuff。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值