Circular Queue Implementation Principle

目录

. 引言
. 环形队列的实现原理
. 环形队列编程实现
. 环形队列的内核实现

1. 引言

环形队列是在实际编程极为有用的数据结构,它有如下特点

. 它是一个首尾相连的FIFO(First In First Out 队列)的数据结构
. 采用数组的线性空间，数据组织简单
. 能很快知道队列是否满、或是否空
. 能以很快的速度、几乎无锁的方式(只在写满或为空的情况下需要加锁实现互斥同步)来存取数据 

因为环形队列简单高效的原因，甚至在硬件都实现了环形队列，环形队列广泛用于网络数据收发，和不同程序间数据交换(比如内核与应用程序大量交换数据，从硬件接收大量数据)均使用了环形队列

0x1: FIFO队列

First Input First Output的缩写，先入先出队列，这是一种传统的按序执行方法，先进入的指令先完成并引退，跟着才执行第二条指令

. FIFO队列不对报文进行分类，当报文进入接口的速度大于接口能发送的速度时，FIFO按报文到达接口的先后顺序让报文进入队列，同时，FIFO在队列的出口让报文按进队的顺序出队，先进的报文将先出队，后进的报文将后出队
. FIFO队列具有处理简单，开销小的优点。但FIFO不区分报文类型，采用尽力而为的转发模式，使对时间敏感的实时应用(如VoIP)的延迟得不到保证，关键业务的带宽也不能得到保证
. FIFO一般用于不同时钟域之间的数据传输，比如FIFO的一端是AD数据采集，另一端是计算机的PCI总线
    ) 假设其AD采集的速率为16位 100K SPS，那么每秒的数据量为100K×16bit=.6Mbps
    ) PCI总线的速度为33MHz，总线宽度32bit，其最大传输速率为1056Mbps
在两个不同的时钟域间就可以采用FIFO来作为数据缓冲。另外对于不同宽度的数据接口也可以用FIFO，例如单片机位8位数据输出，而DSP可能是16位数据输入，在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的 

根据FIFO工作的时钟域，可以将FIFO分为两类

. 同步FIFO
同步FIFO是指读时钟和写时钟为同一个时钟。在时钟沿来临时同时发生读写操作，共同争用同一个FIFO队列

. 异步FIFO
异步FIFO是指读写时钟不一致，读写时钟是互相独立的，可以一定程度上提高FIFO的利用效率，同时也会带来同步的问题

FIFO设计的难点在于怎样判断FIFO的空/满状态。为了保证数据正确的写入或读出，而不发生溢出或读空的状态出现，必须保证FIFO在满的情况下，不能进行写操作。在空的状态下不能进行读操作。怎样判断FIFO的满/空就成了FIFO设计的核心问题，而循环队列是一个很好的算法思路

Relevant Link:

http://baike.baidu.com/view/736423.htm?fromtitle=FIFO&fromid=64838&type=syn

2. 环形队列的实现原理

内存上没有环形的结构，因此环形队列实上是数组的线性空间来实现。当数据到了尾部如何处理，它将转回到0位置来处理。这个的转回是通过取模操作来执行的
因此环列队列的是逻辑上将数组元素q[0]与q[MAXN-1]连接，形成一个存放队列的环形空间，为了方便读写，还要用数组下标来指明队列的读写位置

. head: head指向可以读的位置
. tail: tail指向可以写的位置 

环形队列的关键是判断队列为空，还是为满

. 当tail追上head时，队列为写满
. 当head追上tail时，队列为读空

如何判断环形队列为空，为满有两种判断方法

. 附加一个标志位tag
    ) 当head赶上tail，队列空，则tag =
    ) 当tail赶上head，队列满，则tag = 

. 限制tail赶上head，即队尾结点与队首结点之间至少留有一个元素的空间
    ) 队列空: head == tail
    ) 队列满: (tail+) % MAXN == head

Relevant Link:

http://docs.linuxtone.org/ebooks/C&CPP/c/ch12s05.html
http://coolshell.cn/tag/disruptor
http://www.searchtb.com/2012/10/introduction_to_disruptor.html
http://www.cnblogs.com/haolujun/archive/2012/10/03/2710726.html

3. 环形队列编程实现

0x1: 附加标志环形队列Ring Buffer

ringq.h

#ifndef __RINGQ_H__
#define __RINGQ_H__

#ifdef __cplusplus
extern "C"
{
#endif 

#define QUEUE_MAX 20

/*
1. 初始化状态: q->head = q->tail = q->tag = 0;
2. 队列为空:(q->head == q->tail) && (q->tag == 0)
3. 队列为满: ((q->head == q->tail) && (q->tag == 1))

1. 入队操作: 如队列不满，则写入: q->tail =  (q->tail + 1) % q->size ;
2. 出队操作：如果队列不空，则从head处读出
3. 下一个可读的位置: q->head =  (q->head + 1) % q->size
*/
typedef struct ringq
{
   int head; /* 头部，出队列方向*/
   int tail; /* 尾部，入队列方向*/
   int tag ; /* 为空还是为满的标志位*/
    int size ; /* 队列总尺寸 */
   int space[QUEUE_MAX]; /* 队列空间 */
}RINGQ;

/*
第一种设计方法:
当head == tail 时，tag = 0 为空，等于 = 1 为满
*/

extern int ringq_init(RINGQ * p_queue);

extern int ringq_free(RINGQ * p_queue);

/* 加入数据到队列 */
extern int ringq_push(RINGQ * p_queue,int data);

/* 从队列取数据 */
extern int ringq_poll(RINGQ * p_queue,int *p_data);

#define ringq_is_empty(q) ( (q->head == q->tail) && (q->tag == 0))

#define ringq_is_full(q) ( (q->head == q->tail) && (q->tag == 1))

#define print_ringq(q) printf("ring head %d,tail %d,tag %d\n", q->head,q->tail,q->tag);
#ifdef __cplusplus
}
#endif 

#endif /* __RINGQ_H__ */

ringq.c

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

int ringq_init(RINGQ * p_queue)
{
    p_queue->size = QUEUE_MAX ;

    p_queue->head = ;
    p_queue->tail = ;

    p_queue->tag = ;

    return ;
}

int ringq_free(RINGQ * p_queue)
{
    return ;
}

int ringq_push(RINGQ * p_queue,int data)
{
    print_ringq(p_queue);

    if(ringq_is_full(p_queue))
    {
        printf("ringq is full\n");
        return -;
    }

    p_queue->space[p_queue->tail] = data;

    p_queue->tail = (p_queue->tail + ) % p_queue->size ;

    /* 这个时候一定队列满了*/
    if(p_queue->tail == p_queue->head)
    {
        p_queue->tag = ;
    }

    return p_queue->tag ;
}

int ringq_poll(RINGQ * p_queue,int * p_data)
{
    print_ringq(p_queue);
    if(ringq_is_empty(p_queue))
    {
        printf("ringq is empty\n");
        return -;
    }

    *p_data = p_queue->space[p_queue->head];

    p_queue->head = (p_queue->head + ) % p_queue->size ;

    /* 这个时候一定队列空了*/
    if(p_queue->tail == p_queue->head)
    {
        p_queue->tag = ;
    }
    return p_queue->tag ;
}

/* 测试第一种环形队列*/
void test5()
{
    RINGQ rq, * p_queue;
    int i,data;

    p_queue = &rq;

    ringq_init(p_queue);

    for(i=; i < QUEUE_MAX + ; i++)
    {
        ringq_push(p_queue,i+);
    } 

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    ringq_free(p_queue);
}

/* 测试第一种环形队列,更加复杂的情况*/
void test6()
{
    RINGQ rq, * p_queue;
    int i,data;

    p_queue = &rq;

    ringq_init(p_queue);
    ringq_push(p_queue,);
    ringq_push(p_queue,); 

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    ringq_push(p_queue,);
    ringq_push(p_queue,);
    ringq_push(p_queue,); 

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    ringq_push(p_queue,); 

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    if(ringq_poll(p_queue,&data)>=)
    PRINT_INT(data);

    ringq_free(p_queue);
} 

int mani()
{
    test5();
    test6();

    return ;
}

0x2: 预留空间环形队列

ringq.h

#ifndef __RINGQ_H__
#define __RINGQ_H__

#ifdef __cplusplus
extern "C"
{
#endif 

#define RINGQ_MAX 20

/*
1. 初始化状态: q->head = q->tail = q->tag = 0;
2. 队列为空:(q->head == q->tail)
3. 队列为满: (((q->tail+1)%q->size) == q->head )

1. 入队操作: 如队列不满，则写入: q->tail =  (q->tail + 1) % q->size ;
2. 出队操作：如果队列不空，则从head处读出
3. 下一个可读的位置: q->head = (q->head + 1) % q->size
*/
typedef struct ringq
{
   int head; /* 头部，出队列方向*/
   int tail; /* 尾部，入队列方向*/
   int size ; /* 队列总尺寸 */
   int space[RINGQ_MAX]; /* 队列空间 */
}RINGQ;

/*
  取消tag .限制读与写之间至少要留一个空间
  队列空 head == tail .
  队列满是 (tail+1)%MAX == head
  初始化是head = tail = 0;
*/

extern int ringq_init(RINGQ * p_ringq);

extern int ringq_free(RINGQ * p_ringq);

extern int ringq_push(RINGQ * p_ringq,int data);

extern int ringq_poll(RINGQ * p_ringq,int * p_data);

#define ringq_is_empty(q) (q->head == q->tail)

#define ringq_is_full(q) (((q->tail+1)%q->size) == q->head )

#define print_ringq2(q,d) printf("ring head %d,tail %d,data %d\n", q->head,q->tail,d);

#ifdef __cplusplus
}
#endif 

#endif /* __QUEUE_H__ */

ringq.c

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

int ringq_init(RINGQ * p_ringq)
{
    p_ringq->size = RINGQ_MAX;

    p_ringq->head = ;
    p_ringq->tail = ;

    return p_ringq->size;
}

int ringq_free(RINGQ * p_ringq)
{
    return ;
}

/* 往队列加入数据 */
int ringq_push(RINGQ * p_ringq,int data)
{
    print_ringq(p_ringq,data);

    if(ringq_is_full(p_ringq))
    {
        printf("ringq is full,data %d\n",data);
        return -;
    }

    p_ringq->space[p_ringq->tail] = data;
    p_ringq->tail = (p_ringq->tail + ) % p_ringq->size ;   

    return p_ringq->tail ;
}

int ringq_poll(RINGQ * p_ringq,int * p_data)
{
    print_ringq(p_ringq,-);
    if(ringq_is_empty(p_ringq))
    {
        printf("ringq is empty\n");
        return -;
    }

    *p_data = p_ringq->space[p_ringq->head];
    p_ringq->head = (p_ringq->head + ) % p_ringq->size ;

    return p_ringq->head;
}

Relevant Link:

http://blog.csdn.net/sking002007/article/details/6584590
http://blog.chinaunix.net/uid-26669601-id-3737307.html
http://blog.sina.com.cn/s/blog_79c57c3d01019v8p.html

4. 环形队列的内核实现

在内核态实现无锁的读写环形队列

. 内核态Hook进程/线程会不断的通过自旋互斥锁，试图获取下一个可以写数据的4K内存页，请求会在下面两个情况下失败
    ) 环形队列写满: READ_FLAG == READING()，即头追上了尾巴，这种情况下，当前进程需要保持自旋，并在超时后丢包
    ) 其他进程正在请求当前内存页: Spin_lock已经被持有，这种情况下，当前进程需要等待上一个进程请求完成，并将current_page+1并释放Spin_lock后，方可继续请求下一个内存页
. 用户态进程负责从环形队列中读取数据，它有两种状态
    ) READING: 表示用户态程序接收到了内核态的SIGNAL信号，并处于数据读取状态，在这个状态下，内核态其他进程在完成了数据写之后不会发送SIGNAL信号(内核态进程会检查用户态进程是否处于READING状态)
    ) FLUSHING: 用户态进程已经完成了数据读取，准备好开始捕获信号
. 内核态进程在写完Page.n的数据之后，会将当前内存页的READ_FLAG设置为1，如果用户态进程处于FLUSH态，会向用户态进程发送一个SIGNAL信号，告诉用户态进程当前第n个内存页已经写完毕了，这个SIGNAL信号是通过SIGNAL BUFFER缓存的
//可能存在内核态进程并发地发送了多个SIGNAL
. 用户态进程接收到SIGNAL信号的通知后，通过SetREADING将自己的状态切换为READING态，立即开始从环形队列的开头开始逐页读数据，在没有完成读数据之前，内核态进程不会再发送SIGNAL
. 用户态进程会从环形队列开头逐页检查当前页是否可读(READ_FLAG=)，在读取完当前Page页后将当前页的READ_FLAG设置为0
. 用户态进程会不间断地一直往下读，直到遇到某个内存页的READ_FLAG=，说明当前内核态挤压的数据已经全部读取完
/*
这个逻辑可以实现几乎无锁的异步式的共享内存读写，在高负载IO的情况下可以获得很好的通信性能，但这里面存在一个问题，简单描述如下
1. 内核态有多个进程同时请求内存页进行写数据，在互斥锁的控制下它们分别获取了紧挨着的一系列的内存页进行写入
2. 其中有一个进程率先完成了写数据，在设置了READ_FLAG之后，向用户态发送信号，但此时其他进程还没有完成数据的写入
3. 所以用户态进程在遍历整个环形队列的时候，只会读取那块已经完成了数据写入的内存页，而不会读取其他未完成数据写入的内存页
4. 如果在这个期间，其他进程完成了数据的写入，但是因为用户态进程处于READING态导致信号不会被发送(即刚刚好用户态进程遍历过它之后它才完成写入)，则对应的内存页就不会被用户态进程读取了，而只能等到下一次其他进程发送SIGNAL信号，才有机会被读取
5. 在串行Hook的模式下，这种数据的积压会造成Hook超时，而最终丢包
*/
. 为了解决这个问题，用户态进程采取了"double循环遍历"，即完成第一次遍历之后，通过SetFLUSHING将当前状态设置了FLUSH，然后再次遍历一次环形队列，这大大降低了数据超时的发生

aaarticlea/png;base64,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" alt="" />

Copyright (c) 2015 LittleHann All rights reserved