队列之ring_buffer优雅实现--附个人代码理解

1. 下面张贴实现该队列仅需的两个头文件：ring_buffer_iterator.h 和 fifo_iterator.h

ring_buffer_iterator.h

/*
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under  the terms of the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */


#ifndef _RING_BUFFER_ITERATOR_H_
#define _RING_BUFFER_ITERATOR_H_

#include <unistd.h>
#include <signal.h>

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdint.h>

struct ring_buffer_iterator {
    int head;          // 标识下一个待出队元素被存放的位置
    int tail;          // 标识下一个新入队元素将被存放的位置

    void *buffer;      // 外部已经申请好的一片内存 
    int node_size;     // 每个节点信息所占用的内存大小
    int node_capacity; // 标识允许挂接的节点数量
    int node_available;// 标识已经挂接的节点数量
};

// 创建一个队列容器：队列所需的内存在外部分配，此处所谓的队列容器仅仅是维护一个记录相关信息的数据结构表。
static inline struct ring_buffer_iterator *alloc_ring_buffer_iterator(
        void *buffer, int node_size, int node_capacity)
{
    struct ring_buffer_iterator *iterator;

    if (!buffer) {
        return NULL;
    }

    if (node_size <= 0) {
        return NULL;
    }

    iterator = malloc( sizeof(struct ring_buffer_iterator) );
    if (!iterator) {
        return NULL;
    }

    memset(iterator, 0x00, sizeof(struct ring_buffer_iterator) );

    //从这里可以看出，队列所需的内存在外部分配。此处所谓的队列容器仅仅是维护一个记录相关信息的数据结构表。
    iterator->buffer = buffer;
    iterator->node_size = node_size;
    iterator->node_capacity = node_capacity;

    return iterator;
}

static inline void free_ring_buffer_iterator(struct ring_buffer_iterator *it)
{
    if (!it) {
        return ;
    }

    free(it);
}
static inline int ring_buffer_get(struct ring_buffer_iterator *it, void *buffer)
{
    void *node;

    if (!it || !buffer) {
        return -EINVAL;
    }

    if (!it->node_available) {
        return -ENODATA;
    }
       // 求出待读取的队列元素数据的首地址。
    node = (uint8_t *)it->buffer + it->head * it->node_size;

    // 临界点处理 : 当head的值为node_capacity-1时，下一个待读取的元素就是位置下标0处了。
    if (it->head == it->node_capacity - 1) {
        /*
         * case of rolling at the end of buffer
         */
        it->head = 0;

    } else { // 非临界点处理，head自增即可 
        it->head++;
    }

    it->node_available--;

    memmove(buffer, node, it->node_size);

    return 0;
}


static inline int ring_buffer_peek(struct ring_buffer_iterator *it, void *buffer)
{
    void *node;

    if (!it || !buffer) {
        return -EINVAL;
    }

    if (!it->node_capacity) {
        return -ENODATA;
    }

    node = (uint8_t *)it->buffer + it->head * it->node_size;

    memmove(buffer, node, it->node_size);

    return 0;
}


static inline int ring_buffer_put(struct ring_buffer_iterator *it, void *buffer)
{
    void *node;

    if (!it || !buffer) {
        return -EINVAL;
    }

    /*  对下方的问题1的解答：
    队列中有数据的情况下，head和tail还会有相等的场景么。
    我认为不会进入这种情况，这段代码是多余的。
    */
    if (it->node_available) {

         // 新元素入队待存放地址下标 什么时候 等于 待出队元素的地址下标呢？《== 问题1
        if (it->tail == it->head) {
            /*
             * case of rolling to buffer over lapped
             */
            if (it->node_capacity != 1) {
                /*
                 * case of not single node capacity buffer
                 */
                if (it->tail == it->node_available - 1) {
                    /*
                     * case of rolling to end of buffer
                     */
                    it->head = 0;
                } else {
                    it->head = it->tail + 1;
                }
            }

        }
    } /* end of it->node_available */

    node = (uint8_t *)it->buffer + it->tail *it->node_size;
    memmove(node, buffer, it->node_size);

    if (it->tail == it->node_capacity - 1) {
        /* 更新下一个入队元素将要被存放的地址下标。
         * rolling to end of buffer
         */
        it->tail = 0;
    } else {
        it->tail++;
    }

    if (it->node_available != it->node_capacity) {
        it->node_available++;
    }

    return 0;
}

static inline void ring_buffer_clear(struct ring_buffer_iterator *it)
{
    if (!it) {
        return;
    }

    it->head = 0;
    it->tail = 0;
    it->node_available = 0;
    it->node_capacity  = 0;
}


/*
 * =1: the ring buffer is full
 * =0: the ring buffer is not full
 */
static inline int ring_buffer_full(struct ring_buffer_iterator *it)
{
    if (!it) {
        return -EINVAL;
    }

    return it->node_available == it->node_capacity;
}

/*
 * =1: the ring buffer is empty
 * =0: the ring buffer is not empty
 */
static inline int ring_buffer_empty(struct ring_buffer_iterator *it)
{
    if (!it) {
        printf("it = NULL 
");
        return -EINVAL;
    }

    printf("it->node_available :[ %d ] 
", it->node_available);

    return !(it->node_available);
}

static inline int ring_buffer_capacity(struct ring_buffer_iterator *it)
{
    if (!it) {
        return -EINVAL;
    }

    return (it->node_capacity);
}

static inline int ring_buffer_available(struct ring_buffer_iterator *it)
{
    if (!it) {
        return -EINVAL;
    }

    return (it->node_available);
}



#endif /* _RING_BUFFER_ITERATOR_H_ */

fifo_iterator.h

/*
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under  the terms of the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */


#ifndef _FIFO_ITERATOR_H_
#define _FIFO_ITERATOR_H_

#include "ring_buffer_iterator.h"

struct fifo_iterator {
    struct ring_buffer_iterator *ring_it;
};

// 创建一个迭代器，创建一个容器实，并让该迭代器指向该容器。
static inline struct fifo_iterator *alloc_fifo_iterator(
        void *buffer, int size, int capacity)
{
    // 创建一个迭代器
    struct fifo_iterator *iterator = malloc(sizeof(struct fifo_iterator));

    if (!iterator) {
        return NULL;
    }

    // 创建一个容器，并让该迭代器指向该容器。   
    iterator->ring_it = alloc_ring_buffer_iterator(buffer, size, capacity);
    if (!iterator->ring_it) {
        return NULL;
    }

    return iterator;
}

static inline void free_fifo_iterator(struct fifo_iterator *it)
{
    if (it && it->ring_it) {
        free_ring_buffer_iterator(it->ring_it);
    }

    if (it) {
        free(it);
    }
}

/*
 * =1: fifo buffer is full
 * =0: fifo buffer is not full
 */
static inline int fifo_full(struct fifo_iterator *it)
{
    return ring_buffer_full(it->ring_it);
}

/*
 * =1: fifo buffer is empty
 * =0: fifo buffer is not empty
 */
static inline int fifo_empty(struct fifo_iterator *it)
{
    return ring_buffer_empty(it->ring_it);
}

static inline int fifo_enqueue(struct fifo_iterator *it, void *buffer)
{
    if (ring_buffer_full(it->ring_it)) {
        return -EOVERFLOW;
    }

    static int i=0;
    printf("enQuence Success! %d 
", ++i);
    return ring_buffer_put(it->ring_it, buffer);
}

static inline int fifo_dequeue(struct fifo_iterator *it, void *buffer)
{
    return ring_buffer_get(it->ring_it, buffer);
}

static inline int fifo_peek(struct fifo_iterator *it, void *buffer)
{
    return ring_buffer_peek(it->ring_it, buffer);
}

#endif /* _FIFO_ITERATOR_H_ */

2. 测试代码展示

main.c

#include <stdio.h>
#include "fifo_iterator.h"

typedef struct _mydatastruct{

    int data1;
    int data2;

}mydatastruct;

mydatastruct data_t_in, data_t_out;

#define  fifo_array   4

int main()
{
    struct fifo_iterator * fifo_it = NULL;
    
    void* pbuff = malloc(sizeof(mydatastruct)*fifo_array);

    /*  alloc_fifo_iterator(void *buffer, int size, int capacity)函数内部 ： 
            fifo_it->ring_it->buffer = buffer;
            fifo_it->ring_it->node_size = node_size;
            fifo_it->ring_it->node_capacity = node_capacity;  
    */
    fifo_it = alloc_fifo_iterator(pbuff, sizeof(mydatastruct), fifo_array);

    while(1)
    {

      //  in
      data_t_in.data1 = 88; 
      data_t_in.data2 = 89;
      if(0 != fifo_enqueue(fifo_it, &data_t_in))
        printf("Error
");

      //  in
      data_t_in.data1 = 98;
      data_t_in.data2 = 99;
      if(0 != fifo_enqueue(fifo_it, &data_t_in))
        printf("Error
");

       // out  
      fifo_dequeue(fifo_it, &data_t_out);
      printf("  fifo_dequeue :    
          data_t_out.data1 [%d]   data_t_out.data2 [%d]  
", 
                      data_t_out.data1, data_t_out.data2);
      //  in
      data_t_in.data1 = 100;
      if(0 != fifo_enqueue(fifo_it, &data_t_in))
        printf("Error
");

       // out  
      fifo_dequeue(fifo_it, &data_t_out);
      printf("  fifo_dequeue :    
          data_t_out.data1 [%d]   data_t_out.data2 [%d]  
", 
                      data_t_out.data1, data_t_out.data2);

       // out  
      fifo_dequeue(fifo_it, &data_t_out);
      printf("  fifo_dequeue :    
          data_t_out.data1 [%d]  data_t_out.data2 [%d]  
", 
                      data_t_out.data1, data_t_out.data2);


      printf(" 

");
      sleep(1);
    }

    return 0;
}

makefile:

.PHONY: doit

doit:
    #mips-linux-gnu-gcc -g main.c -o  main_app
    gcc -g main.c -o  main_app

.