理解用户态缓冲区：定长缓冲区、链式缓冲区和环形缓冲区

已于 2024-05-17 00:32:45 修改
阅读量966 收藏 6
点赞数 20
文章标签： 开发语言 c语言 c++ 后端 链表
于 2024-05-17 00:23:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45634782/article/details/138979968
版权

1. 引言

概述

在网络编程中，用户态缓冲区（User-space Buffer）是提升数据传输性能的重要组件。本文将深入探讨三种常见的缓冲区实现方式：定长缓冲区、链式缓冲区和环形缓冲区。通过实际代码示例和详细讲解，我们将帮助读者理解如何设计和使用这些缓冲区。

2. 用户态缓冲区的意义

介绍

用户态缓冲区是指在用户空间（User Space）中维护的缓冲区，用于临时存储数据以便高效地进行读写操作。与内核缓冲区相比，用户态缓冲区可以减少系统调用次数，提升性能。

作用
  • 提高性能：减少系统调用次数，降低上下文切换开销。
  • 流量控制：缓冲区可用于控制数据传输速率，避免网络拥塞。
  • 数据管理：便于数据的缓存和预处理（如加密、压缩）。

3. 定长缓冲区

定义

定长缓冲区是指大小固定的缓冲区，在创建时分配固定大小的内存。

优点
  • 简单高效：结构简单，读写速度快。
  • 易于管理：无需动态分配和释放内存。
缺点
  • 不灵活：无法动态扩展，容易导致内存浪费或溢出。
  • 适应性差：对数据大小变化敏感，不适合大数据量或高并发场景。
示例代码
#define BUFFER_LENGTH 512

struct conn_item {
    int fd;
    char rbuffer[BUFFER_LENGTH];
    int rlen;
    char wbuffer[BUFFER_LENGTH];
    int wlen;
    RCALLBACK recv_callback;
    RCALLBACK send_callback;
};

// 初始化缓冲区
void init_conn_item(struct conn_item *item, int fd, RCALLBACK recv_cb, RCALLBACK send_cb) {
    item->fd = fd;
    item->rlen = 0;
    item->wlen = 0;
    item->recv_callback = recv_cb;
    item->send_callback = send_cb;
}

// 示例使用
struct conn_item conn;
init_conn_item(&conn, clientfd, recv_cb, send_cb);
代码解释

上述代码定义了一个定长缓冲区结构体 conn_item，用于存储连接的相关信息。

  • fd：文件描述符，标识连接。
  • rbuffer 和 wbuffer：分别是接收缓冲区和发送缓冲区，大小固定为 BUFFER_LENGTH。
  • rlen 和 wlen：分别是接收缓冲区和发送缓冲区中数据的长度。
  • recv_callback 和 send_callback：分别是接收和发送操作的回调函数。

init_conn_item 函数用于初始化 conn_item 结构体，设置文件描述符和回调函数，并将缓冲区的长度初始化为 0。

4. 链式缓冲区（Chain Buffer）

定义

链式缓冲区由一系列链表节点组成，每个节点包含一块数据缓冲区。链式缓冲区可以根据需要动态地增加或减少节点。

优点
  • 灵活性高：可以动态扩展，适应数据量变化。
  • 避免内存浪费：根据需要分配内存，不会预先占用大量空间。
缺点
  • 管理复杂：需要维护链表结构，增加管理开销。
  • 读写性能稍差：由于链表的指针操作，读写速度可能稍慢。
示例代码
buffers.h
#ifndef BUFFERS_H
#define BUFFERS_H

#include <stdlib.h>
#include <pthread.h>

typedef struct BufferNode {
    char *data;
    size_t data_size;
    size_t data_used;
    struct BufferNode *next;
} BufferNode;

typedef struct {
    BufferNode *head;
    BufferNode *tail;
    size_t total_size;
    size_t node_size;
    pthread_mutex_t lock;
} ChainBuffer;

ChainBuffer* create_chain_buffer(size_t node_size);
void destroy_chain_buffer(ChainBuffer *cb);
int write_to_chain_buffer(ChainBuffer *cb, const char *data, size_t len);
int read_from_chain_buffer(ChainBuffer *cb, char *buffer, size_t len);

#endif // BUFFERS_H
代码解释

在 buffers.h 中，我们定义了链式缓冲区的数据结构和函数声明。

  • BufferNode：链表节点结构，包含数据缓冲区 data、缓冲区大小 data_size、已使用大小 data_used 和指向下一个节点的指针 next。
  • ChainBuffer：链式缓冲区结构，包含链表的头指针 head、尾指针 tail、总大小 total_size、节点大小 node_size 和用于线程安全的互斥锁 lock。
buffer.c
#include "buffers.h"
#include <string.h>

ChainBuffer* create_chain_buffer(size_t node_size) {
    ChainBuffer *cb = (ChainBuffer*) malloc(sizeof(ChainBuffer));
    cb->head = cb->tail = NULL;
    cb->total_size = 0;
    cb->node_size = node_size;
    pthread_mutex_init(&cb->lock, NULL);
    return cb;
}

void destroy_chain_buffer(ChainBuffer *cb) {
    BufferNode *current = cb->head;
    while (current != NULL) {
        BufferNode *next = current->next;
        free(current->data);
        free(current);
        current = next;
    }
    pthread_mutex_destroy(&cb->lock);
    free(cb);
}

BufferNode* allocate_node(size_t node_size) {
    BufferNode *node = (BufferNode*) malloc(sizeof(BufferNode));
    node->data = (char*) malloc(node_size);
    node->data_size = node_size;
    node->data_used = 0;
    node->next = NULL;
    return node;
}

int write_to_chain_buffer(ChainBuffer *cb, const char *data, size_t len) {
    pthread_mutex_lock(&cb->lock);

    while (len > 0) {
        if (cb->tail == NULL || cb->tail->data_used == cb->tail->data_size) {
            BufferNode *new_node = allocate_node(cb->node_size);
            if (cb->tail != NULL) {
                cb->tail->next = new_node;
            } else {
                cb->head = new_node;
            }
            cb->tail = new_node;
            cb->total_size += cb->node_size;
        }

        size_t space_available = cb->tail->data_size - cb->tail->data_used;
        size_t to_write = (len < space_available) ? len : space_available;

        memcpy(cb->tail->data + cb->tail->data_used, data, to_write);
        cb->tail->data_used += to_write;

        data += to_write;
        len -= to_write;
    }

    pthread_mutex_unlock(&cb->lock);
    return 0;
}

int read_from_chain_buffer(ChainBuffer *cb, char *buffer, size_t len) {
    pthread_mutex_lock(&cb->lock);

    if (cb->head == NULL) {
        pthread_mutex_unlock(&cb->lock);
        return -1; // 缓冲区为空
    }

    size_t total_read = 0;
    while (len > 0 && cb->head != NULL) {
        size_t to_read = (len < cb->head->data_used) ? len : cb->head->data_used;

        memcpy(buffer, cb->head->data, to_read);
        memmove(cb->head->data, cb->head->data + to_read, cb->head->data_used - to_read);
        cb->head->data_used -= to_read;

        buffer += to_read;
        len -= to_read;
        total_read += to_read;

        if (cb->head->data_used == 0) {
            BufferNode *old_head = cb->head;
            cb->head = cb->head->next;
            if (cb->head == NULL) {
                cb->tail = NULL;
            }
            free(old_head->data);
            free(old_head);
        }
    }

    pthread_mutex_unlock(&cb->lock);
    return total_read;
}
代码解释

在 buffer.c 中，我们实现了链式缓冲区的操作函数。

  • create_chain_buffer：初始化链式缓冲区结构，设置节点大小，并初始化互斥锁。
  • destroy_chain_buffer：销毁链式缓冲区，释放所有节点的内存，并销毁互斥锁。
  • allocate_node：分配一个新的链表节点，分配数据缓冲区的内存，并初始化节点结构。
  • write_to_chain_buffer：

向链式缓冲区写入数据。首先加锁，然后检查尾节点是否有足够的空间。如果没有空间，则分配一个新的节点并连接到链表中。然后，将数据写入尾节点，更新节点的已用大小，直到所有数据都写入完成。最后解锁。

  • read_from_chain_buffer：从链式缓冲区读取数据。首先加锁，然后检查头节点是否有数据。如果有数据，则读取数据并更新头节点的已用大小。如果头节点的数据已全部读取，则释放头节点的内存并移动到下一个节点。最后解锁。

5. 环形缓冲区（Ring Buffer）

定义

环形缓冲区是一个固定大小的数组，使用头指针和尾指针来管理读写位置。它是一个循环的数据结构，适合高效的读写操作。

优点
  • 高效读写：固定大小的数组，内存访问连续，读写速度快。
  • 内存使用稳定：使用固定大小的内存，不需要动态分配和释放。
缺点
  • 容量有限：缓冲区大小固定，容易发生溢出。
  • 管理复杂：需要维护头尾指针，防止数据覆盖。
示例代码
buffers.h
#ifndef BUFFERS_H
#define BUFFERS_H

#include <stdlib.h>
#include <pthread.h>

// 环形缓冲区结构
typedef struct {
    char *buffer;
    size_t head;
    size_t tail;
    size_t max_size;
    size_t current_size;
    pthread_mutex_t lock;
} RingBuffer;

RingBuffer* create_ring_buffer(size_t size);
void destroy_ring_buffer(RingBuffer *rb);
int write_to_ring_buffer(RingBuffer *rb, const char *data, size_t len);
int read_from_ring_buffer(RingBuffer *rb, char *buffer, size_t len);

#endif // BUFFERS_H
代码解释

在 buffers.h 中，我们定义了环形缓冲区的数据结构和函数声明。

  • RingBuffer：环形缓冲区结构，包含数据缓冲区 buffer、头指针 head、尾指针 tail、缓冲区的最大大小 max_size、当前大小 current_size 和用于线程安全的互斥锁 lock。
buffer.c
#include "buffers.h"
#include <string.h>

RingBuffer* create_ring_buffer(size_t size) {
    RingBuffer *rb = (RingBuffer*) malloc(sizeof(RingBuffer));
    rb->buffer = (char*) malloc(size);
    rb->head = 0;
    rb->tail = 0;
    rb->max_size = size;
    rb->current_size = 0;
    pthread_mutex_init(&rb->lock, NULL);
    return rb;
}

void destroy_ring_buffer(RingBuffer *rb) {
    free(rb->buffer);
    pthread_mutex_destroy(&rb->lock);
    free(rb);
}

int write_to_ring_buffer(RingBuffer *rb, const char *data, size_t len) {
    pthread_mutex_lock(&rb->lock);

    if (len > rb->max_size - rb->current_size) {
        pthread_mutex_unlock(&rb->lock);
        return -1; // 缓冲区溢出
    }

    for (size_t i = 0; i < len; ++i) {
        rb->buffer[rb->head] = data[i];
        rb->head = (rb->head + 1) % rb->max_size;
    }
    rb->current_size += len;

    pthread_mutex_unlock(&rb->lock);
    return 0;
}

int read_from_ring_buffer(RingBuffer *rb, char *buffer, size_t len) {
    pthread_mutex_lock(&rb->lock);

    if (len > rb->current_size) {
        pthread_mutex_unlock(&rb->lock);
        return -1; // 缓冲区为空
    }

    for (size_t i = 0; i < len; ++i) {
        buffer[i] = rb->buffer[rb->tail];
        rb->tail = (rb->tail + 1) % rb->max_size;
    }
    rb->current_size -= len;

    pthread_mutex_unlock(&rb->lock);
    return 0;
}
代码解释

在 buffer.c 中，我们实现了环形缓冲区的操作函数。

  • create_ring_buffer：初始化环形缓冲区结构，分配数据缓冲区的内存，初始化头尾指针和互斥锁。
  • destroy_ring_buffer：销毁环形缓冲区，释放数据缓冲区的内存，并销毁互斥锁。
  • write_to_ring_buffer：向环形缓冲区写入数据。首先加锁，然后检查是否有足够的空间写入数据。如果有空间，则将数据写入缓冲区，更新头指针和当前大小。最后解锁。
  • read_from_ring_buffer：从环形缓冲区读取数据。首先加锁，然后检查是否有足够的数据可读。如果有数据，则从缓冲区读取数据，更新尾指针和当前大小。最后解锁。

6. 应用场景及优缺点分析

定长缓冲区
  • 适用场景：小数据量、固定大小数据传输的场景。
  • 优点：简单高效，易于管理。
  • 缺点：不灵活，容易发生内存浪费或溢出。
链式缓冲区
  • 适用场景：数据量变化大、需要动态调整缓冲区大小的场景。
  • 优点：灵活性高，内存使用高效。
  • 缺点：管理复杂，读写性能稍差。
环形缓冲区
  • 适用场景：高并发、高频率数据传输的场景。
  • 优点：高效读写，内存使用稳定。
  • 缺点：容量有限，管理相对复杂。

7. 总结

用户态缓冲区在网络编程中起着至关重要的作用。本文介绍了三种常见的缓冲区实现方式：定长缓冲区、链式缓冲区和环形缓冲区，并通过代码示例详细讲解了它们的实现和应用场景。希望通过本文，读者能够更好地理解和应用用户态缓冲区，提高网络编程的性能和效率。

张同学的成长记录
关注
libevent源码学习（18）：缓冲区结构evbuffer
HerofH_的博客
08-27 1251
目录 evbuffer结构体 evbuffer_chain结构 evbuffer及evbuffer_chain的创建 向evbuffer中插入一个evbuffer_chain 向evbuffer中添加数据 向evbuffer的尾部添加数据 在evbuffer的头部插入数据 从evbuffer中提取数据 拷贝式提取数据 提取后删除数据 evbuffer预留一定大小的空间 从f...
字符串、输入输出缓冲区
HangMJ的博客
04-12 852
一、字符串： 字符： 在计算机中，字符是以整数形式存储的，当需要显示时根据ASCII表中的对应关系显示出相应的符号或图案 ‘\0’ 0 ‘0’ 48 ‘A’ 65 ‘a’ 97 串： 是一种数据结构，是由一组连续的相同类型的若干个数据组成，末尾有一个结束标志 对这种数据结构进行处理都是批量性处理，从开头位置到结束标志为止 字符串： 由字符组成的串行结构，他的结束标志一定是’\0’ 二、字符串的输入： scanf %c （接收字符） scanf %s 地址 注意：不能接收空格 c
【Linux】谈谈用户层缓冲区的问题
呋喃吖的博客
04-14 880
文章目录便准C的IO缓冲区标准C的IO接口缓冲区导致的一些现象解释 便准C的IO缓冲区 在C语言中，它的IO接口都是带缓冲区的； 比如什么printf,fprintf,puts,putc,scanf,sscanf等;C语言的标准IO都是有缓冲区的； 那它的缓冲区在哪呢？ 在FILE这个结构体中： 有兴趣可以在Linux操作系统中：打开文件/usr/include/stdio.h里面可找到FILE的结构体： 在/usr/include/libio.h struct _IO_FILE { int _flags;
用户缓冲区、内核缓冲区、缓冲区、缓存
weixin_46708094的博客
06-28 662
常常听到有程序员会跟你讨论：“我们在读写文件的时候，系统是有缓存的”。但实际上有一部分人把用户进程缓冲区和系统空间的缓冲区的概念混淆了，包括这两种缓冲区的用法和所要解决的问题，还有其它类似的概念。本文就来区分一下不同的缓冲区概念（主要针对类unix平台）。 用户进程和操作系统的关系 首先我用一张图来解释“用户进程和操作系统的关系” 这是一个计算机系统运行时的简化模型，我们把所有运行在操作系统上的进程成为用户进程，它们都运行在用户空间（可以看到用户空间有很多进程）。把操作系统运行的空间成为系统空间。 为什么
Linux_内核缓冲区
安权_code的博客
06-22 1725
Linux下的内核缓冲区存在于系统中，该缓冲区和用户层面的缓冲区不过同一个概念，用户层面的缓冲区称之为用户缓冲区，而系统中也有自己的缓冲区即内核缓冲区，两者虽然同为缓冲区却差之毫厘谬以千里，了解内核缓冲区前先谈谈用户缓冲区。
用户缓冲区概念
weixin_50809457的博客
11-07 109
先看现象，printf / fprintf / fwrite 一定封装了write , 但是执行代码看到大家都是去掉\n 和close(1),库函数无法打印，write可以。如果执行这两句代码你会发现程序会等待一会最后结束时打印出来，这是因为缓冲区的存在，printf把。你不是说的库函数封装了write，怎么打印不出来？
用户态网络缓冲区的设计
weixin_44585214的博客
04-09 714
生产消费模型 生产者：，追加数据 → 把数据从内核态拷贝到用户态，填充用户态网络缓冲区 。 消费者：从用户态网络缓冲区界定数据包，界定成功，取数据包 → 把剩余数据挪到最前面，修改 → 优点：结构简单，易于实现。 缺点： 需要频繁腾挪数据，只要界定成功一个完整数据包，就需要把后面的数据挪到前面，以空余更多的空间供生产者往里面填充数据。 需要实现扩缩容机制，如果缓冲区剩余空间不足以存放数据，需要对缓冲区进行扩容，并且将旧缓冲区中的数据挪到新缓冲区中。 使用场景： 客户端发送的数据比较少，并
【Linux基础IO篇】用户缓冲区、文件系统、以及软硬链接
m0_74215144的博客
11-08 670
本篇博客将介绍缓冲区、磁盘的构成、分区，以及文件系统中的结构、软硬链接
十分钟带你了解！用户进程缓冲区和内核缓冲区
fhp123的博客
08-19 4243
用户进程缓冲区和内核缓冲区 1. 用户进程和系统进程 用户进程：运行在操作系统上的进程，都运行在用户空间 系统空间：操作系统运行的空间 2. 内核态和用户态（kernel mode和user mode） （1）内核态可以访问系统资源，比如： ps：上面所说的这些系统资源，在用户进程中是无法被直接访问的，只能通过操作系统来访问，所以也把操作系统提供的这些功能成为:“系统调用”。 比如下图，展示一个用户通过shell控制计算机所经过的数据流向：文件读写和终端控制，都是通过内核进行的。 提供这些限制的基础
串的基本操作定长顺序存储表示：初始化串、复制串、判断串是否为空、比较两个字符串、计算字符串长度、清空串、连接串、找子串、模式匹配、替换子串、插入和删除子串
06-05
在IT领域，尤其是在编程语言如C中，字符串（串）是一种基本的数据结构，用于存储和处理文本信息。本文将深入探讨“串的基本操作定长顺序...在进行字符串操作时，必须注意防止缓冲区溢出和内存泄漏，确保程序的安全性。
缓冲区溢出报告
Binarymind的专栏
04-26 2400
缓冲区溢出报告1 概述1.1 编写背景         网络防范技术的日益成熟，使木马、病毒这类恶意代码的植入变得困难。网络黑客开始针对系统和程序自身存在的漏洞，编写相应的攻击程序。其中最常见的就是对缓冲区溢出漏洞的攻击，而在诸多缓冲区溢出中又以堆栈溢出的问题最有代表性。目前，利用缓冲区溢出漏洞进行的攻击已经占到了整个网络攻击次数的一半以上。        对缓冲区溢出漏洞攻击，可
【环形数据结构的同步和异步操作】：JavaScript中的事件循环和回调处理
这类结构在处理周期性或连续的数据流时尤其有用，比如在缓冲区管理、数据队列、以及流媒体数据处理中。环形结构的关键特性是有限空间的循环覆盖使用，即当数据达到结构的末尾时，会自动回到起始位置，形成一个无限...
行缓冲、全缓冲、无缓冲以及用户缓冲区、内核缓冲区介绍
m0_51429770的博客
03-06 3660
可以理解为：内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。后面讲到的内核缓冲区以及用户缓冲区能够更好理解缓冲区的作用。缓冲区其实可以算是保护我们的硬件的，所有的磁盘都是有寿命限制的（读写的次数不是无限的），到了一定的程度就坏了。所以就将我们要读写的内容都放在缓冲区中，统一进行读写，减少次数。缓冲区就是一块内存区，它用在输入输出设备和CPU之间，用来缓存数据。
日常小知识点之用户层网络缓冲区（固定内存，ringbuffer，chainbuffer）
yun6853992的博客
12-21 1954
1：网络缓冲区理解 1.1：理解背景 我们在网络编程时，通常以五元组，一个fd标识一个连接（套接字fd）。 ==》每个连接其实有接收消息和发送消息的功能。 ==》内核为每个连接分配了固定大小的发送缓冲区和接收缓冲区（套接字缓冲区）。 ==》我们通过相关api接口(如send(),recv())根据五元组标识操作对应缓冲区。 以网络通信为例理解，个人理解如下： 注释： 这里套接字fd对应的缓冲区中的数据，其实是由内核协议栈解析后，我们实际发送/接收的数据。（udp/tcp协议，由内部协议栈处理，我们关注的是
【pytorch】将模型部署至生产环境：借助TensorRT 8完成代码优化及部署（二）：C++接口实现
种一棵树最好的时间是十年前，其次是现在
05-13 1238
python接口的实现及说明详见：【pytorch】将模型部署至生产环境：借助TensorRT 8完成代码优化及部署（一）：python接口实现 （一）转换思路及模型准备： 转换思路为：pytorch -> onnx -> onnx2trt -> TensorRT 其中pytorch -> onnx详见上一篇博文。 （二）onnx2trt： bool SampleOnnxMNIST::constructNetwork(SampleUniquePtr<nvinfer1::IBu
c++ 实现高效缓存（链式buffer）
The Coding World
12-06 3483
如果我们从网络端接收的数据是不定长度的，不能提前分配好网络缓存大小，则可以选择使用链式缓存的实现方式。链式缓存主要是分配固定大小的缓存链保存数据，一个管理器去管理这些缓存链。 链式缓存示例： //一种链式缓冲 //ringbuffer是固定长度，不能够扩展，链式buffer可以任意扩充 /** * buffer * *first--chain buffer [1024] * ...
libevent框架的使用
ajffaj的博客
09-06 315
libevent框架的使用
Linux下网络缓冲区——chainbuffer的具体设计
最新发布
记录一位C++爱好者的笔记
08-30 1350
对于网络缓冲区的chain_buffer，我们这次通过代码进行详细讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值