用户态缓存：环形缓冲区（Ring Buffer）

TravisBytes2024-09-26 21:05

目录

[环形缓冲区（Ring Buffer）简介](#环形缓冲区（Ring Buffer）简介)

为什么选择环形缓冲区？

代码解析

[1. 头文件与类型定义](#1. 头文件与类型定义)

[1.1 头文件保护符](#1.1 头文件保护符)

[1.2 包含必要的标准库](#1.2 包含必要的标准库)

[1.3 类型定义](#1.3 类型定义)

[2. 环形缓冲区结构体](#2. 环形缓冲区结构体)

[2.1 结构体成员解释](#2.1 结构体成员解释)

[3. 辅助宏与内联函数](#3. 辅助宏与内联函数)

[3.1 min 宏](#3.1 min 宏)

[3.2 is_power_of_two 内联函数](#3.2 is_power_of_two 内联函数)

[3.3 roundup_power_of_two 内联函数](#3.3 roundup_power_of_two 内联函数)

[4. 环形缓冲区的基本操作](#4. 环形缓冲区的基本操作)

[4.1 创建新缓冲区](#4.1 创建新缓冲区)

[4.2 获取缓冲区长度](#4.2 获取缓冲区长度)

[4.3 释放缓冲区](#4.3 释放缓冲区)

[4.4 添加数据到缓冲区](#4.4 添加数据到缓冲区)

[4.5 从缓冲区移除数据](#4.5 从缓冲区移除数据)

[4.6 清空缓冲区的一部分数据](#4.6 清空缓冲区的一部分数据)

[4.7 在缓冲区中搜索特定字符串](#4.7 在缓冲区中搜索特定字符串)

[4.8 获取写入缓冲区的可写指针](#4.8 获取写入缓冲区的可写指针)

[5. 其他辅助函数](#5. 其他辅助函数)

[5.1 判断缓冲区是否为空](#5.1 判断缓冲区是否为空)

[5.2 判断缓冲区是否已满](#5.2 判断缓冲区是否已满)

[5.3 获取缓冲区中剩余的空间](#5.3 获取缓冲区中剩余的空间)

[6. 代码中的关键概念与实现](#6. 代码中的关键概念与实现)

[6.1 环形地址计算](#6.1 环形地址计算)

[6.2 缓冲区大小为2的幂次方](#6.2 缓冲区大小为2的幂次方)

[6.3 双指针机制](#6.3 双指针机制)

[7. 综合应用](#7. 综合应用)

[7.1 在用户态缓存区中的应用](#7.1 在用户态缓存区中的应用)

[7.2 处理生产者与消费者速度不匹配](#7.2 处理生产者与消费者速度不匹配)

[7.3 结合之前的内容](#7.3 结合之前的内容)

[8. 总结](#8. 总结)

环形缓冲区（Ring Buffer）简介

环形缓冲区是一种高效的数据结构，广泛应用于生产者-消费者模型中。在网络通信中，尤其是用户态缓存区中，环形缓冲区通过循环使用固定大小的内存区域，减少数据移动和内存管理开销，提升数据传输效率。

为什么选择环形缓冲区？

  • 减少数据移动：数据在缓冲区中循环写入和读取，避免了频繁的数据拷贝操作。
  • 高效缓存管理：适用于高并发场景，能够快速响应数据的读写请求。
  • 简化内存管理：固定大小的缓冲区结构简化了内存分配和释放。

代码解析

让我们逐步解析环形缓冲区代码，理解其各个部分的功能和实现细节。

1. 头文件与类型定义

cpp 复制代码 
#ifndef _ringbuffer_h
#define _ringbuffer_h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <limits.h>  // for uint_max
#include <stdint.h>
#include <unistd.h>

typedef struct ringbuffer_s buffer_t;

buffer_t * buffer_new(uint32_t sz);

uint32_t buffer_len(buffer_t *r);

void buffer_free(buffer_t *r);

int buffer_add(buffer_t *r, const void *data, uint32_t sz);

int buffer_remove(buffer_t *r, void *data, uint32_t sz);

int buffer_drain(buffer_t *r, uint32_t sz);

int buffer_search(buffer_t *r, const char* sep, const int seplen);

uint8_t * buffer_write_atmost(buffer_t *r);

#endif
1.1 头文件保护符
cpp 复制代码 
#ifndef _ringbuffer_h
#define _ringbuffer_h
...
#endif
  • 作用：防止头文件被多次包含，避免重复定义错误。
1.2 包含必要的标准库
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <limits.h>  // for uint_max
#include <stdint.h>
#include <unistd.h>
  • 标准库 ：提供了内存管理（malloc、free）、字符串操作（memcpy）、固定宽度整数类型（uint32_t、uint8_t）等功能。
1.3 类型定义
cpp 复制代码 
typedef struct ringbuffer_s buffer_t;
  • 作用 ：为 struct ringbuffer_s 定义一个别名 buffer_t，简化后续代码的书写。

2. 环形缓冲区结构体

cpp 复制代码 
struct ringbuffer_s {
    uint32_t size;
    uint32_t tail;
    uint32_t head;
    uint8_t * buf;
};
2.1 结构体成员解释

  • size (uint32_t)：缓冲区的总大小，以字节为单位。通常为2的幂次方，便于使用位运算实现环形效果。

  • tail (uint32_t)：指向缓冲区的写入位置。每次添加数据时，tail 会递增。

  • head (uint32_t)：指向缓冲区的读取位置。每次移除数据时，head 会递增。

  • buf (uint8_t *)：指向实际数据存储区的指针。数据以字节形式存储。

3. 辅助宏与内联函数

cpp 复制代码 
#define min(lth, rth) ((lth)<(rth)?(lth):(rth))

static inline int is_power_of_two(uint32_t num) {
    if (num < 2) return 0;
    return (num & (num - 1)) == 0;
}

static inline uint32_t roundup_power_of_two(uint32_t num) {
    if (num == 0) return 2;
    int i = 0;
    for (; num != 0; i++)
        num >>= 1;
    return 1U << i;
}
3.1 min 宏
cpp 复制代码 
#define min(lth, rth) ((lth)<(rth)?(lth):(rth))
  • 作用：返回两个值中的较小者，简化代码中的条件判断。
3.2 is_power_of_two 内联函数
cpp 复制代码 
static inline int is_power_of_two(uint32_t num) {
    if (num < 2) return 0;
    return (num & (num - 1)) == 0;
}
  • 作用：判断一个数是否为2的幂次方。
  • 原理：2的幂次方数在二进制中只有一个1，其减1后所有位都会变为1，按位与结果为0。
3.3 roundup_power_of_two 内联函数
cpp 复制代码 
static inline uint32_t roundup_power_of_two(uint32_t num) {
    if (num == 0) return 2;
    int i = 0;
    for (; num != 0; i++)
        num >>= 1;
    return 1U << i;
}
  • 作用：将一个数向上舍入到最近的2的幂次方。
  • 实现：通过不断右移操作，计算出需要的位数，然后使用位移生成对应的2的幂次方数。

4. 环形缓冲区的基本操作

4.1 创建新缓冲区
cpp 复制代码 
buffer_t * buffer_new(uint32_t sz) {
    if (!is_power_of_two(sz)) sz = roundup_power_of_two(sz);
    buffer_t * buf = (buffer_t *)malloc(sizeof(buffer_t) + sz);
    if (!buf) {
        return NULL;
    }
    buf->size = sz;
    buf->head = buf->tail = 0;
    buf->buf = (uint8_t *)(buf + 1);
    return buf;
}
  • 功能：分配并初始化一个新的环形缓冲区。
  • 步骤 ：
    1. 检查传入的大小 sz 是否为2的幂次方。如果不是，则向上舍入到最近的2的幂次方数。
    2. 分配内存：sizeof(buffer_t) + sz。buffer_t结构体和实际数据存储区 buf 一起分配。
    3. 初始化结构体成员：
      • size ：设置为调整后的大小 sz。
      • head 和 tail：初始化为0，表示缓冲区为空。
      • buf：指向结构体之后的内存区域，即实际的数据存储区。
4.2 获取缓冲区长度
cpp 复制代码 
uint32_t buffer_len(buffer_t *r) {
    return rb_len(r);
}

static uint32_t
rb_len(buffer_t *r) {
    return r->tail - r->head;
}
  • 功能：返回缓冲区中当前存储的数据长度。
  • 实现 ：通过 tail - head 计算当前缓冲区中有效数据的字节数。
4.3 释放缓冲区
cpp 复制代码 
void buffer_free(buffer_t *r) {
    free(r);
    r = NULL;
}
  • 功能：释放之前分配的缓冲区内存。
  • 注意 ：设置指针为 NULL 只是为了防止悬挂指针，但在函数外部无效。
4.4 添加数据到缓冲区
cpp 复制代码 
int buffer_add(buffer_t *r, const void *data, uint32_t sz) {
    if (sz > rb_remain(r)) {
        return -1;
    }
    uint32_t i;
    i = min(sz, r->size - (r->tail & (r->size - 1)));

    memcpy(r->buf + (r->tail & (r->size - 1)), data, i);
    memcpy(r->buf, data+i, sz-i);

    r->tail += sz;
    return 0;
}

static uint32_t
rb_remain(buffer_t *r) {
    return r->size - r->tail + r->head;
}
  • 功能：将数据添加到缓冲区中。
  • 步骤 ：
    1. 检查剩余空间 ：
      • 使用 rb_remain(r) 计算缓冲区中剩余的可用空间。
      • 如果要添加的数据大小 sz 超过剩余空间，返回错误 -1。
    2. 计算可写入的字节数 i ：
      • 使用 min(sz, r->size - (r->tail & (r->size - 1))) 计算可以连续写入的最大字节数，避免跨越缓冲区末尾。
    3. 数据拷贝 ：
      • 第一部分 ：将前 i 字节的数据拷贝到缓冲区当前位置。
      • 第二部分 ：如果有剩余的数据（sz - i），将其从缓冲区的起始位置开始拷贝，形成环形。
    4. 更新 tail ：将 tail 指针增加 sz，标记新数据的结束位置。
    5. 返回成功 ：返回 0 表示数据添加成功。
4.5 从缓冲区移除数据
cpp 复制代码 
int buffer_remove(buffer_t *r, void *data, uint32_t sz) {
    assert(!rb_isempty(r));
    uint32_t i;
    sz = min(sz, r->tail - r->head);

    i = min(sz, r->size - (r->head & (r->size - 1)));
    memcpy(data, r->buf+(r->head & (r->size - 1)), i);
    memcpy(data+i, r->buf, sz-i);

    r->head += sz;
    return sz;
}

static uint32_t
rb_isempty(buffer_t *r) {
    return r->head == r->tail;
}
  • 功能：从缓冲区中移除并读取数据。
  • 步骤 ：
    1. 断言缓冲区不为空 ：使用 assert(!rb_isempty(r)) 确保缓冲区中有数据可读。
    2. 调整读取大小 ：将 sz 限制为缓冲区中实际存储的数据量 r->tail - r->head。
    3. 计算可连续读取的字节数 i ：
      • 使用 min(sz, r->size - (r->head & (r->size - 1))) 计算可以连续读取的最大字节数，避免跨越缓冲区末尾。
    4. 数据拷贝 ：
      • 第一部分 ：将前 i 字节的数据从缓冲区当前位置拷贝到目标缓冲区。
      • 第二部分 ：如果有剩余的数据（sz - i），将其从缓冲区的起始位置开始拷贝。
    5. 更新 head ：将 head 指针增加 sz，标记数据的读取位置。
    6. 返回读取的字节数 ：返回实际读取的数据大小 sz。
4.6 清空缓冲区的一部分数据
cpp 复制代码 
int buffer_drain(buffer_t *r, uint32_t sz) {
    if (sz > rb_len(r))
        sz = rb_len(r);
    r->head += sz;
    return sz;
}
  • 功能 ：从缓冲区中清除 sz 字节的数据，而不读取到用户空间。
  • 步骤 ：
    1. 调整清除大小 ：将 sz 限制为缓冲区中实际存储的数据量 rb_len(r)。
    2. 更新 head ：将 head 指针增加 sz，标记数据的清除位置。
    3. 返回清除的字节数 ：返回实际清除的数据大小 sz。
4.7 在缓冲区中搜索特定字符串
cpp 复制代码 
int buffer_search(buffer_t *r, const char* sep, const int seplen) {
    int i;
    for (i = 0; i <= rb_len(r)-seplen; i++) {
        int pos = (r->head + i) & (r->size - 1);
        if (pos + seplen > r->size) {
            if (memcmp(r->buf+pos, sep, r->size-pos))
                return 0;
            if (memcmp(r->buf, sep+r->size-pos, pos+seplen-r->size) == 0) {
                return i+seplen;
            }
        }
        if (memcmp(r->buf+pos, sep, seplen) == 0) {
            return i+seplen;
        }
    }
    return 0;
}
  • 功能 ：在缓冲区中搜索特定的分隔符 sep，用于界定数据包的边界（如协议解析）。
  • 步骤 ：
    1. 遍历缓冲区 ：从 head 开始，逐个字节检查是否匹配 sep。
    2. 计算当前检查的位置 pos ：使用 (r->head + i) & (r->size - 1) 实现环形地址计算。
    3. 处理跨越缓冲区末尾的情况 ：
      • 如果 pos + seplen > r->size，表示分隔符跨越缓冲区末尾，需要分两部分比较。
      • 第一部分 ：比较从 pos 到缓冲区末尾的部分。
      • 第二部分：比较从缓冲区起始位置到剩余长度的部分。
    4. 匹配成功 ：如果找到匹配的分隔符，返回分隔符的位置（偏移量 i + seplen）。
    5. 未找到匹配 ：返回 0，表示未找到。
4.8 获取写入缓冲区的可写指针
cpp 复制代码 
uint8_t * buffer_write_atmost(buffer_t *r) {
    uint32_t rpos = r->head & (r->size - 1);
    uint32_t wpos = r->tail & (r->size - 1);
    if (wpos < rpos) {
        uint8_t* temp = (uint8_t *)malloc(r->size * sizeof(uint8_t));
        memcpy(temp, r->buf+rpos, r->size - rpos);
        memcpy(temp+r->size-rpos, r->buf, wpos);
        free(r->buf);
        r->buf = temp;
        return r->buf;
    }
    return r->buf + rpos;
}
  • 功能：获取当前缓冲区中可写入数据的位置指针，最多可写入的字节数。
  • 步骤 ：
    1. 计算读取和写入位置 ：
      • rpos ：head 指针在缓冲区中的当前位置。
      • wpos ：tail 指针在缓冲区中的当前位置。
    2. 判断是否需要重新排列缓冲区 ：
      • 如果 wpos < rpos，表示写入位置已环绕到缓冲区的起始位置，需要将数据重新排列，使得写入位置连续。
      • 重新排列 ：
        • 分配新的缓冲区 temp，大小与原缓冲区相同。
        • 将从 rpos 到缓冲区末尾的数据复制到 temp 的起始位置。
        • 将从缓冲区起始位置到 wpos 的数据复制到 temp 的剩余位置。
        • 释放原缓冲区内存，并将 buf 指针指向新的缓冲区 temp。
        • 返回新的缓冲区起始位置。
    3. 直接返回写入位置 ：
      • 如果不需要重新排列，直接返回 buf + rpos，即当前可写入的位置。

5. 其他辅助函数

5.1 判断缓冲区是否为空
cpp 复制代码 
static uint32_t
rb_isempty(buffer_t *r) {
    return r->head == r->tail;
}
  • 功能：检查缓冲区是否为空。
  • 返回值 ：1 表示为空，0 表示不为空。
5.2 判断缓冲区是否已满
cpp 复制代码 
static uint32_t
rb_isfull(buffer_t *r) {
    return r->size == (r->tail - r->head);
}
  • 功能：检查缓冲区是否已满。
  • 返回值 ：1 表示已满，0 表示未满。
5.3 获取缓冲区中剩余的空间
cpp 复制代码 
static uint32_t
rb_remain(buffer_t *r) {
    return r->size - r->tail + r->head;
}
  • 功能：计算缓冲区中剩余的可用空间。
  • 返回值：剩余空间的字节数。

6. 代码中的关键概念与实现

6.1 环形地址计算

在环形缓冲区中，head 和 tail 指针是以字节为单位递增的。当指针超过缓冲区的大小时，通过位运算（& (r->size - 1)）将其映射回缓冲区的起始位置，实现环形效果。

cpp 复制代码 
(r->tail & (r->size - 1))
  • 条件 ：r->size 通常为2的幂次方，这样 (r->size - 1) 就是一个全1的二进制数，可以用来快速计算模运算。
6.2 缓冲区大小为2的幂次方

为了简化环形地址的计算，缓冲区的大小通常设置为2的幂次方。这不仅提高了效率，还使得位运算成为可能，从而加快了数据的读写操作。

6.3 双指针机制
  • head：指向下一个读取位置。
  • tail：指向下一个写入位置。
  • 优势：通过维护两个指针，可以高效地管理生产者（写入）和消费者（读取）之间的数据流动，避免数据冲突和竞争条件。

7. 综合应用

7.1 在用户态缓存区中的应用

在用户态缓存区中，环形缓冲区用于存储和管理网络数据的读写操作。生产者（如内核协议栈）将数据添加到缓冲区，消费者（如应用程序）从缓冲区读取数据。通过环形缓冲区的高效管理，确保数据传输的流畅性和可靠性。

7.2 处理生产者与消费者速度不匹配

当生产者（如内核协议栈）生成数据的速度快于消费者（应用程序）的处理速度时，缓冲区可以暂存这些数据，避免数据丢失。同样，当消费者处理数据的速度快于生产者生成数据的速度时，缓冲区也能有效地管理数据流动，确保数据的连续性。

7.3 结合之前的内容

用户态缓存：高效数据交互与性能优化https://blog.csdn.net/weixin_43925427/article/details/142354725?fromshare=blogdetail&sharetype=blogdetail&sharerId=142354725&sharerefer=PC&sharesource=weixin_43925427&sharefrom=from_link在之前的讲解中，我们提到了读写缓存区在网络通信中的重要性，以及不同的缓冲区设计（固定内存块、环形缓冲区、链式缓冲区）对性能和效率的影响。环形缓冲区通过减少数据移动和优化内存管理，提升了数据传输的效率和系统的整体性能。

8. 总结

通过详细解析这段环形缓冲区的代码，我们深入理解了环形缓冲区的结构和工作原理：

  • 高效的数据管理：通过固定大小的缓冲区和双指针机制，环形缓冲区实现了高效的数据读写操作。
  • 减少数据移动：利用环形地址计算和分段拷贝，避免了大量的数据拷贝和移动操作，提升了性能。
  • 灵活的空间管理 ：通过动态调整和优化（如 buffer_write_atmost 函数），环形缓冲区能够适应不同的数据量需求，保持高效运行。
  • 可靠的数据传输：在生产者和消费者速度不匹配的情况下，环形缓冲区通过暂存和管理数据，确保数据的完整性和可靠性。

参考：

0voice · GitHub

GitHub - TryTryTL/buffer_design

用户态缓存：高效数据交互与性能优化-CSDN博客

相关推荐
奶糖趣多多2 分钟前
Redis知识点
数据库·redis·缓存
CoderIsArt1 小时前
Redis的三种模式：主从模式，哨兵与集群模式
数据库·redis·缓存
励志成为嵌入式工程师3 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
Peter_chq4 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
hikktn5 小时前
如何在 Rust 中实现内存安全：与 C/C++ 的对比分析
c语言·安全·rust
观音山保我别报错5 小时前
C语言扫雷小游戏
c语言·开发语言·算法
ketil275 小时前
Redis - String 字符串
数据库·redis·缓存
小林熬夜学编程8 小时前
【Linux系统编程】第四十一弹---线程深度解析：从地址空间到多线程实践
linux·c语言·开发语言·c++·算法
生命几十年3万天8 小时前
redis时间优化
数据库·redis·缓存
墨墨祺8 小时前
嵌入式之C语言（基础篇）
c语言·开发语言
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play