linux中kfifo的无锁队列实现解读

简介

kfifo是linux内核中的一个模块。
在单消费者，单生产者情况下，可以达到不加锁也能保证线程安全的效果。

路径

linux/lib/kfifo.c，链接直达：https://github.com/torvalds/linux/blob/master/lib/kfifo.c
linux/include/linux/kfifo.h，链接直达：https://github.com/torvalds/linux/blob/master/include/linux/kfifo.h

数据结构

struct __kfifo {
    unsigned int    in; //写指针
    unsigned int    out;//读指针
    unsigned int    mask; //size-1
    unsigned int    esize;//单个元素的大小
    void        *data; //保存数据
};

接口函数

//创建
kfifo_alloc(fifo, size, gfp_mask)
//初始化
kfifo_init(fifo, buffer, size)
//释放
kfifo_free(fifo)
//写数组
kfifo_put(fifo, val)
//读数组
kfifo_get(fifo, val)
//读数组但不移除
kfifo_peek(fifo, val)
//写多个数据
kfifo_in(fifo, buf, n)
//读多个数据
kfifo_out(fifo, buf, n)
//读多个数据但不移除
kfifo_out_peek(fifo, buf, n)
//fifo大小
kfifo_size(fifo)
//fifo数据长度
kfifo_len(fifo) 
//fifo是否为空
kfifo_is_empty(fifo)

实现

无锁队列核心

在改变读写指针的时候，应该是原子操作。这要求仅通过读写指针的关系来判断剩余空间长度，而不是用一个变量来记录已使用长度。（更详细解释，可以看这个博主的文章：https://airekans.github.io/c/2015/10/12/linux-kernel-data-str...）
限制长度在2的整次幂就能支撑这种方式，而不仅仅是比求模效率高。

计算剩余空间

static inline unsigned int kfifo_unused(struct __kfifo *fifo)
{
    return (fifo->mask + 1) - (fifo->in - fifo->out);
}

未利用size为2的整次幂这特性。

写数据

static void kfifo_copy_in(struct __kfifo *fifo, const void *src,
        unsigned int len, unsigned int off)
{
    unsigned int size = fifo->mask + 1;
    unsigned int esize = fifo->esize;
    unsigned int l;

    off &= fifo->mask;
    if (esize != 1) {
        off *= esize;
        size *= esize;
        len *= esize;
    }
    l = min(len, size - off);

    memcpy(fifo->data + off, src, l);
    memcpy(fifo->data, src + l, len - l);
    /*
     * make sure that the data in the fifo is up to date before
     * incrementing the fifo->in index counter
     */
    smp_wmb();
}

unsigned int __kfifo_in(struct __kfifo *fifo,
        const void *buf, unsigned int len)
{
    unsigned int l;

    l = kfifo_unused(fifo);
    if (len > l)
        len = l;

    kfifo_copy_in(fifo, buf, len, fifo->in);
    fifo->in += len;
    return len;
}

off传进来的时候，是fifo->in。
off &= fifo->mask;
这个操作有效利用size为2的整次幂，因为这个操作，后续的fifo->in增加，是不用考虑长度判断的。
fifo->in += len;

读数据

static void kfifo_copy_out(struct __kfifo *fifo, void *dst,
        unsigned int len, unsigned int off)
{
    unsigned int size = fifo->mask + 1;
    unsigned int esize = fifo->esize;
    unsigned int l;

    off &= fifo->mask;
    if (esize != 1) {
        off *= esize;
        size *= esize;
        len *= esize;
    }
    l = min(len, size - off);

    memcpy(dst, fifo->data + off, l);
    memcpy(dst + l, fifo->data, len - l);
    /*
     * make sure that the data is copied before
     * incrementing the fifo->out index counter
     */
    smp_wmb();
}

unsigned int __kfifo_out_peek(struct __kfifo *fifo,
        void *buf, unsigned int len)
{
    unsigned int l;

    l = fifo->in - fifo->out;
    if (len > l)
        len = l;

    kfifo_copy_out(fifo, buf, len, fifo->out);
    return len;
}

unsigned int __kfifo_out(struct __kfifo *fifo,
        void *buf, unsigned int len)
{
    len = __kfifo_out_peek(fifo, buf, len);
    fifo->out += len;
    return len;
}

读写的指针的操作是一样的，两者记录了内存的位置。仅仅在计算剩余空间时候有交叉比较。