dpdk rte_ring无锁队列 及 内核kfifo

kfifo是内核里面的一个FIFO数据结构，采用环形循环队列的数据结构来实现；它提供一个无边界的字节流服务，最重要的一点是，它使用并行无锁编程技术，即当它用于只有一个入队线程和一个出队线程的场情时，两个线程可以并发操作，而不需要任何加锁行为，就可以保证kfifo的线程安全。
kfifo代码既然肩负着这么多特性，那我们先一敝它的代码：

struct kfifo {
    unsigned char *buffer;    /* the buffer holding the data */
    unsigned int size;    /* the size of the allocated buffer */
    unsigned int in;    /* data is added at offset (in % size) */
    unsigned int out;    /* data is extracted from off. (out % size) */
    spinlock_t *lock;    /* protects concurrent modifications */ //紧用在多生产者或多消费者环境。
};

+--------------------------------------------------------------+
|            |<----------data---------->|                      |
+--------------------------------------------------------------+
             ^                          ^                      ^
             |                          |                      |
            out                        in                     size

struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask, spinlock_t *lock)
{
    unsigned char *buffer;
    struct kfifo *ret;

    /*
     * round up to the next power of 2, since our 'let the indices
     * wrap' tachnique works only in this case.
     */
    if (size & (size - 1)) {
        BUG_ON(size > 0x80000000);
        size = roundup_pow_of_two(size);
    }

    buffer = kmalloc(size, gfp_mask);
    if (!buffer)
        return ERR_PTR(-ENOMEM);

    ret = kfifo_init(buffer, size, gfp_mask, lock);

    if (IS_ERR(ret))
        kfree(buffer);

    return ret;
}

unsigned int __kfifo_put(struct kfifo *fifo,
             unsigned char *buffer, unsigned int len)
{
    unsigned int l;
    /* 本次存放的数据量，当数据量大于剩余空间时取len */
    len = min(len, fifo->size - fifo->in + fifo->out);

    smp_mb();
    /* 计算fifo->in后面还有多少可用空间 */
    l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
    memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);

    memcpy(fifo->buffer, buffer + l, len - l);

    smp_wmb();

    fifo->in += len;

    return len;
}

unsigned int __kfifo_get(struct kfifo *fifo,
             unsigned char *buffer, unsigned int len)
{
    unsigned int l;
     /* 本次取的数据量，当len大于kinfo->buf数据量时时取len */
    len = min(len, fifo->in - fifo->out);

    smp_rmb();

   /* 计算fifo->out后面有多少数据可以取 */
    l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
    memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
    memcpy(buffer + l, fifo->buffer, len - l);

    smp_mb();

    fifo->out += len;

    return len;
}

保持一个原则：先存取数据然后增加in/out.
空闲的空间：fifo->size - fifo->in + fifo->out
已占用的空间：fifo->in - fifo->out
队列空：fifo->in == fifo->out
队列满：(fifo->in - fifo->out)&(fifo->size-1) == 0

smp_mp:内存屏障用来告诉CPU保顺执行。