基于c 实现 FIFO

已于 2023-12-19 19:40:27 修改
阅读量755 收藏 14
点赞数 8
分类专栏： 编程实践 文章标签： 开发语言
于 2023-12-04 10:23:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/poject/article/details/115276212
版权

功能：

1、读和写长度不限制

2、数据操作 和 指针操作分开（如先操作数据，再操作指针）
     注意：直接操作指针的情况下，注意越界问题，要每次拷贝进入FIFO的数据大小要是FIFO大小的整数分之一
                例子：
                fifo size 是32K 每次读或者写的数据是1K，不会越界

                 如果每次操作3K，则操作导接近FIFO末尾的时候，容易越界
                 如果要解决3K操作问题，不要操作指针， 直接调用 fifo_read fifo_write操作即可

               

适用场景：

单向通信模式，一方写、一方读，可用于任务间单向通信（无需锁）
如：

1、音频各个处理流程间，缓冲数据

2、线程间、进程间，cpu间，基于共享内存的大数据量传递，缓冲数据

头文件：

/*
 * Time       : 2023/12/XX
 * Author     :
 */
#ifndef __ZFIFO_H__
#define __ZFIFO_H__

// #include "stdint.h"
#include "stdio.h"
#include "stdlib.h"

// #define min(a, b) (((a) < (b)) ? (a) : (b))

/* FIFO数据的类型，可以是结构体类型 */
typedef unsigned char u8;
typedef unsigned int u32;

/* 读写偏移计数最大值1取 2*size 长度，解决取 size 大小时，当 w r 重叠时，无法区分满 或者空的问题 */
typedef struct
{
    u32 w;    /* 写偏移计数 */
    u32 r;    /* 读偏移计数 */
    u32 size; /* FIFO数据区大小 */
    u8 *data; /* FIFO数据区指针 */
} fifo_t;

/*
 ****************************************************************
 * 函数功能：FIFO初始化（动态分配内存）
 *
 * *参数 size：fifo数据区字节数
 * *返回值 创建成功：返回创建fifo指针
 *         创建失败：返回创建空指针
 *
 ****************************************************************
 */
fifo_t *fifo_init(u32 size);

/*
 ****************************************************************
 * 函数功能：FIFO内存释放（和动态分配内存初始化配合使用）
 *
 * *参数 f：fifo指针
 * *返回值 0
 *
 ****************************************************************
 */
u32 fifo_deinit(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：FIFO初始化（只初始化）
 *
 * *参数 f：fifo指针
 * *参数 buf：fifo数据区
 * *参数 size：fifo数据区字节数
 * *返回值 0
 *
 ****************************************************************
 */
void fifo_init_ext(fifo_t *f, void *buf, u32 size);

/*
 ****************************************************************
 * 函数功能：FIFO重置
 *
 * *参数 f：fifo指针
 * *返回值 0
 *
 ****************************************************************
 */
u32 fifo_reset(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：获取fifo数据区已使用空间大小
 *
 * *参数 f：fifo指针
 * *返回值 fifo数据区已使用字节数
 *
 ****************************************************************
 */
u32 fifo_getUsed(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：获取fifo数据区空余空间大小
 *
 * *参数 f：fifo指针
 * *返回值 fifo数据区空余字节数
 *
 ****************************************************************
 */
u32 fifo_getFree(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：获取读指针位置
 *
 * *参数 f：fifo指针
 * *返回值 读指针位置
 *
 ****************************************************************
 */
u8 *fifo_getReadPtr(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：获取写指针位置
 *
 * *参数 f：fifo指针
 * *返回值 写指针位置
 *
 ****************************************************************
 */
u8 *fifo_getWritePtr(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：FIFO是否满
 *
 * *参数 f：fifo指针
 * *返回值 1-满 0-未满
 *
 ****************************************************************
 */
u32 fifo_isFull(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：FIFO是否为空
 *
 * *参数 f：fifo指针
 * *返回值 1-空 0-未空
 *
 ****************************************************************
 */
u32 fifo_isEmpty(fifo_t *f);

/*
 ****************************************************************
 * 函数功能：FIFO读数据（不更新读指针）
 *
 * *参数 f：fifo指针
 * *参数 buf：数据缓冲区
 * *参数 len：数据长度
 * *返回值 实际读数据长度
 *        *注意 fifo剩余数据 < len 情况
 *
 ****************************************************************
 */
u32 fifo_readOnlyData(fifo_t *f, u8 *buf, u32 len);

/*
 ****************************************************************
 * 函数功能：更新FIFO读指针（不读数据）
 *
 * *参数 f：fifo指针
 * *参数 len：数据长度
 * *返回值 实际读出数据长度
 *        *注意 fifo剩余数据 < len 情况
 * *注意 整体逻辑同读数据保持一致
 *
 ****************************************************************
 */
u32 fifo_readOnlyPtr(fifo_t *f, u32 len);

/*
 ****************************************************************
 * 函数功能：从FIFO读数据、并更新读指针
 *
 * *参数 f：fifo指针
 * *参数 buf：数据缓冲区
 * *参数 len：数据长度
 * *返回值 实际读出数据长度
 *        *注意 fifo剩余数据 < len 情况
 * *注意 基于 fifo_readOnlyData fifo_readOnlyPtr 实现
 *
 ****************************************************************
 */
u32 fifo_read(fifo_t *f, u8 *buf, u32 len);

/*
 ****************************************************************
 * 函数功能：FIFO写数据（不更新写指针）
 *
 * *参数 f：fifo指针
 * *参数 buf：数据缓冲区
 * *参数 len：数据长度
 * *返回值 实际写数据长度
 *        *注意 fifo剩余数据 < len 情况
 *
 ****************************************************************
 */
u32 fifo_writeOnlyData(fifo_t *f, u8 *buf, u32 len);

/*
 ****************************************************************
 * 函数功能：更新FIFO写指针（不写数据）
 *
 * *参数 f：fifo指针
 * *参数 len：数据长度
 * *返回值 实际写数据长度
 *        *注意 fifo剩余数据 < len 情况
 * *注意 整体逻辑同写数据保持一致
 *
 ****************************************************************
 */
u32 fifo_writeOnlyPtr(fifo_t *f, u32 len);

/*
 ****************************************************************
 * 函数功能：FIFO写数据、并更新写指针
 *
 * *参数 f：fifo指针
 * *参数 buf：数据缓冲区
 * *参数 len：数据长度
 * *返回值 实际写数据长度
 *        *注意 fifo剩余数据 < len 情况
 * *注意 基于 fifo_writeOnlyData fifo_writeOnlyPtr 实现
 *
 ****************************************************************
 */
u32 fifo_write(fifo_t *f, u8 *buf, u32 len);

#endif /* __ZFIFO_H__ */

.c 函数实现：

/*
 * Time       : 2023/12/XX
 * Author     :
 */

#include "fifo.h"
#include "string.h"

/*
 * init
 *
 */
fifo_t *fifo_init(u32 size)
{
    fifo_t *f = (fifo_t *)malloc(sizeof(fifo_t));
    if (NULL == f)
        return NULL;

    f->data = (u8 *)malloc(sizeof(u8) * size);
    if (NULL == f->data)
    {
        free(f);
        return NULL;
    }

    f->w = 0;
    f->r = 0;
    f->size = size;

    return f;
}

void fifo_init_ext(fifo_t *f, void *buf, u32 size)
{
    f->w = 0;
    f->r = 0;
    f->size = size;
    f->data = buf;

    return f;
}

u32 fifo_deinit(fifo_t *f)
{
    if (NULL != f->data)
    {
        free(f->data);
        f->data = NULL;
    }

    if (NULL != f)
    {
        free(f->data);
        // f = NULL;
    }

    return 0;
}

u32 fifo_reset(fifo_t *f)
{
    f->w = 0;
    f->r = 0;

    return 0;
}

u32 fifo_getUsed(fifo_t *f)
{
#if 0
	u32 len;

	if (f->w >= f->r)
	{
		len = f->w - f->r;
	}
	else
	{
		len = (f->size << 1) - f->r + f->w;
	}

	return len;
#else
    if (f->w >= f->r)
    {
        return (f->w - f->r);
    }

    return ((f->size << 1) - f->r + f->w);
#endif
}

u32 fifo_getFree(fifo_t *f)
{
#if 0
	u32 len;

	if (f->w >= f->r)
	{
		len = f->size - f->w + f->r;
	}
	else
	{
		len = f->r - f->w - f->size;
	}

	return len;
#else
    if (f->w >= f->r)
    {
        return (f->size - f->w + f->r);
    }

    return (f->r - f->w - f->size);
#endif
}

u8 *fifo_getReadPtr(fifo_t *f)
{
    return (f->data + (f->r % f->size));
}

u8 *fifo_getWritePtr(fifo_t *f)
{
    return (f->data + (f->w % f->size));
}

u32 fifo_isFull(fifo_t *f)
{
    if (0 == fifo_getFree(f))
        return 1;

    return 0;
}

u32 fifo_isEmpty(fifo_t *f)
{
    if (0 == fifo_getUsed(f))
        return 1;

    return 0;
}

u32 fifo_readOnlyData(fifo_t *f, u8 *buf, u32 len)
{
    // copy len, first copy len
    u32 cl, fcl;

    // 剩余空间 与 待读数据取小
    cl = fifo_getUsed(f);
    if (cl > len) cl = len;

    // 第一次读
    fcl = f->size - (f->r % f->size);
    if (fcl > cl) fcl = cl;

    memcpy(buf, f->data + (f->r % f->size), fcl);

    // 第二次读，跨buf尾的时候，从buf头开始读剩余部分
    if (fcl < cl)
        memcpy(buf + fcl, f->data, cl - fcl);

    return cl;
}

u32 fifo_readOnlyPtr(fifo_t *f, u32 len)
{
    // copy len
    u32 cl = fifo_getUsed(f);
    if (cl > len) cl = len;

    // 计算偏移地址
    f->r = (f->r + cl) % (f->size << 1);

    return cl;
}

u32 fifo_read(fifo_t *f, u8 *buf, u32 len)
{
    u32 ret = 0;

    ret = fifo_readOnlyData(f, buf, len);
    ret |= fifo_readOnlyPtr(f, len);

    return ret;
}

u32 fifo_writeOnlyData(fifo_t *f, u8 *buf, u32 len)
{
    // copy len, first copy len
    u32 cl, fcl;

    // 剩余空间 与 写数据 取小
    cl = fifo_getFree(f);
    if (cl > len) cl = len;

    // 第一次写
    fcl = f->size - (f->w % f->size);
    if (fcl >= cl) fcl = cl;

    memcpy(f->data + (f->w % f->size), buf, fcl);

    // 第二次：buf头开始写剩余部分
    if (fcl < cl)
        memcpy(f->data, buf + fcl, cl - fcl);

    return cl;
}

// 计算逻辑通写数据保持一致
u32 fifo_writeOnlyPtr(fifo_t *f, u32 len)
{
    // copy len
    u32 cl = fifo_getFree(f);
    if (cl > len) cl = len;

    // 计算偏移地址
    f->w = (f->w + cl) % (f->size << 1);

    return cl;
}

u32 fifo_write(fifo_t *f, u8 *buf, u32 len)
{
    u32 ret = 0;

    ret = fifo_writeOnlyData(f, buf, len);
    ret |= fifo_writeOnlyPtr(f, len);

    return ret;
}

测试程序：


#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
#include <unistd.h>  
#include <fcntl.h>  
#include "fifo.h"
  
#define FIFO_READ_SIZE  32
#define FIFO_WRITE_SIZE 19
#define FIFO_BUF_SIZE   32

fifo_t* g_fifo;
int  g_exit = 0;

// 读文件线程函数  
void* read_file(void* arg) {  
    int fd = *(int*)arg;  
    char buffer[FIFO_WRITE_SIZE + 1];  
    ssize_t bytes_read;  
  
    while(1)
    {
        if(fifo_getFree(g_fifo) >= FIFO_WRITE_SIZE)
        {
            if ((bytes_read = read(fd, buffer, FIFO_WRITE_SIZE)) > 0) {  
                if(bytes_read != fifo_write(g_fifo, buffer, bytes_read))
                {
                    printf("write fifo error\n");
                }
                // if(bytes_read != FIFO_WRITE_SIZE)
                //     printf("\n ## len = %d\n", (int)bytes_read);
            }
            else
            {
                printf("write fifo finish\n");
                g_exit = 1;
                break;
            }
        }
        else
        {
            usleep(2000);
        }
    }
  
    return NULL;  
}  
  
// 写文件线程函数  
void* write_file(void* arg) {  
    int fd = *(int*)arg;  
    char buffer[FIFO_READ_SIZE + 1];  
    ssize_t bytes_written;
    int fifo_size = 0;

    while(1)
    {
        fifo_size = fifo_getUsed(g_fifo);
        if(fifo_size >= FIFO_READ_SIZE)
        {
            if (FIFO_READ_SIZE != fifo_read(g_fifo, buffer, FIFO_READ_SIZE))
            {
                printf("read fifo error\n");
            }
            else
            {
                write(fd, buffer, FIFO_READ_SIZE);
            }

        }
        else if(fifo_size >= 0)
        {
            if (fifo_size != fifo_read(g_fifo, buffer, fifo_size))
            {
                printf("read fifo error\n");
            }
            else
            {
                write(fd, buffer, fifo_size);
            }
        }
        else
        {
            usleep(2000);
        }

        if(fifo_isEmpty(g_fifo) && g_exit) 
        {
            printf("read fifo finish\n");
            break;
        }
    }
    return NULL;  
}  
  
int main() {  
    pthread_t read_thread, write_thread;  
    int fd_in, fd_out;

    g_fifo = fifo_init((u32)FIFO_BUF_SIZE); 

    // 打开输入文件和输出文件  
    fd_in = open("input.txt", O_RDONLY);  
    fd_out = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);  
  
    // 创建读文件线程和写文件线程  
    pthread_create(&read_thread, NULL, read_file, &fd_in);  
    pthread_create(&write_thread, NULL, write_file, &fd_out);  
  
    // 等待两个线程执行完毕  
    pthread_join(read_thread, NULL);  
    pthread_join(write_thread, NULL);  
  
    // 关闭文件描述符  
    close(fd_in);  
    close(fd_out);  

    fifo_deinit(g_fifo);
  
    return 0;  
}

poject
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C语言的FIFO和LRU算法
06-15
基于C语言的FIFO和LRU算法的实现。
用c语言实现队列(FIFO)
热门推荐
EmSoftEn的专栏
08-05 1万+
循环队列是通过数组实现的一种队列 #include #define QUEUESIZE 100 //定义数组大小 typedef int DataType; //定义数组元素类型 typedef struct { int count; //当前队列中元素的个数 int front; //队列中第一个元素的索引 int tail; //队列中最后一个元素的下一个位置的索引 }C
C语言实现一个简易的环形FIFO
stephenbruce的博客
02-12 425
设计一个环形FIFO缓冲区，用于存储原始数据。环形FIFO缓冲区最大有10个节点，每个节点有200个原始数据，即200个unsigned int类型的数据。其中，包括写FIFO函数，读FIFO函数，删除某节点函数，删除整个FIFO函数等。
【数据结构】循环队列(C语言实现）
Hello_World_213的博客
05-17 8975
史上最详细的循环队列讲解！不怕你不会，就怕你不点进来！
C语言实现循环缓冲fifo及总结
weixin_42648229的博客
10-16 1926
**循环缓冲fifo是先进先出的。生产者和消费者都只有一个，linux系统下使用提供了一种免锁的机制，处理时不用加锁。**UART下收发fifo主要是解决收发中断过于频繁，会导致CPU效率不高。 ...
FIFO队列 C语言实现
dssd111的博客
04-29 665
参考了 https://blog.csdn.net/weixin_30407613/article/details/97446678 添加了读取队列状态函数，并将读取队列状态与对队列的实际操作分离，需要先判断队列是否可操作，然后再对其进行操作，原函数是直接进行操作，然后返回的操作结果。 修改了主函数，对其进行了测试。 Queue.c #include "Queue.h" /*******************************************************************
用C语言实现FIFO (简单版
小马哔哔
06-10 6441
#include <stdio.h> #include <windows.h> #define fifo_max 110 //分配给fifo的空间,设置为2的n次幂可以快速求余 int fifo_top; //队顶指针 int fifo_bot; //队底指针 int fifo_size;//队长度 char fifo_buff[1000];//缓冲区 /** * @brief 初始化FIFO * @retval 无 */ void fifo_init(){
利用FPGA实现异步FIFO设计
01-19
FPGA内部具有丰富的存储单元，易于实现各种存储器(如FIFO、双口RAM等)；另外，基于查找表的逻辑单元可用于实现各种数字信号处理(如滤波等)，以辅助DSP处理器做各种预处理。 　TI公司推出的高性能数字信号处理芯片...
xqueue：基于C语言实现的循环队列缓冲区
04-09
xqueue：基于C语言实现的循环队列缓冲区 https://blog.csdn.net/whik1194/article/details/130047136
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现...
循环队列(C语言实现）
03-02
循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 # 优点 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一...
c语言：几种方法构建FIFO用于can和usart数据缓冲
花有重开日，人无再少年
01-18 394
c语言：几种方法构建FIFO用于can和usart数据缓冲
C语言数据结构之FIFO
风清云淡 的专栏
04-16 2417
FIFO(First in First out),插入在表的一端进行，而删除在表的另一端进行，我们将这种数据结构称为队或者队列（就像排队一样，排在前面的先出，很形象） 允许插入的一端称为队尾（rear）,允许删除的一端称为（front） 通常我们用得较多的是循环队列 也就是当rear达到fifo的最大值后又指向下标为0的位置。 这里会存在一个问题：正常是根据front==rear判...
c语言链表和fifo,FIFO 行列的链表和数组实现
weixin_35645652的博客
05-24 306
FIFO 队列的链表和数组实现FIFO (First-in, First-out，先进先出)队列：当执行delete操作时删除那些呆在队列中时间最长的元素。FIFO 队列是这样一个ADT，包含两个基本操作：插入(put)一个新的项、删除(get)一个最早插入的项。一、FIFO队列的链表实现FIFO 队列和下堆栈的区别在于新项的插入是在尾部，而不是在头部。因此实现程序要保存一个指向链表最后一个节点的...
《前端面试题》- TypeScript - TypeScript的优/缺点
小张微说的博客
04-22 1722
问题 简述TypeScript的优/缺点 答案 优点 增强了代码的可读性和可维护性 包容性，js可以直接改成ts，ts编译报错也可以生成js文件，兼容第三方库，即使不是ts编写的 社区活跃，完全支持es6 缺点 增加学习成本 增加开发成本，因为增加了类型定义 需要编译，类型检查会增加编译时长，语法和类型系统复杂的话时间特别特别长 eval和new Function()这种操作类型系统管不到 ...
node-v9.6.0-x86.msi
04-29
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python基于机器学习的分布式系统故障诊断系统源代码，分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别
04-29
基于技术手段（包括但不限于机器学习、深度学习等技术）对分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别，实现分布式系统故障运维的智能化，快速恢复故障的同时大大降低分布式系统运维工作的难度，减少运维对人力资源的消耗。在分布式系统中某个节点发生故障时，故障会沿着分布式系统的拓扑结构进行传播，造成自身节点及其邻接节点相关的KPI指标和发生大量日志异常
JavaScript前端开发的核心语言前端开发的核心语言
最新发布
04-29
javascript 当今互联网时代，JavaScript已经成为了前端开发的核心语言它是一种高级程序设计语言，通常用于网页的交互和动态效果的实现。JavaScript的灵活性以及广泛的使用使得它变得异常重要，能够为用户带来更好的用户体验。 JavaScript的特点之一是它的轻量级，它可以在网页中运行无需单独的编译或下载。这意味着网页可以更快地加载并且用户无需安装额外的软件才能运行网页上的JavaScript代码。此外，与HTML和CSS紧密结合，可以直接在HTML文档中嵌入，使得网页的开发变得非常便捷。 JavaScript具有动态性，它可以在浏览器中实时修改页面内容和样。它可以通过操作DOM（文档对象模型来动态地修改网页的结构和布局，并且可以根据用户的行为实时地响应各种事件，如点击、标悬停、滚动等。这使得开发者可以轻松地为网页添加交互性和动态效果，提供更好的用户体验。 JavaScript也是一种面向对象的语言。它支持对象、类、继承、多态等面向对象编程的概念，使得代码结构更加清晰和可维护。开发者可以创建自定义的对象和方法，对功能进行封装和复用，提高代码的可读性和可维护性。
四则运算自动生成程序安装包
04-29
四则运算自动生成程序安装包
如何c语言实现FIFO，LRU，CLOCK，OPT替换页算法，并对代码做出解释
05-25
下面是C语言实现FIFO算法的代码： ```c #include #include #define MAXSIZE 3 // 模拟内存中的页面数 #define PAGESIZE 10 // 每个页面的大小 typedef struct { int page_num; // 页面号 int visit_time; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值