用户态缓存：链式缓冲区（Chain Buffer）

目次
链式缓冲区（Chain Buffer）简介
为什么选择链式缓冲区？
代码分析
1. 头文件与范例界说
2. 布局体界说
3. 宏界说与常量
4. 环形缓冲区的根本操纵
5. 其他辅助函数
6. 数据读写操纵的详细实现
7. 总结
8. 团结之前的内容
9. 详细应用分析
10. 综合应用
11. 总结

---

链式缓冲区（Chain Buffer）简介

链式缓冲区是一种通过链接多个缓冲区块来动态管理数据的布局。相比于固定巨细的环形缓冲区，链式缓冲区具有更高的机动性和可扩展性，特殊实用于须要处置惩罚差别巨细数据包的场景。它通过将数据分散存储在多个缓冲区块中，镌汰了内存浪费和数据移动的需求。
为什么选择链式缓冲区？

  

• 机动性和可扩展性：链式缓冲区可以或许动态地添加或移除缓冲区块，顺应差别的数据量需求。  
  
• 镌汰数据移动：通太过散存储数据，克制了大规模的数据拷贝操纵，进步了数据处置惩罚服从。  
  
• 高效内存利用：根据实际数据量动态分配缓冲区块，镌汰了内存浪费。
  

代码分析

让我们渐渐分析你提供的链式缓冲区代码，明白其各个部分的功能和实现细节。
1. 头文件与范例界说

1. #ifndef _chain_buffer_h
2. #define _chain_buffer_h
3. #include <stdint.h>
5. typedef struct buf_chain_s buf_chain_t;
6. typedef struct buffer_s buffer_t;
8. // Function declarations
9. buffer_t * buffer_new(uint32_t sz);
10. uint32_t buffer_len(buffer_t *buf);
11. int buffer_add(buffer_t *buf, const void *data, uint32_t datlen);
12. int buffer_remove(buffer_t *buf, void *data, uint32_t datlen);
13. int buffer_drain(buffer_t *buf, uint32_t len);
14. void buffer_free(buffer_t *buf);
15. int buffer_search(buffer_t *buf, const char* sep, const int seplen);
16. uint8_t * buffer_write_atmost(buffer_t *p);
18. #endif

复制代码

1.1 头文件掩护符

1. #ifndef _chain_buffer_h
2. #define _chain_buffer_h
3. ...
4. #endif

复制代码

  

• 作用：防止头文件被多次包罗，克制重复界说错误。
  

1.2 范例界说

1. typedef struct buf_chain_s buf_chain_t;
2. typedef struct buffer_s buffer_t;

复制代码

  

• 作用：为布局体 buf_chain_s 和 buffer_s 界说别名 buf_chain_t 和 buffer_t，简化后续代码的誊写。
  

2. 布局体界说

1. struct buf_chain_s {
2.     struct buf_chain_s *next;
3.     uint32_t buffer_len;
4.     uint32_t misalign;
5.     uint32_t off;
6.     uint8_t *buffer;
7. };
9. struct buffer_s {
10.     buf_chain_t *first;
11.     buf_chain_t *last;
12.     buf_chain_t **last_with_datap;
13.     uint32_t total_len;
14.     uint32_t last_read_pos; // for sep read
15. };

复制代码

2.1 buf_chain_s 布局体

  

• next (struct buf_chain_s *)：指向下一个缓冲区块，实现链式布局。  
  
• buffer_len (uint32_t)：缓冲区块的总巨细，以字节为单元。  
  
• misalign (uint32_t)：缓冲区块的未对齐偏移量，用于优化内存访问。  
  
• off (uint32_t)：当前缓冲区块中有用数据的长度，以字节为单元。  
  
• buffer (uint8_t *)：指向实际数据存储区的指针。
  

2.2 buffer_s 布局体

  

• first (buf_chain_t *)：链表的第一个缓冲区块。  
  
• last (buf_chain_t *)：链表的末了一个缓冲区块。  
  
• last_with_datap (buf_chain_t **)：指向链表中末了一个有数据的缓冲区块的指针的指针，用于快速定位添加新数据的位置。  
  
• total_len (uint32_t)：缓冲区中当前存储的总数据量，以字节为单元。  
  
• last_read_pos (uint32_t)：用于分隔符读取的前次读取位置，优化搜刮性能。
  

3. 宏界说与常量

1. #define CHAIN_SPACE_LEN(ch) ((ch)->buffer_len - ((ch)->misalign + (ch)->off))
2. #define MIN_BUFFER_SIZE 1024
3. #define MAX_TO_COPY_IN_EXPAND 4096
4. #define BUFFER_CHAIN_MAX_AUTO_SIZE 4096
5. #define MAX_TO_REALIGN_IN_EXPAND 2048
6. #define BUFFER_CHAIN_MAX 16*1024*1024  // 16M
7. #define BUFFER_CHAIN_EXTRA(t, c) (t *)((buf_chain_t *)(c) + 1)
8. #define BUFFER_CHAIN_SIZE sizeof(buf_chain_t)

复制代码

  

• CHAIN_SPACE_LEN(ch)：盘算缓冲区块 ch 中剩余的可用空间。  
  
• MIN_BUFFER_SIZE：缓冲区块的最小巨细，设置为1024字节。  
  
• MAX_TO_COPY_IN_EXPAND：扩展缓冲区时最多复制的字节数。  
  
• BUFFER_CHAIN_MAX_AUTO_SIZE：主动扩展缓冲区块的最大巨细。  
  
• MAX_TO_REALIGN_IN_EXPAND：扩展时最大允许重新对齐的字节数。  
  
• BUFFER_CHAIN_MAX：缓冲区块的最大巨细，设置为16MB。  
  
• BUFFER_CHAIN_EXTRA(t, c)：宏，用于获取缓冲区块中的实际数据存储区的指针。  
  
• BUFFER_CHAIN_SIZE：缓冲区块布局体的巨细。
  

4. 环形缓冲区的根本操纵

4.1 创建缓冲区

1. buffer_t * buffer_new(uint32_t sz) {
2.     (void)sz;
3.     buffer_t * buf = (buffer_t *) malloc(sizeof(buffer_t));
4.     if (!buf) {
5.         return NULL;
6.     }
7.     memset(buf, 0, sizeof(*buf));
8.     buf->last_with_datap = &buf->first;
9.     return buf;
10. }

复制代码

  

• 功能：创建并初始化一个新的链式缓冲区。  
  
• 步调：
     
  
  • 分配内存，初始化布局体 buffer_t。   
    
  • 利用 memset 清零布局体成员。   
    
  • 初始化 last_with_datap 指针为指向 first，体现当前没有数据存储。   
    
  • 返回缓冲区指针。   
    
  
  

留意：固然函数吸收一个巨细参数 sz，但在当前实现中未利用（通过 (void)sz; 忽略）。这是由于链式缓冲区通过动态添加缓冲区块来顺应差别的数据量需求，而不依靠于单一的固定巨细。
4.2 获取缓冲区长度

1. uint32_t buffer_len(buffer_t *buf) {
2.     return buf->total_len;
3. }

复制代码

  

• 功能：返回缓冲区中当前存储的数据长度。  
  
• 实现：直接返回 total_len。
  

4.3 开释缓冲区

1. void buffer_free(buffer_t *buf) {
2.     buf_chain_free_all(buf->first);
3. }

复制代码

  

• 功能：开释链式缓冲区中的全部缓冲区块，并开释缓冲区布局体本身。  
  
• 步调：
     
  
  • 调用 buf_chain_free_all 开释全部缓冲区块。   
    
  • 留意：当前实现未开释 buffer_t 本身的内存，大概须要在调用者中举行开释。   
    
  
  

4.4 添加数据到缓冲区

1. int buffer_add(buffer_t *buf, const void *data_in, uint32_t datlen) {
2.     buf_chain_t *chain, *tmp;
3.     const uint8_t *data = data_in;
4.     uint32_t remain, to_alloc;
5.     int result = -1;
6.     if (datlen > BUFFER_CHAIN_MAX - buf->total_len) {
7.         goto done;
8.     }
10.     if (*buf->last_with_datap == NULL) {
11.         chain = buf->last;
12.     } else {
13.         chain = *buf->last_with_datap;
14.     }
16.     if (chain == NULL) {
17.         chain = buf_chain_insert_new(buf, datlen);
18.         if (!chain)
19.             goto done;
20.     }
22.     remain = chain->buffer_len - chain->misalign - chain->off;
23.     if (remain >= datlen) {
24.         memcpy(chain->buffer + chain->misalign + chain->off, data, datlen);
25.         chain->off += datlen;
26.         buf->total_len += datlen;
27.         // buf->n_add_for_cb += datlen;
28.         goto out;
29.     } else if (buf_chain_should_realign(chain, datlen)) {
30.         buf_chain_align(chain);
32.         memcpy(chain->buffer + chain->off, data, datlen);
33.         chain->off += datlen;
34.         buf->total_len += datlen;
35.         // buf->n_add_for_cb += datlen;
36.         goto out;
37.     }
38.     to_alloc = chain->buffer_len;
39.     if (to_alloc <= BUFFER_CHAIN_MAX_AUTO_SIZE/2)
40.         to_alloc <<= 1;
41.     if (datlen > to_alloc)
42.         to_alloc = datlen;
43.     tmp = buf_chain_new(to_alloc);
44.     if (tmp == NULL)
45.         goto done;
46.     if (remain) {
47.         memcpy(chain->buffer + chain->misalign + chain->off, data, remain);
48.         chain->off += remain;
49.         buf->total_len += remain;
50.         // buf->n_add_for_cb += remain;
51.     }
53.     data += remain;
54.     datlen -= remain;
56.     memcpy(tmp->buffer, data, datlen);
57.     tmp->off = datlen;
58.     buf_chain_insert(buf, tmp);
59.     // buf->n_add_for_cb += datlen;
60. out:
61.     result = 0;
62. done:
63.     return result;
64. }

复制代码

  

• 功能：将数据添加到链式缓冲区中。  
  
• 步调：
     
  
  • 查抄缓冲区是否已满：
    
          
    
    • 假如要添加的数据 datlen 凌驾缓冲区的最大允许长度（BUFFER_CHAIN_MAX），则返回错误 -1。     
      
       
    
  • 定位当前可用的缓冲区块：
    
          
    
    • 假如 last_with_datap 指向 NULL，