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

#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 头文件保护符

#ifndef _ringbuffer_h
#define _ringbuffer_h
...
#endif

作用：防止头文件被多次包含，避免重复定义错误。

1.2 包含必要的标准库

#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 类型定义

typedef struct ringbuffer_s buffer_t;

作用：为 struct ringbuffer_s 定义一个别名 buffer_t，简化后续代码的书写。

2. 环形缓冲区结构体

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. 辅助宏与内联函数

#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` 宏

#define min(lth, rth) ((lth)<(rth)?(lth):(rth))

作用：返回两个值中的较小者，简化代码中的条件判断。

3.2 `is_power_of_two` 内联函数

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` 内联函数

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 创建新缓冲区

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 获取缓冲区长度

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 释放缓冲区

void buffer_free(buffer_t *r) {
    free(r);
    r = NULL;
}

功能：释放之前分配的缓冲区内存。
注意：设置指针为 NULL 只是为了防止悬挂指针，但在函数外部无效。

4.4 添加数据到缓冲区

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 从缓冲区移除数据

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 清空缓冲区的一部分数据

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 在缓冲区中搜索特定字符串

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 获取写入缓冲区的可写指针

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 判断缓冲区是否为空

static uint32_t
rb_isempty(buffer_t *r) {
    return r->head == r->tail;
}

功能：检查缓冲区是否为空。
返回值：1 表示为空，0 表示不为空。

5.2 判断缓冲区是否已满

static uint32_t
rb_isfull(buffer_t *r) {
    return r->size == (r->tail - r->head);
}

功能：检查缓冲区是否已满。
返回值：1 表示已满，0 表示未满。

5.3 获取缓冲区中剩余的空间

static uint32_t
rb_remain(buffer_t *r) {
    return r->size - r->tail + r->head;
}

功能：计算缓冲区中剩余的可用空间。
返回值：剩余空间的字节数。

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

6.1 环形地址计算

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

(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博客

原文地址：https://blog.csdn.net/weixin_43925427/article/details/142358862

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

00898 互联网软件应用与开发自考复习题
1. 创建两个文件selectContent.jsp和writeFile.jsp，首先使用selectContent.jsp中的表单输入存放路径、保存的文件名和将要写入文件的文件内容信息，提交后，由w
阅读更多2024-09-20
web基础—dvwa靶场（九）Weak Session IDs
在网络应用中，“Session” 称为“会话控制”，Session 对象存储特定用户会话所需的属性及配置信息。用户在应用程序的 Web 页面之间跳转时，存储在 Session 对象中的变量将不会丢失。
阅读更多2024-09-20
Vue.js 的 Mixins
Mixins 是一个普通的 JavaScript 对象，可以包含任何组件选项。// 定义一个名为 myMixin 的 mixin},methods: {hello() {');Vue Mixins 是
阅读更多2024-09-20
Compose Multiplatform+kotlin Multiplatfrom第三弹
上篇文章很多通用业务功能，这篇续着发布队列文件断点下载保存到本地。urlsavePathjob${GlobalCodeGlobalCodetaskurlGlobalCodetaskurlisCopyt
阅读更多2024-09-20
go多线程
【代码】go多线程。
阅读更多2024-09-20
Golang | Leetcode Golang题解之第412题Fizz Buzz
Golang | Leetcode Golang题解之第412题Fizz Buzz
阅读更多2024-09-20
C语言内存函数
这里我们引入数组的概念来理解我们会发现，当destsrc的时候是从后往前遍历的，根据这个我们就可以来编写程序了。像这种情况我们不难发现不管是从前往后遍历或者是从后往前遍历都是可以的，但是为了方便我们
阅读更多2024-09-20
leetcode 165.比较版本号
【代码】leetcode 165.比较版本号。
阅读更多2024-09-20
54.【C语言】字符函数和字符串函数(strncpy,strncat,strncmp函数)
和strcpy,strcat,strcmp函数对应的是strncpy,strncat,strncmp函数。
阅读更多2024-09-20
android10 系统定制：增加应用使用数据埋点，应用使用时长统计
null）时，判断新的包名与旧的是否相同，如果不同说明进行了应用切换，记录退出了上个应用和进入了新的应用。根据上面的数据记录可以看出：2024-08-12 09:52:54进入了设置，09:52:57
阅读更多2024-09-20