一个简单的RingBuffer

最新推荐文章于 2024-09-02 21:08:21 发布
最新推荐文章于 2024-09-02 21:08:21 发布
阅读量676 收藏
点赞数 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
关注
专栏目录
ring buffer简单原理及c代码实现
strengthen2324的博客
11-17 2565
环形存储（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 1600
#include <iostream> #include <thread> #include <vector> #include <chrono> using namespace std; #define RING_BUFFER_SIZE 12 /*环形队列元素个数*/ /*环形队列*/ class RingBuffer{ public: ...
环形缓冲区(ring buffer)原理与实现详解
最新发布
2401_86353562的博客
09-02 1953
ring buffer称作环形缓冲区，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。如下为环形缓冲区（ring buffer） 的概念示意图。在任务间的通信、串口数据收发、log缓存、网卡处理网络数据包、音频/视频流处理中均有环形缓冲区（ring buffer） 的应用。
网卡的 Ring Buffer 详解
关注微信公众号【开源Linux】，后台回复『10T』，领取10T学习资源大放送，涵盖Linux、虚拟化、容器、云计算、网络、Python、Go等书籍和视频
02-28 1845
来源：yangyidba1. 网卡处理数据包流程网卡处理网络数据流程图：图片来自参考链接1上图中虚线步骤的解释：1 DMA 将 NIC 接收的数据包逐个写入 sk_buff ，一个数据包可能占用多个 sk_buff , sk_buff 读写顺序遵循FIFO（先入先出）原则。2 DMA 读完数据之后，NIC 会通过 NIC Interrupt Handler 触发 IRQ （中断请求）。3 NIC ...
linux网卡收包源码,Linux 网络协议栈收消息过程-Ring Buffer
weixin_39860201的博客
05-03 381
想看能不能完整梳理一下收消息过程。从 NIC 收数据开始，到触发软中断，交付数据包到 IP 层再经由路由机制到 TCP 层，最终交付用户进程。会尽力介绍收消息过程中的各种配置信息，以及各种监控数据。知道了收消息的完整过程，了解了各种配置，明白了各种监控数据后才有可能在今后的工作中做优化配置。所有参考内容会列在这个系列最后一篇文章中。Ring Buffer 相关的收消息过程大致如下： 图片来自参考1...
linux 内核 进入ring0,Linux内核跟踪之ring buffer的实现
weixin_27256197的博客
04-29 437
ring buffer用struct ring_buffer来表示,数据结构定义如下:struct ring_buffer {/*RB中的页面数*/unsigned pages;/*RB的标志,目前只有RB_FL_OVERWRITE可用*/unsigned flags;/*ring buffer中包含的cpu个数*/int cpu...
Rt-thead studio软件下使用ringbuffer
04-21
- 在RTOS中，RingBuffer常用于任务间通信、设备驱动层的数据缓存等场景，因为它的读写操作快速且同步简单。 2. **RT-Thread中的RingBuffer实现** - RT-Thread提供了标准的RingBuffer接口，包括`rt_ringbuf_create...
ringbuffer.zip
12-08
- `RingBuffer* ringbuffer_init(size_t size)`: 初始化环形缓冲区，分配指定大小的内存并返回一个指向`RingBuffer`结构体的指针。 - `void ringbuffer_destroy(RingBuffer* rb)`: 释放环形缓冲区占用的内存。 - ...
简单的RingBuffer库
12-17
RingBuffer库是一个在嵌入式系统，特别是STM32微控制器平台上常见的数据结构实现，用于高效地处理数据缓冲。在嵌入式编程中，尤其是在实时操作系统（RTOS）中， RingBuffer（环形缓冲区）是一种非常实用的数据管理...
ringbuffer java例子_使用Ring Buffer构建高性能的文件写入程序
weixin_39725403的博客
02-13 556
最近常收到SOD框架的朋友报告的SOD的SQL日志功能报错：文件句柄丢失。经过分析得知，这些朋友使用SOD框架开发了访问量比较大的系统，由于忘记关闭SQL日志功能所以出现了很高频率的日志写入操作，从而偶然引起错误。后来我建议只记录出错的或者执行时间较长的SQL信息，暂时解决了此问题。但是作为一个热心造轮子的人，一定要看看能不能造一个更好的轮子出来。前面说的错误原因已经很直白了，就是频繁的日志写入导...
ringbuffer
嵌入式与人工智能
12-01 637
ringbuffer有很多种实现方法，一个一个整理出来 ByteBuffer.h #ifndef _RING_BUFFER_H #define _RING_BUFFER_H #include <stdint.h> /* * Circular buffer of bytes. */ class ByteBuffer { public: ByteBuffer(uint32_t size); ~ByteBuffer(void); // number of bytes
ring buffer示例
ldhshao的专栏
07-30 365
文章目录概述示例引用 概述 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
【socket】网卡内部缓冲区、socket缓冲区、滑动窗口
数字人生
10-27 1767
网卡内部缓冲区、socket缓冲区、滑动窗口 三者的关系
一个优秀的 ring buffer 或 cycle buffer 的实现代码
dielucui7698的博客
05-18 116
#define CIRCLE_BUFFSIZE 1024 * 1024#define min(x, y) ((x) < (y) ? (x) : (y))struct cycle_buffer { unsigned char *buf; unsigned int size; unsigned int in; unsigned...
乐鑫代码中Ring Buffers (环形缓冲区)说明
zhou_2018的博客
08-26 5833
本文翻译自乐鑫文档，详见链接地址，结合用例自行测试，欢迎交流。 Ring Buffers(环形缓冲区) ESP-IDF FreeRTOS环形缓冲区是严格的FIFO缓冲区，支持任意大小的项目。在项目大小可变的情况下，环形缓冲区是FreeRTOS队列的一种内存效率更高的替代方法。环形缓冲区的容量不是由它可以存储的项目数来衡量的，而是由用于存储项目的内存量来衡量的。您可以在环形缓冲区上申请一块内存来发送项目，或者只是使用API​​复制数据并发送（根据您调用的send API）。出于效率原因，总是通过引.
一个环形缓冲(ringbuf)的简单实现
鱼思故渊的专栏
01-16 6940
代码中有相关注释： // mybuf.h #ifndef _RINGBUF_HEADER_ #define _RINGBUF_HEADER_ #ifdef _cplusplus extern "C"{ #endif /************* 1 === succeed 0 === failed *************/ typedef struct _ringbuf_
Ring Buffers （环形消息缓冲区)
wangyx1234的博客
07-30 5683
Ring Buffers 基本结构 即环形缓冲区：添加环形缓冲区是为了提供一种可以接受任意长度条目的缓冲区形式。 （内存管理）是一种数据结构用于表示一个固定尺寸、头尾相连的缓冲区，适合缓存数据流。内部除维护一个环形缓冲区外，还有两个二值信号量，用于读写保护： 1.发送保护信号量：二值信号量，通知被阻塞发送的任务有更多可用空间或阻塞已经超时。 2.接收保护信号量，二值信号量，通知被阻塞接收的任务指示新的数据/项已写入环形缓冲区或者阻塞超时。 为什么需要Ring Buffers...
ring buffer C语言实现
ggmjxry的专栏
05-20 778
ring buffer的一个实现
使用 Ring Buffer 完成数据传递
wangyx1234的博客
11-03 2531
1）Ring Buffer 提供了管理数据溢出的机制，当 Ring Buffer 的缓存区足够大时，数据写到缓冲区尾部后将自动从头部开始继续写。当 Ring Buffer 的缓冲区不够大时，即便存在数据溢出风险，但应用本身允许新数据覆盖旧数据的情况下使用 Ring Buffer 也非常合适。2）ESP-IDF 对 rIngbuf 的三种分类：No-Split buffers、Allow split buffers、Byte buffer。
使用C语言实现一个ringbuffer
05-20
下面是一个使用C语言实现的简单的ring buffer。 ``` #include #define BUFFER_SIZE 10 typedef struct { int buffer[BUFFER_SIZE]; int head; int tail; } ring_buffer_t; void ring_buffer_init(ring_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Midas-Zhou

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

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

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

打赏作者

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

抵扣说明：

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

余额充值