一个简单的RingBuffer

最新推荐文章于 2024-03-14 21:44:41 发布
最新推荐文章于 2024-03-14 21:44:41 发布
阅读量610 收藏
点赞数 1
分类专栏： Linux 笔记 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/midaszhk/article/details/121373007
版权
Linux 同时被 2 个专栏收录
12 篇文章 3 订阅
订阅专栏
笔记
11 篇文章 0 订阅
订阅专栏

  写了一个简单的RingBuffer模块。  
  主要函数包括: egi_ringbuffer_create() (创建RingBuffer), egi_ringbuffer_free()(释放RingBuffer), egi_ringbuffer_write()(写入数据), egi_ringbuffer_read()(读出数据)。 通过一个mutex互斥锁来同步,以实现多个线程同时写和读.。

egi_ringbuffer.h

/*---------------------------------------------------------------------------
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.

"egi_ringbuffer.h"

Midas Zhou
midaszhou@yahoo.com
-------------------------------------------------------------------------*/
#ifndef __EGI_RINGBUFFER_H__
#define __EGI_RINGBUFFER_H__
#include <stdlib.h>

typedef struct {
	char*	 buffer;	/* Mem. space allocated */
	size_t	 buffsize;	/* Size of the ring buffer */
	size_t   datasize;	/* Size of available data buffered */
	off_t	 pw;		/* Offset to write position (Write pointer) */
	off_t    pr;		/* Offset to read position (Read pointer) */

	pthread_mutex_t ring_mutex;
} EGI_RINGBUFFER;

EGI_RINGBUFFER *egi_ringbuffer_create(size_t buffsize);
void egi_ringbuffer_free(EGI_RINGBUFFER **ringbuf);
size_t egi_ringbuffer_write(EGI_RINGBUFFER *ringbuf, void *src, size_t len);
size_t egi_ringbuffer_read(EGI_RINGBUFFER *ringbuf, void *dest, size_t len);

#endif

egi_ringbuffer.c

/*------------------------------------------------------------------
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.

A simple ring buffer.

Journal:
2021-11-15:
	1. Create the file and functions:
		egi_ringbuffer_create() egi_ringbuffer_free()
		egi_ringbuffer_write()	egi_ringbuffer_read()

Midas Zhou
midaszhou@yahoo.com
------------------------------------------------------------------*/
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
//#include <egi_debug.h>
#include "egi_ringbuffer.h"

/*-------------------------------------------
Create an EGI ring buffer

@buffsize:	Size of the ring buffer.

Return:
Pointer to EGI_RINGBUFFER	OK
NULL				Fails
-------------------------------------------*/
EGI_RINGBUFFER *egi_ringbuffer_create(size_t buffsize)
{
	EGI_RINGBUFFER *ringbuf=calloc(1, sizeof(EGI_RINGBUFFER));
	if(ringbuf==NULL) {
		//egi_dperr("Fail to calloc ringbuf!");
		return NULL;
	}

	ringbuf->buffer=calloc(1, buffsize);
	if(ringbuf->buffer==NULL) {
		//egi_dperr("Fail to calloc ringbuf->buffer!");
		free(ringbuf);
		return NULL;
	}
	ringbuf->buffsize=buffsize;

        if(pthread_mutex_init(&ringbuf->ring_mutex,NULL) != 0)
        {
		//egi_dperr("Fail init ring_mutex!");
		free(ringbuf->buffer);
                free(ringbuf);
                return NULL;
        }

	return ringbuf;
}

/*-------------------------------------------
Free an EGI ring buffer.
---------------------------------------------*/
void egi_ringbuffer_free(EGI_RINGBUFFER **ringbuf)
{
	if(ringbuf==NULL || *ringbuf==NULL)
		return;

        /* Hope there is no other user */
        if(pthread_mutex_lock(&(*ringbuf)->ring_mutex) !=0 )
		//egi_dperr("Fail lock ring_mutex");

#if 1   /*  "It shall be safe to destroy an initialized mutex that is unlocked. Attempting to
         *   destroy a locked mutex results in undefined behavior"  --- POSIX man/Linux man 3
         */
        if( pthread_mutex_unlock(&(*ringbuf)->ring_mutex) != 0)
		//egi_dperr("Fail unlock ring_mutex");
#endif

        /* Destroy thread mutex lock  */
        if(pthread_mutex_destroy(&(*ringbuf)->ring_mutex) !=0 )
		//egi_dperr("Fail destroy ring_mutex");

	/* Free mem */
	free((*ringbuf)->buffer);
	free(*ringbuf);

	*ringbuf=NULL;
}


/*-------------------------------------------
Wrtie data into a ring buffer.

@ringbuf:	Pointer to an ring buffer.
@src:		Soure of data.
@len:		Length of source data.

Note:
1. Assume pw will NOT surpass pr!

Return:
	>0	Actual size of data written
	=0	Ringbuffer is full.
		OR len==0.
	<0	Fails.
-------------------------------------------*/
size_t egi_ringbuffer_write(EGI_RINGBUFFER *ringbuf, void *src, size_t len)
{
	int ret=0;
	size_t lenx=0;

	if(ringbuf==NULL || src==NULL)
		return -1;

        /* Get mutex lock */
        if(pthread_mutex_lock(&ringbuf->ring_mutex) !=0 ){
		//egi_dperr("Fail to lock ring_mutex!");
		return -1;
        }
 /* ------ >>>  Critical Zone  */

	/* Check available space in the buffer. */

	/* Case_1. Ringbuffer is full! (pw==pr) */
	if( ringbuf->datasize == ringbuf->buffsize ) {
		/* Check */
		if(ringbuf->pw!=ringbuf->pr) {
			//egi_dpstd("ERROR! datasize==buffsize while pw!=pr !\n");
			ret=-2; goto END_FUNC;
		}
		else {
			ret=0; goto END_FUNC;
		}
	}

	/* Case_2. Ringbuffer has enough space:  */
	if( ringbuf->datasize + len <= ringbuf->buffsize ) {
		/* 2.1 Pw is not necessary to cross the ring END/HEAD */
		if( ringbuf->buffsize - ringbuf->pw >= len ) {
			memcpy(ringbuf->buffer+ringbuf->pw, src, len);
			/* update pw */
			ringbuf->pw += len;
			if(ringbuf->pw==ringbuf->buffsize)
				ringbuf->pw=0;
			/* update datasize */
			ringbuf->datasize +=len;

			ret=len; goto END_FUNC;
		}
		/* 2.2 pw is to cross the ring END/HEAD */
		else {
			/* Write to buffer END/HEAD */
			lenx = ringbuf->buffsize-ringbuf->pw;
			memcpy(ringbuf->buffer+ringbuf->pw, src, lenx);
			/* Write remaining from HEAD/END */
			memcpy(ringbuf->buffer+0, src+lenx, len-lenx);
			/* Update pw */
			ringbuf->pw=len-lenx;
			/* Update datasize */
			ringbuf->datasize +=len;

			ret=len; goto END_FUNC;
		}
	}
	/* Case_3. Ringbuffer has NOT enough space: */
	else  { /* if( ringbuf->datasize + len > ringbuf->buffsize ) */
		/* 3.1 Pw is not necessary to cross the ring head/end */
		if( ringbuf->pw < ringbuf->pr ) {
			/* Write till to pr */
			lenx=ringbuf->pr-ringbuf->pw;
			memcpy(ringbuf->buffer+ringbuf->pw, src, lenx);

			/* Update pw */
			ringbuf->pw = ringbuf->pr;
			/* update datasize */
			ringbuf->datasize +=lenx;

			ret=lenx; goto END_FUNC;
		}
		/* 3.2 pw is to cross the ring head/end */
		else {  /* pw > pr */
			/* Write till to END/HEAD */
			lenx=ringbuf->buffsize-ringbuf->pw;
			memcpy(ringbuf->buffer+ringbuf->pw, src, lenx);
			/* Write remaining from HEAD/END to pr */
			memcpy(ringbuf->buffer+0, src+lenx, ringbuf->pr);

			/* Update pw */
			ringbuf->pw = ringbuf->pr;
			/* update datasize */
			ringbuf->datasize +=(lenx+ringbuf->pr);

			ret=lenx+ringbuf->pr; goto END_FUNC;
		}
	}

END_FUNC:
/* ------- <<<  Critical Zone  */
        /* put mutex lock */
        pthread_mutex_unlock(&ringbuf->ring_mutex);

	return ret;
}

/*-------------------------------------------
Read data out from a ring buffer.

@ringbuf:	Pointer to an ring buffer.
@dest:		Destination of data.
@len:		Expected length of data to read.

Note:
1. Assume pw will NOT surpass pr!

Return:
	>0	Actual size of data read out.
	=0	Ringbuffer is Empty.
		OR len==0.
	<0	Fails.
-------------------------------------------*/
size_t egi_ringbuffer_read(EGI_RINGBUFFER *ringbuf, void *dest, size_t len)
{
	int ret=0;
	size_t lenx=0;

	if(ringbuf==NULL || dest==NULL)
		return -1;

        /* Get mutex lock */
        if(pthread_mutex_lock(&ringbuf->ring_mutex) !=0 ){
		//egi_dperr("Fail to lock ring_mutex!");
		return -1;
        }
 /* ------ >>>  Critical Zone  */

	/* Check available space in the buffer. */

	/* Case_1. Ringbuffer has Empty data! (pw==pr) */
	if( ringbuf->datasize==0 ) {
		/* Check */
		if(ringbuf->pw!=ringbuf->pr) {
			//egi_dpstd("ERROR! datasize==0 while pw!=pr !\n");
			ret=-2; goto END_FUNC;
		}
		else {
			ret=0; goto END_FUNC;
		}
	}

	/* Case_2. Ringbuffer has enough data:  */
	if( ringbuf->datasize >= len ) {
		/* 2.1 Pr is not necessary to cross the ring END/HEAD */
		if( ringbuf->buffsize - ringbuf->pr >= len ) {
			memcpy(dest, ringbuf->buffer+ringbuf->pr, len);
			/* update pr */
			ringbuf->pr += len;
			if(ringbuf->pr==ringbuf->buffsize)
				ringbuf->pr=0;
			/* update datasize */
			ringbuf->datasize -=len;

			ret=len; goto END_FUNC;
		}
		/* 2.2 pr is to cross the ring END/HEAD */
		else {
			/* Read till to buffer END/HEAD */
			lenx = ringbuf->buffsize-ringbuf->pr;
			memcpy(dest, ringbuf->buffer+ringbuf->pr, lenx);
			/* Read remaining from HEAD/END */
			memcpy(dest+lenx, ringbuf->buffer+0, len-lenx);
			/* Update pr */
			ringbuf->pr=len-lenx;
			/* Update datasize */
			ringbuf->datasize -=len;

			ret=len; goto END_FUNC;
		}
	}
	/* Case_3. Ringbuffer has NOT enough data: */
	else  { /* if( ringbuf->datasize<len ) */
		/* 3.1 pr is NOT necessary to cross the ring head/end */
		if( ringbuf->pr < ringbuf->pw ) {
			/* Read till to pw */
			lenx=ringbuf->pw-ringbuf->pr;
			memcpy(dest, ringbuf->buffer+ringbuf->pr, lenx);

			/* Update pr */
			ringbuf->pr = ringbuf->pw;
			/* update datasize */
			ringbuf->datasize -=lenx;

			ret=lenx; goto END_FUNC;
		}
		/* 3.2 pr is to cross the ring head/end */
		else {  /* pr > pw */
			/* Write till to END/HEAD */
			lenx=ringbuf->buffsize-ringbuf->pr;
			memcpy(dest, ringbuf->buffer+ringbuf->pr, lenx);
			/* Write remaining from HEAD/END to pw */
			memcpy(dest, ringbuf->buffer+0, ringbuf->pw);

			/* Update pr */
			ringbuf->pr = ringbuf->pw;
			/* update datasize */
			ringbuf->datasize -=(lenx+ringbuf->pw);

			ret=lenx+ringbuf->pw; goto END_FUNC;
		}
	}

END_FUNC:
/* ------- <<<  Critical Zone  */
        /* put mutex lock */
        pthread_mutex_unlock(&ringbuf->ring_mutex);

	return ret;
}

 一个简单的测试程序:

test_ringbuff.c

/*------------------------------------------------------------------
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.


Midas Zhou
midaszhou@yahoo.com
https://github.com/widora/wegi
------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include "egi_ringbuffer.h"

int main(void)
{
	char data[100];
	int inBytes=100; /* 每次写入数据量 */
	int outBytes=50;  /* 每次读出数据量 */
	int ret;

	EGI_RINGBUFFER *ringbuff=NULL;
	ringbuff=egi_ringbuffer_create(4096);

   while(1) {

	/* Write into the ringbuffer */
	if( (ret=egi_ringbuffer_write(ringbuff, data, inBytes)) <inBytes ) {
		printf("Ringbuffer overrun... write %d of %d Bytes.\n", ret,inBytes);
		/* Adjust speed */
		inBytes=50;
		outBytes=100;
		sleep(1);
	}

	/* Read out from the ringbuffer */
	if( (ret=egi_ringbuffer_read(ringbuff, data, outBytes)) <outBytes ) {
		printf("Ringbuffer underrun... read %d of %d Bytes.\n", ret,outBytes);
		/* Adjust speed */
		inBytes=100;
		outBytes=50;
		sleep(1);
	}

	printf("Ringbuff datasize=%zu, pw=%jd, pr=%jd\n", ringbuff->datasize, ringbuff->pw, ringbuff->pr);
   }

	egi_ringbuffer_free(&ringbuff);
	return 0;
}

最后，把它装配到mini流播放器中应用起来.....OK

 

Midas-Zhou
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ringbuffer.rar
04-26
代码中包含了ringbuferr的所有接口函数，使用简单，直接上手，C语言编写。代码中包含了ringbuferr的所有接口函数，使用简单，直接上手，C语言编写。
Ring Buffers （环形消息缓冲区)
wangyx1234的博客
07-30 5095
Ring Buffers 基本结构 即环形缓冲区：添加环形缓冲区是为了提供一种可以接受任意长度条目的缓冲区形式。 （内存管理）是一种数据结构用于表示一个固定尺寸、头尾相连的缓冲区，适合缓存数据流。内部除维护一个环形缓冲区外，还有两个二值信号量，用于读写保护： 1.发送保护信号量：二值信号量，通知被阻塞发送的任务有更多可用空间或阻塞已经超时。 2.接收保护信号量，二值信号量，通知被阻塞接收的任务指示新的数据/项已写入环形缓冲区或者阻塞超时。 为什么需要Ring Buffers...
ringbuffer 工具函数源码及实例分享
cooklelyq的专栏
03-07 430
目录 1，什么是ringbuffer 2，什么情况下需要使用ringbuffer 3，工具函数API 源码 4，使用方法 4.1 第一步用户按照如下格式定义好数据结构，并初始化好内存空间 4.2数据存储API调用方法： 4.3数据读取API调用方法： 4.4 注意事项： 本文分享一个近期写的ring buffer的工具函数。 1，什么是ringbuffer ring buff...
RingBuffer环形缓冲区C语言
最新发布
刘看山是山的博客
03-14 532
项目未能实现线程安全，仅供学习参考，工程项目请谨慎使用！！！RingBuffer 是一个基于C语言开发的环形缓冲区，适用于各嵌入式平台的串口收发等应用场景；在基本功能的基础上还提供了一个分段记录框架，方便数据管理；代码在AT32F403A平台上编译运行，经过简单的串口收发测试后暂未发现显性BUG。
ring buffer简单原理及c代码实现
strengthen2324的博客
11-17 2311
环形存储（ring buffer）：一个头尾相连的buffer，根据head索引确定写入位置，根据tail索引确定读出位置，读写时head、tail索引各自递增，不够空间且有新数据要写入时，覆盖旧数据。 下图演示了创建/初始化长度12、写4bytes数据、读2bytes数据时，ring buffer的head、tail索引变化情况。 //因此使用ring buffer关键因素是数据缓冲区、数据缓冲区长度、head索引、tail索引 typedef struct { char *buff;
C++实现一个简单的RingBuffer
weixin_37871174的博客
03-17 1543
#include <iostream> #include <thread> #include <vector> #include <chrono> using namespace std; #define RING_BUFFER_SIZE 12 /*环形队列元素个数*/ /*环形队列*/ class RingBuffer{ public: ...
使用 Ring Buffer 完成数据传递
wangyx1234的博客
11-03 2118
1）Ring Buffer 提供了管理数据溢出的机制，当 Ring Buffer 的缓存区足够大时，数据写到缓冲区尾部后将自动从头部开始继续写。当 Ring Buffer 的缓冲区不够大时，即便存在数据溢出风险，但应用本身允许新数据覆盖旧数据的情况下使用 Ring Buffer 也非常合适。2）ESP-IDF 对 rIngbuf 的三种分类：No-Split buffers、Allow split buffers、Byte buffer。
简单的RingBuffer库
12-17
简单的RingBuffer库
ringbuffer.zip
12-08
环形缓冲区简单实例
RingBuffer的操作與简单應用
12-11
工作后的第二个Ｃ程序，还是挺好做的。ＲｉｎｇＢｕｆｆｅｒ，循环队列
stm32f103c8t6-usart-ringbuffer.rar
03-10
环形缓冲区是一种数据结构，它允许在缓冲区中存储和...以下是一个简单的指南，可以帮助初学者开始使用环形缓冲区，可以在这个链接中有更多的细节：https://blog.csdn.net/weixin_44317448/article/details/136607605
ring buffer示例
ldhshao的专栏
07-30 329
文章目录概述示例引用 概述 ring buffer,或者说循环队列，是嵌入式开发中的一个基本模型，常用于命令队列，资源循环分配场合。 示例 ring_buffer.h ring buffer 封装API testringbuffer.c 测试ring buffer api. //ring_buffer.h #include <stdlib.h> typedef struct s_ring_buffer{ int tail; int head; int size; int item_si
乐鑫代码中Ring Buffers (环形缓冲区)说明
zhou_2018的博客
08-26 4953
本文翻译自乐鑫文档，详见链接地址，结合用例自行测试，欢迎交流。 Ring Buffers(环形缓冲区) ESP-IDF FreeRTOS环形缓冲区是严格的FIFO缓冲区，支持任意大小的项目。在项目大小可变的情况下，环形缓冲区是FreeRTOS队列的一种内存效率更高的替代方法。环形缓冲区的容量不是由它可以存储的项目数来衡量的，而是由用于存储项目的内存量来衡量的。您可以在环形缓冲区上申请一块内存来发送项目，或者只是使用API​​复制数据并发送（根据您调用的send API）。出于效率原因，总是通过引.
RingBuffer源代码分析
weixin_33924770的博客
09-13 510
看到一篇写的非常详细的帖子，为防止楼主删帖后找不到，果断转载过来 RingBuffer源代码分析 出处： http://bbs.ickey.cn/community/forum.php?mod=viewthread&amp;tid=43202(出处: ICKEY BBS) 大家都知道，环形缓冲区是比较常用的数据结构，正好机智云“微信宠物屋源代码v2.3”中也用到了。 下面给大家分析一下。 ...
一文解决ethtool 原理介绍和解决网卡丢包排查思路
youzhangjing_的博客
04-01 1661
（如有 ring buffer 的网卡，好像 frame 可以先存在 ring buffer 里再触发软件中断（下篇文章将详细解释 Linux 中 frame 的走向），ring buffer 是网卡和驱动程序共享，是设备里的内存，但是对操作系统是可见的，因为看到 linux 内核源码里网卡驱动程序是使用 kcalloc 来分配的空间，所以 ring buffer 一般都有上限，另外这个 ring buffer size，表示的应该是能存储的 frame 的个数，而不是字节大小。
环形缓冲区(ring buffer)，环形队列(ring queue) 原理
热门推荐
code09的专栏
02-28 2万+
1. 序言 环形缓冲区(ring buffer)，环形队列(ring queue) 多用于2个线程之间传递数据，是标准的先入先出(FIFO)模型。 一般来说，对于多线程共享数据，需要使用mutex来同步，这样共享数据才不至于发生不可预测的修改/读取，然而， mutex的使用也带来了额外的系统开销，ring buffer/queue 的引入，就是为了有效地解决这个问题，因其特殊的结构 及算法
c印记（八）： ring buffer实现
xuanwolanxue的专栏
01-16 2533
一、写在前面的话 之所以自己要自己实现一个ring buffer，和前面的ini file解析的原因差不多，都是在深度定制轮子。 我从事是多媒体播放或者录影方面工作，且是在嵌入式平台或移动端上运行，内存，cpu运行主频等资源都相对受限，所以模组之间的数据交互，就不能简单重复的使用malloc/free的方式，这样会产生内存碎片，而且有的模组(比如硬件解码或编码)的输入输出的buffer都需要物...
Disruptor源码（一）RingBuffer底层结构 & 构建过程
乌鲁木齐001号程序员
04-05 495
RingBuffer源码核心 底层用数组Object[] entries存储元素，不会扩容，满了之后从数组头开始填充，所谓环形数组； 内存预加载，在RingBuffer初始化的时候，就用空Event对象填充entries，初始化后不再新建Event对象 ，消除了不断new对象带来的开销，只对entries中的Event对象做update操作； Ring...
环形缓冲队列(RingBuffer),自己写的靠谱的代码
CSSEIKOCS的专栏
03-03 7288
kfifo ringbuffer
怎样写ring buffer
04-01
下面是一个简单的ring buffer的实现： ```c #include #include #define BUFFER_SIZE 10 typedef struct { int *buffer; int head; int tail; int size; } RingBuffer; RingBuffer *createRingBuffer(int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Midas-Zhou

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值