对dpdk的rte_ring实现原理和代码分析
对dpdk的rte_ring实现原理和代码分析
前言
dpdk的rte_ring是借鉴了linux内核的kfifo实现原理，这里统称为无锁环形缓冲队列。
环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的数据。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。
在通常情况下，环形缓冲区的读用户仅仅会影响读指针， 而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。
但是，如果有多个读写用户访问环形缓冲区， 那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。 具体来讲，如果有多个写用户和一个读用户，那么只是需要给写用户加锁进行保护；反之，如果有一个写用户和多个读用户，那么只是需要对读用户进行加锁保护。
所以这里说它是无锁，其实我是持保留态度的，只有在单生产单消费的场景下，才能说它是正在的无锁，多生产或者多消费的场景下，必须要加锁来保护才行，kfifo提供了自旋锁保护，而dpdk提供了原子锁cas来保护。
备注：dpdk版本18.11， 以下图片来自dpdk的prog_guide-master.pdf. dpdk官网编程指南手册
本人从dpdk移植了ring实现到自己的github里面 https://github.com/air5005/usg/tree/master/libs/libring 有兴趣的可以参考
rte_ring的实现原理
单生产者入队
当只有一个生产者增加一个对象到环形缓冲区，这个时候只有一个生产者头和尾（prod_head和prod_tail）被修改。这个初始状态是有一个生产者的头和尾指向了相同的位置。
- 第一步
将r->prod.head保存到变量的prod_head, prod_next = prod_head + n，如下图
（在代码里面的话，临时变量prod_head = old_head. prod_next = new_head）
- 第二步
修改prod_head去指向prod_next指向的位置。 指向新增加对象的指针被拷贝到ring（obj4）。
- 第三步
一旦这个对象被增加到环形缓冲区中，prod_tail将要被修改成prod_head指向的位置。 至此， 这入队操作完成了。
单消费者出队
当只有一个消费者出队操作在环形缓冲区，这个时候只有一个消费者头和尾（cons_head和cons_tail）被修改并且这只有一个消费者。初始状态是一个消费者的头和尾指向了相同的位置。
- 第一步
首先，暂时将消费者的头索引和生产者的尾部索引交给临时变量，并且将cons_next指向表中下一个对象，如果在这环形缓冲区没有足够的对象，将返回一个错误。
- 第二步
第二步是修改cons_head去指向cons_next指向的位置，并且指向出队对象（obj1）的指针被拷贝到一个临时用户定义的指针中。
- 第三步
最后，cons_tail被修改成指向cons_head指向的位置。至此，单消费者的出队操作完成了。
多生产者入队
- 初始状态下，环形缓冲区的状态是prod_head和prod_tail都指向同一个位置，这个时候core1和core2都保存prod_head到各自的临时变量，如果core1和core2是同时执行这个动作的话，他们的临时变量保存的prod_head和prod_next应该完全相同。如下图所示：
- 在core1上面执行cas，比较prod_head和临时变量里面的prod_head，如果相同则把prod_head移动到prod_next，这个时候再core2也是执行完全一下的动作，由于使用的是cas，原子操作的比较和设置，只能有一个是成功的，这里如果是core1成功的话，那么core2的cas就是失败的。
所以这个时候ring里面的prod_head移动到core1的prod_next这个位置了并填充obj4到ring里面。
- core2在执行第一次cas的时候失败了，这个时候再执行一次，重新update临时变量里面的prod_head和prod_next,由于core1已经cas成功，那么这个时候core2 update到的这两个值就相应的更新了，这个时候再执行cas，则能成功，所以这个时候ring里面的prod_head移动到core2的prod_next这个位置并填充obj5到ring里面。
- core1在更新完ring的prod_head和obj后，这个时候临时变量里面保存的prod_head和prod_next是固定的，这个时候需要借助这两个值，当ring里面的prod_tail == prod_head（临时变量）的时候，即可直接更新prod_tail = prod_next, 这里的更新tail条件是唯一的，否则不能更新。
- core2在更新完ring的prod_head和obj后，这个时候临时变量里面保存的prod_head和prod_next是固定的，同理，core2也需要判断当ring里面的prod_tail == prod_head（临时变量）的时候，即可直接更新prod_tail = prod_next, 如果这个时候core1还没有update这个tail值的话，core2需要一直等待，知道core1更新了tail值位置才行(因为core1更新head值在core2之前，所以core1更新tail值也需要在core2之前)。
多消费者出队
多消费者出列和多生产者入列的实现逻辑大致相同，也是先更新cons head、存储obj、最后更新cons tail，具体这里就不一一罗列出来了，下面我们看具体代码的实现。
代码分析
rte_ring 结构体
struct rte_ring {
/*
* Note: this field kept the RTE_MEMZONE_NAMESIZE size due to ABI
* compatibility requirements, it could be changed to RTE_RING_NAMESIZE
* next time the ABI changes
*/
char name[RTE_MEMZONE_NAMESIZE] __rte_cache_aligned; /**< Name of the ring. */
int flags; /**< Flags supplied at creation. */
const struct rte_memzone *memzone;
/**< Memzone, if any, containing the rte_ring */
uint32_t size; /**< Size of ring. */
uint32_t mask; /**< Mask (size-1) of ring. */
uint32_t capacity; /**< Usable size of ring */
char pad0 __rte_cache_aligned; /**< empty cache line */
/** Ring producer status. */
struct rte_ring_headtail prod __rte_cache_aligned;
char pad1 __rte_cache_aligned; /**< empty cache line */
/** Ring consumer status. */
struct rte_ring_headtail cons __rte_cache_aligned;
char pad2 __rte_cache_aligned; /**< empty cache line */
};
struct rte_ring结构体主要包含一个生产者prod和一个消费者cons，还有ring本身支持加入obj数量的容量大小，
这个过程struct rte_ring、struct rte_ring_headtail都设置了cache line对其，防止出现cache miss的情况.
struct rte_ring_headtail {
volatile uint32_t head; /**< Prod/consumer head. */
volatile uint32_t tail; /**< Prod/consumer tail. */
uint32_t single; /**< True if single prod/cons */
};
rte_ring_headtail 实现了head和tail，环形链表两个游标，还有一个single，标示是单操作者还是多操作者.
创建ring rte_ring_create
struct rte_ring *
rte_ring_create(const char *name, unsigned count, int socket_id,
unsigned flags)
{
char mz_name[RTE_MEMZONE_NAMESIZE];
struct rte_ring *r;
struct rte_tailq_entry *te;
const struct rte_memzone *mz;
ssize_t ring_size;
int mz_flags = 0;
struct rte_ring_list* ring_list = NULL;
const unsigned int requested_count = count;
int ret;
/* 获取rte_ring_tailq链表，用来保存ring，方便定位查看系统存在的ring */
ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
/* 判断flags表示是否设置了RING_F_EXACT_SZ, RING_F_EXACT_SZ的话，内部会
把count做一个调整，调整为2的指数次方，否则要求外面带进来的count本身就是
2的指数次方*/
/* for an exact size ring, round up from count to a power of two */
if (flags & RING_F_EXACT_SZ)
count = rte_align32pow2(count + 1);
/* 根据count获取ring需要的大小,
ring_size的大小计算如下
ring_size = sizeof(struct rte_ring) + count * sizeof(void *);
ring_size = RTE_ALIGN(ring_size, RTE_CACHE_LINE_SIZE);
即等于sizeof(struct rte_ring)+count个指针的大小，所以ring用来保存的
数据就是指针.
*/
ring_size = rte_ring_get_memsize(count);
if (ring_size < 0) {
rte_errno = ring_size;
return NULL;
}
/* 填充一下ring的名字,RTE_RING_MZ_PREFIX+name */
ret = snprintf(mz_name, sizeof(mz_name), "%s%s",
RTE_RING_MZ_PREFIX, name);
if (ret < 0 || ret >= (int)sizeof(mz_name)) {
rte_errno = ENAMETOOLONG;
return NULL;
}
/* 申请一下rte_ring_tailq的节点，挂到rte_ring_tailq尾部 */
te = rte_zmalloc("RING_TAILQ_ENTRY", sizeof(*te), 0);
if (te == NULL) {
RTE_LOG(ERR, RING, "Cannot reserve memory for tailq\n");
rte_errno = ENOMEM;
return NULL;
}
/* 读写锁保护tailq操作 */
rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
/* reserve a memory zone for this ring. If we can't get rte_config or
* we are secondary process, the memzone_reserve function will set
* rte_errno for us appropriately - hence no check in this this function */
mz = rte_memzone_reserve_aligned(mz_name, ring_size, socket_id,
mz_flags, __alignof__(*r));
if (mz != NULL) {
r = mz->addr;
/* no need to check return value here, we already checked the
* arguments above */
/* 对ring里面变量做初始化操作 */
rte_ring_init(r, name, requested_count, flags);
te->data = (void *) r;
r->memzone = mz;
TAILQ_INSERT_TAIL(ring_list, te, next);
} else {
r = NULL;
RTE_LOG(ERR, RING, "Cannot reserve memory\n");
rte_free(te);
}
rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
return r;
}
int
rte_ring_init(struct rte_ring *r, const char *name, unsigned count,
unsigned flags)
{
int ret;
/* compilation-time checks */
RTE_BUILD_BUG_ON((sizeof(struct rte_ring) &
RTE_CACHE_LINE_MASK) != 0);
RTE_BUILD_BUG_ON((offsetof(struct rte_ring, cons) &
RTE_CACHE_LINE_MASK) != 0);
RTE_BUILD_BUG_ON((offsetof(struct rte_ring, prod) &
RTE_CACHE_LINE_MASK) != 0);
/* init the ring structure */
memset(r, 0, sizeof(*r));
ret = snprintf(r->name, sizeof(r->name), "%s", name);
if (ret < 0 || ret >= (int)sizeof(r->name))
return -ENAMETOOLONG;
r->flags = flags;
r->prod.single = (flags & RING_F_SP_ENQ) ? __IS_SP : __IS_MP;
r->cons.single = (flags & RING_F_SC_DEQ) ? __IS_SC : __IS_MC;
if (flags & RING_F_EXACT_SZ) {
r->size = rte_align32pow2(count + 1);
r->mask = r->size - 1;
r->capacity = count;
} else {
if ((!POWEROF2(count)) || (count > RTE_RING_SZ_MASK)) {
RTE_LOG(ERR, RING,
"Requested size is invalid, must be power of 2, and not exceed the size limit %u\n",
RTE_RING_SZ_MASK);
return -EINVAL;
}
r->size = count;
r->mask = count - 1;
r->capacity = r->mask;
}
r->prod.head = r->cons.head = 0;
r->prod.tail = r->cons.tail = 0;
return 0;
}
具体创建一个ring的函数流程如上，具体我在代码里面加了每个操作的注释，主要分为以下几个流程：
- 确定count数量，需要满足是2的指数次方
- 申请内存，具体ring size=sizeof(struct rte_ring) + count * sizeof(void *)，通过rte_memzone_reserve_aligned申请内存
- 申请tailq节点，加入rte_ring_tailq链表里面，用来保存ring，方便定位查看系统存在的ring
- 使用rte_ring_init初始化ring结构体
入队列
入队列操作主要分为三个流程
- 更新r->prod.head
static __rte_always_inline unsigned int
__rte_ring_move_prod_head(struct rte_ring *r, unsigned int is_sp,
unsigned int n, enum rte_ring_queue_behavior behavior,
uint32_t *old_head, uint32_t *new_head,
uint32_t *free_entries)
{
const uint32_t capacity = r->capacity;
unsigned int max = n;
int success;
do {
/* Reset n to the initial burst count */
n = max;
*old_head = r->prod.head;
/* add rmb barrier to avoid load/load reorder in weak
* memory model. It is noop on x86
*/
rte_smp_rmb();
/*
* The subtraction is done between two unsigned 32bits value
* (the result is always modulo 32 bits even if we have
* *old_head > cons_tail). So 'free_entries' is always between 0
* and capacity (which is < size).
*/
/* 计算当前可用容量，
cons.tail是小于等于prod.head, 所以r->cons.tail - *old_head得到一个
负数，capacity减这个差值就得到剩余的容量 */
*free_entries = (capacity + r->cons.tail - *old_head);
/* check that we have enough room in ring */
if (unlikely(n > *free_entries))
n = (behavior == RTE_RING_QUEUE_FIXED) ?
0 : *free_entries;
if (n == 0)
return 0;
/* 新头的位置 */
*new_head = *old_head + n;
/* 如果是单生产者，直接更新r->prod.head即可，不需要加锁 */
if (is_sp)
r->prod.head = *new_head, success = 1;
/* 如果是多生产者，需要使用cmpset比较，如果&r->prod.head == *old_head
则&r->prod.head = *new_head
否则重新循环，获取新的*old_head = r->prod.head，知道成功位置*/
else
success = rte_atomic32_cmpset(&r->prod.head,
*old_head, *new_head);
} while (unlikely(success == 0));
return n;
}
- 将obj存放到r指定位置
/* r经过__rte_ring_move_prod_head处理后，r->prod.head已经移动到想要的位置
&r[1]是数据的位置, prod_head是旧的r->prod.head，obj_table是要加入的obj
ENQUEUE_PTRS的处理目的是把对应个数的obj存放到r的指定位置里面，由于
obj在r里面坑已经站好，所以这里只要按指定填充即可，不需要加锁
*/
#define ENQUEUE_PTRS(r, ring_start, prod_head, obj_table, n, obj_type) do { \
unsigned int i; \
const uint32_t size = (r)->size; \
uint32_t idx = prod_head & (r)->mask; \
obj_type *ring = (obj_type *)ring_start; \
if (likely(idx + n < size)) { \
for (i = 0; i < (n & ((~(unsigned)0x3))); i+=4, idx+=4) { \
ring[idx] = obj_table[i]; \
ring[idx+1] = obj_table[i+1]; \
ring[idx+2] = obj_table[i+2]; \
ring[idx+3] = obj_table[i+3]; \
} \
switch (n & 0x3) { \
case 3: \
ring[idx++] = obj_table[i++]; /* fallthrough */ \
case 2: \
ring[idx++] = obj_table[i++]; /* fallthrough */ \
case 1: \
ring[idx++] = obj_table[i++]; \
} \
} else { \
for (i = 0; idx < size; i++, idx++)\
ring[idx] = obj_table[i]; \
for (idx = 0; i < n; i++, idx++) \
ring[idx] = obj_table[i]; \
} \
} while (0)
- 更新r->prod.tail
static __rte_always_inline void
update_tail(struct rte_ring_headtail *ht, uint32_t old_val, uint32_t new_val,
uint32_t single, uint32_t enqueue)
{
if (enqueue)
rte_smp_wmb();
else
rte_smp_rmb();
/*
* If there are other enqueues/dequeues in progress that preceded us,
* we need to wait for them to complete
*/
/* 如果是多生产者流程，这里需要等待tail等于我们想要的old val
因为是多生产者，这里需要等其他prod把这个tail update，这里的
能成立*/
if (!single)
while (unlikely(ht->tail != old_val))
rte_pause();
/* 更新tail */
ht->tail = new_val;
}
完整函数如下：
static __rte_always_inline unsigned int
__rte_ring_do_enqueue(struct rte_ring *r, void * const *obj_table,
unsigned int n, enum rte_ring_queue_behavior behavior,
unsigned int is_sp, unsigned int *free_space)
{
uint32_t prod_head, prod_next;
uint32_t free_entries;
/* 更新r->prod.head指针操作 */
n = __rte_ring_move_prod_head(r, is_sp, n, behavior,
&prod_head, &prod_next, &free_entries);
if (n == 0)
goto end;
/* r经过__rte_ring_move_prod_head处理后，r->prod.head已经移动到想要的位置
&r[1]是数据的位置, prod_head是旧的r->prod.head，obj_table是要加入的obj
ENQUEUE_PTRS的处理目的是把对应个数的obj存放到r的指定位置里面，由于
obj在r里面坑已经站好，所以这里只要按指定填充即可，不需要加锁
*/
ENQUEUE_PTRS(r, &r[1], prod_head, obj_table, n, void *);
/* 更新r->prod.tail指针操作 */
update_tail(&r->prod, prod_head, prod_next, is_sp, 1);
end:
if (free_space != NULL)
*free_space = free_entries - n;
return n;
}
出队列
出队列操作流程和入队列流程基本一致，也是分为三部分，不过操作的是cons指针
-
更新r->cons.head
-
将obj从r指定位置移除
-
更新r->cons.tail
static __rte_always_inline unsigned int
__rte_ring_do_dequeue(struct rte_ring *r, void **obj_table,
unsigned int n, enum rte_ring_queue_behavior behavior,
unsigned int is_sc, unsigned int *available)
{
uint32_t cons_head, cons_next;
uint32_t entries;
/* 更新r->cons.head */
n = __rte_ring_move_cons_head(r, (int)is_sc, n, behavior,
&cons_head, &cons_next, &entries);
if (n == 0)
goto end;
DEQUEUE_PTRS(r, &r[1], cons_head, obj_table, n, void *);
/* 更新r->cons.tail */
update_tail(&r->cons, cons_head, cons_next, is_sc, 0);
end:
if (available != NULL)
*available = entries - n;
return n;
}
ring衍生出来的api
rte_ring_mp_enqueue_bulk 多生产者批量入队列，数量要求固定
rte_ring_sp_enqueue_bulk 单生产者批量入队列，数量要求固定
rte_ring_enqueue_bulk 生产者批量入队列，同时支持单生产和多生产，数量要求固定
rte_ring_mp_enqueue 多生产者单次入队列
rte_ring_sp_enqueue 单生产者单次入队列
rte_ring_enqueue 生产者单次入队列，同时支持单生产和多生产
rte_ring_mc_dequeue_bulk 多消费者批量出队列，数量要求固定
rte_ring_sc_dequeue_bulk 单消费者批量出队列，数量要求固定
rte_ring_dequeue_bulk 消费者批量出队列，同时支持单消费和多消费，数量要求固定
rte_ring_mc_dequeue 多消费者单次出队列
rte_ring_sc_dequeue 单消费者单次出队列
rte_ring_dequeue 消费者单次出队列，同时支持单消费和多消费
rte_ring_count 已经加入的obj数量
rte_ring_free_count 剩余容量
rte_ring_full 判断ring是否已经满了，没有容量了
rte_ring_empty 判断ring是否为空
rte_ring_get_size 获取ring的大小
rte_ring_get_capacity 获取ring的最大容量
rte_ring_list_dump 打印系统所有ring的信息
rte_ring_lookup 根据名字查找ring是否存在
rte_ring_mp_enqueue_burst 多生产者批量入队列，如果ring可用容量不够，加入最大能加入的数量
rte_ring_sp_enqueue_burst 单生产者批量入队列，如果ring可用容量不够，加入最大能加入的数量
rte_ring_enqueue_burst 生产者批量入队列，同时支持单生产和多生产，如果ring可用容量不够，加入最大能加入的数量
rte_ring_mc_dequeue_burst 多消费者批量出队列，如果ring可用容量不够，加入最大能加入的数量
rte_ring_sc_dequeue_burst 单消费者批量出队列，如果ring可用容量不够，加入最大能加入的数量
rte_ring_dequeue_burst 消费者批量出队列，同时支持单消费和多消费，如果ring可用容量不够，加入最大能加入的数量
已知问题
rte_ring是不可抢占的，如果遇到多任务抢占的情况下，可能导致死锁。
- 在同一个ring执行多生产者入队列操作的时候，该pthread不能被在同一环上执行多生产者队列的其他pthread抢占
- 在同一个ring执行多消费者出队列操作的时候，该pthread不能被另一个在同一环上执行多消费者出队列操作的pthread抢占
如果出现以上两种情况，可能会导致第二个pthread旋转，直到第一个pthread再次被调度。甚至如果第一个pthread被具有更高优先级的上下文抢占，它甚至可能导致死锁。
使用ring的时候，需要谨慎考虑任务的抢占，单生产和单消费都是支持抢占的，但是多生产或者多消费在抢占情况下会有概率出现死锁。