最新电影在线观看,jrs低调看直播,avav天堂,囯产精品宾馆在线精品酒店,亚洲精品成人区在线观看

適用于嵌入式的輕量級環緩沖區管理庫！

嵌入式大雜燴 3星期前 83 閱讀 3 贊 3 收藏 0 評論

1. 為什么需要環形緩沖區？

在嵌入式開發中，我們經常遇到這樣的場景：串口接收數據、傳感器采集、網絡數據包處理...這些都涉及到一個核心問題——如何高效地管理有限內存中的數據流？

例如，開發一個物聯網設備，需要處理源源不斷的傳感器數據。傳統的數組緩沖區就像一個裝滿水的杯子，倒滿了就得全部倒掉重新開始，這顯然不夠優雅。而環形緩沖區就像一個永不停歇的水車，數據可以持續流入流出，充分利用每一寸存儲空間。

2. LwRB簡介

LwRB（Lightweight Ring Buffer） 是一個輕量級通用環緩沖區管理庫，在GitHub上已經獲得了數千個星標，被廣泛應用于各種嵌入式項目中。

//github.com/MaJerle/lwrb

為什么選擇LwRB？

  • 零動態內存分配 - 完全使用靜態內存，避免內存碎片
  • 高性能 - 使用優化的memcpy操作，而非逐字節循環
  • 線程安全 - 基于C11原子操作，支持單讀單寫的并發場景
  • DMA友好 - 支持零拷貝操作，完美配合硬件DMA

3. 核心原理解析

3.1 環形緩沖區模型

  • R指針（讀指針）：就像一個"消費者"，負責讀取數據
  • W指針（寫指針）：就像一個"生產者"，負責寫入數據
  • 緩沖區大小S：跑道的總長度

關鍵規則：

  1. 當 W == R 時，緩沖區為空（兩個指針重合）
  2. 當 W == (R-1) % S 時，緩沖區已滿（寫指針追上了讀指針）
  3. 實際可用容量是 S-1 字節（需要保留一個位置來區分空和滿）

讓我們看看不同狀態下的緩沖區：

3.2 內存安全機制

LwRB的內存安全機制是如何防止緩沖區溢出的：

// 寫入前的安全檢查
free = lwrb_get_free(buff);
if (free == 0 || (free < btw && (flags & LWRB_FLAG_WRITE_ALL))) {
    return 0;  // 安全退出，防止溢出
}
btw = BUF_MIN(free, btw);  // 限制寫入量為可用空間

3.3 線程安全的實現

LwRB的線程安全設計分為兩種情況：

C11原子操作：

C11 標準引入了原子操作（Atomic Operations），用于解決多線程環境下的數據競爭（data race） 問題。原子操作是不可分割的操作，在執行過程中不會被其他線程打斷，因此可以安全地在多線程中共享數據，無需依賴互斥鎖等同步機制。

// 原子讀取
#define LWRB_LOAD(var, type) atomic_load_explicit(&(var), (type))
// 原子寫入  
#define LWRB_STORE(var, val, type) atomic_store_explicit(&(var), (val), (type))

這些原子操作確保了指針的讀寫是不可中斷的，即使在多線程環境下也能保證數據的一致性。

原子操作 vs 鎖:

  • 原子操作：適用于簡單操作（如計數器、標志位），開銷小（通常對應一條硬件原子指令），無阻塞。
  • 鎖（如互斥鎖）：適用于復雜臨界區（多步操作），開銷較大（可能涉及內核態切換），可能阻塞線程。

4. 關鍵代碼

4.1 核心數據結構

讓我們來看看LwRB的核心數據結構：

typedef struct lwrb {
    uint8_t* buff;                    // 緩沖區數據指針
    lwrb_sz_t size;                   // 緩沖區大小
    lwrb_sz_atomic_t r_ptr;           // 讀指針（原子類型）
    lwrb_sz_atomic_t w_ptr;           // 寫指針（原子類型）
    lwrb_evt_fn evt_fn;               // 事件回調函數
    void* arg;                        // 用戶自定義參數
} lwrb_t;
  • 指針與大小分離：buff和size分開存儲，支持任意大小的緩沖區
  • 原子類型指針：r_ptr和w_ptr使用原子類型，確保線程安全
  • 事件機制：evt_fn和arg提供了靈活的回調機制

4.2 寫操作的兩階段策略

LwRB的寫操作采用了一個兩階段策略：

對應代碼：

// 階段1：寫入線性部分
tocopy = BUF_MIN(buff->size - w_ptr, btw);
BUF_MEMCPY(&buff->buff[w_ptr], d_ptr, tocopy);
d_ptr += tocopy;
w_ptr += tocopy;
btw -= tocopy;

// 階段2：寫入環繞部分（如果需要）
if (btw > 0) {
    BUF_MEMCPY(buff->buff, d_ptr, btw);
    w_ptr = btw;
}

// 階段3：原子更新指針
LWRB_STORE(buff->w_ptr, w_ptr, memory_order_release);

4.3 讀操作的內存優化

讀操作采用了與寫操作類似的策略：

// 讀操作同樣分兩階段
// 階段1：讀取線性部分
tocopy = BUF_MIN(buff->size - r_ptr, btr);
BUF_MEMCPY(d_ptr, &buff->buff[r_ptr], tocopy);

// 階段2：讀取環繞部分
if (btr > 0) {
    BUF_MEMCPY(d_ptr, buff->buff, btr);
    r_ptr = btr;
}

4.4 Peek功能的巧妙實現

LwRB還提供了一個非常實用的peek功能，可以預覽數據而不移動讀指針：

lwrb_sz_t lwrb_peek(const lwrb_t* buff, lwrb_sz_t skip_count, 
                    void* data, lwrb_sz_t btp);

這就像在書店里翻閱書籍，你可以看內容但不把書拿走。這個功能在協議解析中特別有用：

5. 例子

5.1 最小例子

#include 
#include 
#include "lwrb/lwrb.h"

int main(void) {
    /* 聲明環形緩沖區實例和原始數據 */
    lwrb_t buff = {0};
    uint8_t buff_data[8] = {0};

    /* 初始化緩沖區 */
    lwrb_init(&buff, buff_data, sizeof(buff_data)); 

    /* 寫入4字節數據 */
    lwrb_write(&buff, "0123", 4);

    printf("Bytes in buffer: %d\r\n", (int)lwrb_get_full(&buff));

    /* 現在開始讀取 */
    uint8_t data[8] = {0}; /* 應用程序工作數據 */
    size_t len = 0;

    /* 從緩沖區讀取數據 */
    len = lwrb_read(&buff, data, sizeof(data));
    printf("Number of bytes read: %d, data: %s\r\n", (int)len, data);

    return0;
}

5.2 環形緩沖區與普通緩沖區覆蓋寫入對比

// 環形緩沖區與普通緩沖區覆蓋寫入對比

#include 
#include 
#include 
#include "lwrb/lwrb.h"

/* 普通緩沖區實現 */
typedefstruct {
    uint8_t* data;
    size_t size;
    size_t head;  /* 寫入位置 */
    size_t tail;  /* 讀取位置 */
    size_t count; /* 當前數據量 */
} normal_buffer_t;

void normal_buffer_init(normal_buffer_t* buf, uint8_t* data, size_t size) {
    buf->data = data;
    buf->size = size;
    buf->head = 0;
    buf->tail = 0;
    buf->count = 0;
}

size_t normal_buffer_write(normal_buffer_t* buf, const void* data, size_t len) {
    /* 普通緩沖區：滿了就不能寫入，需要移動數據 */
    if (buf->count + len > buf->size) {
        /* 需要移動數據到前面 */
        if (buf->tail > 0 && buf->count > 0) {
            memmove(buf->data, buf->data + buf->tail, buf->count);
            buf->head = buf->count;
            buf->tail = 0;
        }
        /* 重新檢查空間，確保不會溢出 */
        if (buf->count + len > buf->size) {
            if (buf->count >= buf->size) {
                return0; /* 緩沖區已滿，無法寫入 */
            }
            len = buf->size - buf->count; /* 截斷數據 */
        }
    }
    
    if (len > 0 && buf->head + len <= buf->size) {
        memcpy(buf->data + buf->head, data, len);
        buf->head += len;
        buf->count += len;
    } else {
        len = 0; /* 防止溢出 */
    }
    return len;
}

size_t normal_buffer_read(normal_buffer_t* buf, void* data, size_t len) {
    if (len > buf->count) {
        len = buf->count;
    }
    
    memcpy(data, buf->data + buf->tail, len);
    buf->tail += len;
    buf->count -= len;
    
    return len;
}

void demo_overwrite_behavior(void) {
    
    /* 小緩沖區演示覆蓋行為 */
    lwrb_t ring_buf = {0};
    uint8_t ring_data[8] = {0};
    lwrb_init(&ring_buf, ring_data, sizeof(ring_data));
    
    normal_buffer_t normal_buf = {0};
    uint8_t normal_data[8] = {0};
    normal_buffer_init(&normal_buf, normal_data, sizeof(normal_data));
    
    printf("緩沖區大小: 8 字節\n");
    
    /* 第一次寫入 */
    printf("\n1. 寫入 \"HELLO\" (5字節):\n");
    lwrb_write(&ring_buf, "HELLO", 5);
    normal_buffer_write(&normal_buf, "HELLO", 5);
    printf("環形緩沖區存儲: %zu 字節\n", lwrb_get_full(&ring_buf));
    printf("普通緩沖區存儲: %zu 字節\n", normal_buf.count);
    
    /* 第二次寫入 */
    printf("\n2. 繼續寫入 \"WORLD\" (5字節):\n");
    size_t ring_w2 = lwrb_write(&ring_buf, "WORLD", 5);
    size_t normal_w2 = normal_buffer_write(&normal_buf, "WORLD", 5);
    printf("環形緩沖區: 寫入 %zu 字節, 存儲 %zu 字節 (覆蓋了舊數據)\n", 
           ring_w2, lwrb_get_full(&ring_buf));
    printf("普通緩沖區: 寫入 %zu 字節, 存儲 %zu 字節 (已滿，無法寫入更多)\n", 
           normal_w2, normal_buf.count);
    
    /* 讀取所有數據 */
    printf("\n3. 讀取所有數據:\n");
    uint8_t buffer[16] = {0};
    
    size_t ring_read = lwrb_read(&ring_buf, buffer, sizeof(buffer));
    buffer[ring_read] = '\0';
    printf("環形緩沖區讀取: \"%s\" (%zu 字節)\n", buffer, ring_read);
    
    size_t normal_read = normal_buffer_read(&normal_buf, buffer, sizeof(buffer));
    buffer[normal_read] = '\0';
    printf("普通緩沖區讀取: \"%s\" (%zu 字節)\n", buffer, normal_read);
}

int main(void) {
    printf("=== 環形緩沖區 vs 普通緩沖區 覆蓋寫入行為對比 ===\n");

    /* 覆蓋寫入測試 */
    demo_overwrite_behavior();

    return0;
}

  • 環形緩沖區: 自動管理空間，新數據覆蓋舊數據，適合實時數據流。

  • 普通緩沖區: 滿了就無法寫入，需要手動管理空間，容易丟失數據。

6. 環形緩沖區 VS 消息隊列

環形緩沖區（Circular Buffer）和消息隊列（Message Queue）都是用于在生產者與消費者之間傳遞數據的緩沖機制，但在設計目標、數據處理方式和適用場景上存在顯著差異。

環形緩沖區（Circular Buffer）和消息隊列（Message Queue）都是用于在生產者與消費者之間傳遞數據的緩沖機制，但在設計目標、數據處理方式和適用場景上存在顯著差異。以下從相同點和不同點兩方面詳細分析：

6.1 相同點

  • 支持“生產者-消費者”模型：基本邏輯一致：生產者向緩沖區寫入數據，消費者從緩沖區讀取數據，兩者通過緩沖區解耦（無需直接交互）。
  • 核心功能一致：兩者均作為數據傳遞的“中間層”，解決生產者與消費者速度不匹配的問題（如生產者生成數據快于消費者處理）。
  • 依賴同步機制：都需要處理并發訪問問題（如多線程讀寫），通常依賴互斥鎖（Mutex）、信號量（Semaphore）等保證數據一致性（避免讀寫沖突）。

6.2 不同點

6.3 總結

  • 環形緩沖區：優勢在于高性能、低開銷，適合對實時性和內存效率要求高的場景（如底層驅動、流媒體），但靈活性低，需手動處理消息邊界。
  • 消息隊列：優勢在于靈活性高、支持結構化消息和優先級，適合復雜的消息傳遞場景（如跨進程/服務通信），但內存開銷略高，不適合高頻連續數據傳輸。
聲明：本內容為作者獨立觀點，不代表電子星球立場。未經允許不得轉載。授權事宜與稿件投訴，請聯系：editor@netbroad.com
覺得內容不錯的朋友，別忘了一鍵三連哦！
贊 3
收藏 3
關注 33
成為作者 賺取收益
全部留言
0/200
成為第一個和作者交流的人吧