在 C 中实现双缓冲区

Implement Double Buffer in C

所以我的数据采集率非常高16MB/s。我正在从设备文件中将 4MB 数据读入缓冲区,然后对其进行处理。然而,这种先写后读的方法对于项目来说是缓慢的。我想在 C 中实现双缓冲区。

为了简化我对双缓冲区的想法,为了简单起见,我决定不包括从设备文件中读取数据。我创建的是一个 C 程序,它生成两个单独的线程 readThread 和 writeThread。我让 readThread 调用我的交换函数来交换缓冲区的指针。

这个实现很糟糕,因为我在 Mutex 之外使用共享内存。我实际上对 post 它有点尴尬,但它至少会让你了解我正在尝试做什么。但是,我似乎无法想出一种实用的方法来同时读取和写入单独的缓冲区,然后在两个线程完成写入和读取后调用交换。

谁能告诉我是否可以实现双缓冲,并告诉我如何使用信号来控制线程读写的时间?

请注意,readToBuff(我知道的愚蠢名称)和 writeToBuff 目前实际上没有做任何事情,它们具有空白函数。

这是我的代码:

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

pthread_t writeThread;
pthread_t readThread;
pthread_mutex_t buffer_mutex;

char buff1[4], buff2[4];

struct mutex_shared {
    int stillReading, stillWriting, run_not_over;
    char *writeBuff, *readBuff;
} SHARED;

void *writeToBuff(void *idk) {
    while(!SHARED.run_not_over) {
        SHARED.stillWriting = 1;
        for(int i = 0; i < 4; i++) {
        }
        SHARED.stillWriting = 0;
        while(SHARED.stillReading){};
    }    
    printf("hello from write\n");
    return NULL;
}

void *readToBuff(void *idk) {
    while(!SHARED.run_not_over) {
        SHARED.stillReading = 1;
        for(int i = 0; i < 4; i++) {
        }
        while(SHARED.stillWriting){};
        swap(writeThread,readThread);
    }

    printf("hello from read");
    return NULL;
}

void swap(char **a, char **b){
    pthread_mutex_lock(&buffer_mutex);
        printf("in swap\n");
        char *temp = *a;
        *a = *b;
        *b = temp;
        SHARED.stillReading = 0;
        //SHARED.stillWriting = 0;
    pthread_mutex_unlock(&buffer_mutex);
}

int main() {
    SHARED.writeBuff = buff1;
    SHARED.readBuff = buff2;
    printf("buff1 address %p\n", (void*) &buff1);
    printf("buff2 address %p\n", (void*) &buff2);

    printf("writeBuff address its pointing to %p\n", SHARED.writeBuff);
    printf("readBuff address its pointing to %p\n", SHARED.readBuff);

    swap(&SHARED.writeBuff,&SHARED.readBuff);

    printf("writeBuff address its pointing to %p\n", SHARED.writeBuff);
    printf("readBuff address its pointing to %p\n", SHARED.readBuff);

    pthread_mutex_init(&buffer_mutex,NULL);

    printf("Creating Write Thread\n");

    if (pthread_create(&writeThread, NULL, writeToBuff, NULL)) {

        printf("failed to create thread\n");
        return 1;
    }
    printf("Thread created\n");
    printf("Creating Read Thread\n");
    if(pthread_create(&readThread, NULL, readToBuff, NULL)) {
            printf("failed to create thread\n");
            return 1;
    }
    printf("Thread created\n");
    pthread_join(writeThread, NULL);
    pthread_join(readThread, NULL);
    exit(0);
}

使用一对信号量似乎会更容易。每个线程都有自己的信号量,指示缓冲区已准备好读取或写入,每个线程都有自己的循环结构数组索引,每个结构都包含指向缓冲区和缓冲区大小的指针。对于双缓冲,循环数组只包含两个结构。

初始状态将读取线程的信号量计数设置为 2,将读取索引设置为第一个缓冲区,将写入线程的信号量计数设置为 0,将写入索引设置为第一个缓冲区。然后创建写入线程,它将立即等待其信号量。

读取线程在其信号量上等待 non-zero 信号量计数 (sem_wait),读入缓冲区,设置缓冲区大小,增加写入线程信号量计数 (sem_post ) 和 "advances" 它是循环结构数组的索引。

写入线程在其信号量上等待 non-zero 信号量计数 (sem_wait),从缓冲区写入(使用读取线程设置的大小),增加读取线程信号量计数(sem_post) 和 "advances" 它是循环结构数组的索引。

读取完成后,读取线程将结构的缓冲区大小设置为零以指示读取链结束,然后等待写入线程 "return" 所有缓冲区。

结构的循环数组可以包含不止 2 个结构,从而允许更多的数据嵌套。

我不得不使用类似的东西来进行高速数据捕获,但在这种情况下,输入流比单个硬盘驱动器更快,因此使用了两个硬盘驱动器,输出在两个写入线程之间交替.一个写入线程在 "even" 个缓冲区上运行,另一个在 "odd" 个缓冲区上运行。

在 Windows 的情况下,通过它的 WaitForMultipleObjects()(除 Posix 之外几乎所有操作系统都有),每个线程都可以使用互斥量和信号量,以及它自己的基于链表的消息队列。互斥锁控制队列更新的队列所有权,信号量指示队列上未决的项目数。为了检索消息,单个原子 WaitForMultipleObjects() 等待互斥锁和 non-zero 信号量计数,当两者都发生时,减少信号量计数并解除线程阻塞。一个消息发送者,只需要在互斥锁上使用 WaitForObject() 来更新另一个线程消息队列,然后发布(释放)线程信号量并释放互斥锁。这消除了线程之间的任何优先级问题。