Cisco VPP：Bihash简介
Github-blog
CSDN
注意：本文使用的代码是2018.05.07提交的master分支上的code，其具体commitID是c22fcba177bad2c755fdb6d4d52f2a799eceaf34。
Bihash简介
Bihash（Bounded-index extensible hash），个人认为其特点可大致概括如下：
1、bihash支持8/16/24/40/48等类型，减少对于_mm_crc32_u32/16等的使用，提高效率的同时，避免引入GCC的bug；
2、bihash使用64bit Hash值，最多可以支持双层hash查找，第一层bucket查找，第二层page查找（后面具体分析其hash结构）；
3、bucket大小和page大小均为2的指数倍，因此hash查找时，仅需要位与操作即可；
4、采用working_copy，bucket操作区变换前后添加内存屏障，实现线程安全，使得bihash的查找无锁，修改时仍可进行查找；
5、采用freelists减少heap的碎片化，同时提高分配效率；
6、采用cache_lru的方式，提高查找效率。
Bihash的hash值计算
Bihash计算hash值时，对key进行hash。采用clib_crc32c或者clib_xxhash算法进行计算，x86中默认为clib_crc32c。key长度为8的倍数，即为了尽量使用_mm_crc32_u64函数，避免进一步使用_mm_crc32_u32等，出现GCC bug，同时加快了计算效率。得到的hash值为64bit，其结构如下：
后log2_nbuckets位用于表示所落buckets的index，中间log2_pages表示具体page的index，即bucket、page的双层hash。注意，当page级出现hash冲突的时候，该层可能被拉成线形。
Bihash数据结构简介
这里主要介绍三个数据结构，BVT (clib_bihash_value)， BVT (clib_bihash_bucket)，以及BVT (clib_bihash)。其中BVT是个宏，用于将其转换为对应的bihash类型，如_8_8，_16_8，其中第一个数字表示key的长度，第二个数字表示value的长度，单位字节，所以BVT (clib_bihash_value)阅读时可直接将其当作clib_bihash_value_8_8。
BVT (clib_bihash_value) 为存放若干kvp的数据结构，vpp中将其记作page，默认情况每个page中存放BIHASH_KVP_PER_PAGE（默认为4）个kvp。具体数据结构如下：
typedef struct BV (clib_bihash_value)
{ // bucket位置决定是kvp（*buckets）或者next_free（**free_list）
union
{
// 真正存放的kvp
BVT (clib_bihash_kv) kvp[BIHASH_KVP_PER_PAGE];
// 当该bucket被free后，通过next_free将释放的内存空间串联起来
struct BV (clib_bihash_value) * next_free;
};
} BVT (clib_bihash_value);
//kvp的结构体
typedef struct
{
u64 key; /**< the key */
u64 value; /**< the value */
} clib_bihash_kv_8_8_t;
BVT (clib_bihash_bucket)为bucket的数据结构，记录该bucket的详细信息。具体数据结构如下：
typedef struct
{
union
{
struct
{ // 距离整个bihash内存头部的偏移值
u32 offset;
// bihash内是否是page是否是hash的
u8 linear_search;
// 该bucket中page数目（log2后的）
u8 log2_pages;
// bucket内kvp的数目，当为0是进行free
i16 refcnt;
};
u64 as_u64;
};
// bucket的cache，用于提高查找效率，仅对频繁查找相同内容的才有较好效果==
#if BIHASH_KVP_CACHE_SIZE > 0
u16 cache_lru;
BVT (clib_bihash_kv) cache[BIHASH_KVP_CACHE_SIZE];
#endif
} BVT (clib_bihash_bucket);
BVT (clib_bihash)是bihash的数据结构，记录整个bihash表的全部信息，其具体数据结构如下：
typedef struct
{ // 这个目测是没有用到==， 如错，请指正^^
BVT (clib_bihash_value) * values;
// buckets指针
BVT (clib_bihash_bucket) * buckets;
// 修改时加锁
volatile u32 *writer_lock;
// 拷贝区，当进行修改操作时，相应bucket内数据会拷贝到working_copies中
BVT (clib_bihash_value) ** working_copies;
int *working_copy_lengths;
// 用于记录正在修改的bucket位置
BVT (clib_bihash_bucket) saved_bucket;
// buckets的数目
u32 nbuckets;
u32 log2_nbuckets;
u8 *name;
// cache命中情况记录
u64 cache_hits;
u64 cache_misses;
// 用于释放的内存碎片收集，便于下一次快速分配
BVT (clib_bihash_value) ** freelists;
// bihash的heap指针
void *mheap; //heap地址
// bihash对应的format函数，用于bihash打印
format_function_t *fmt_fn;
} BVT (clib_bihash);
Bihash具体实现
接下来我们对bihash的具体实现从init过程，add/del过程，search过程，以及free过程进行进行简单介绍。
init过程
在这一过程中init函数主要做四件事情：
输出话bihash结构体的各个参数；
创建bihash的heap；
在heap中创建bucket的vec；
分配write_lock内存；
针对每个bucket初始化缓存index序列(如果cache使能了) cache_lru (0 1 2 3 4）
完成初始化后，其在内存中的情况如下图所示：
void BV (clib_bihash_init)
(BVT (clib_bihash) * h, char *name, u32 nbuckets, uword memory_size)
{
void *oldheap;
int i;
// 各种参数初始化
nbuckets = 1 << (max_log2 (nbuckets));
h->name = (u8 *) name;
h->nbuckets = nbuckets;
h->log2_nbuckets = max_log2 (nbuckets);
h->cache_hits = 0;
h->cache_misses = 0;
// 通过mheap_alloc分配内存
if (h->mheap == NULL) /* Allow customerized mheap, by Jordy*/
h->mheap = mheap_alloc (0 /* use VM */ , memory_size);
// 对该内存进行初始化，包括初始化bucket指针的vec，lock等
oldheap = clib_mem_set_heap (h->mheap);
vec_validate_aligned (h->buckets, nbuckets - 1, CLIB_CACHE_LINE_BYTES);
h->writer_lock = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
CLIB_CACHE_LINE_BYTES);
h->writer_lock[0] = 0;
// 针对每个bucket 初始化cache
for (i = 0; i < nbuckets; i++)
BV (clib_bihash_reset_cache) (h->buckets + i);
clib_mem_set_heap (oldheap);
h->fmt_fn = NULL;
}
add/del过程
add/del过程我们以add和del，以及空桶和非空桶进行区别，分为四种情况进行讨论。
空桶add
1、空桶，即bucket->offset 为0;
2、为桶分配kvp存储空间(page), 先从h->freelists中查找，发现freelist为空，创建freelists的vec, 即*clib_bihash_value的vec；
3、创建pages，即BVT (clib_bihash_value)对象，并将bucket的offset设为该pages到heap->mheap的offset，将kvp放置于该page，并bucket的refcnt+=1。
其内存对应的结构如图所示：
空桶del
1、空桶，即bucket->offset 为0；
2、return -1即可。
非空桶add
1、找到对应的bucket,(b0)，将b0在h->working_copy[threads_index]中复制一份;
2、将b0 (即,bucket[0]->offset)设在working_copy，即图中b0(add时)，查找时，查找的是working_copy区，增加操作在h->saved_bucke区进行处理，保证线程安全;
a.不需要扩展的情况，即增加新kvp不会造成冲突：
1、完成增加后，b0重新指向h->saved_bucket。
b.需要扩展的情况：
扩展， pages×2, 内存从freelist中取，此时操作的区域是working_copy区(仅作为被复制的对应，不会影响查询)。
扩展分为两种，hash扩展和线性扩展
1.1、 hash扩展，原来的kvp，重新hash，落到new_bucket中，若hash的page发生碰撞，则hash扩展失败，释放new_pages，即将其挂在freelist中，进行b；
1.2、 线性扩展，原来的kvp按序落到new_bucket中， 标记new_pages-> linear_search=1；
2、扩展完成后，b0的offset为new_pages; 将kvp放置于new_pages，并bucket的refcnt+=1；
3、 释放h->saved_bucket， 即原来的pages，将该块存储空间的地址放入freelist[log2_pages]的表头。
扩展情况下，其非空桶add过程，内存对应的结构如下图所示：
非空桶del
1、找到对应的bucket,(b0)，将b0在h->working_copy[threads_index]中复制一份，将b0 (即,bucket[0]->offset)设在working_copy处，即查找时，查找的是working_copy区，删除操作在h->saved_bucke区进行处理；
2、查找key，hash或者linear查找，找到key，删除之（置为全1）；
3、h->saved_bucket.refcnt>1, 则自减1，b0.as_u64 = h->saved_bucket.as_u64 否则free该pages，将其放到freelists中。
int BV (clib_bihash_add_del)
(BVT (clib_bihash) * h, BVT (clib_bihash_kv) * add_v, int is_add)
{
u32 bucket_index;
BVT (clib_bihash_bucket) * b, tmp_b;
BVT (clib_bihash_value) * v, *new_v, *save_new_v, *working_copy;
int rv = 0;
int i, limit;
u64 hash, new_hash;
u32 new_log2_pages, old_log2_pages;
u32 thread_index = os_get_thread_index ();
int mark_bucket_linear;
int resplit_once;
// 计算kvp的hash值
hash = BV (clib_bihash_hash) (add_v);
// 桶定位
bucket_index = hash & (h->nbuckets - 1);
b = &h->buckets[bucket_index];
hash >>= h->log2_nbuckets;
tmp_b.linear_search = 0;
// 上锁
while (__sync_lock_test_and_set (h->writer_lock, 1))
;
/* First elt in the bucket? */
// 空桶情况
if (b->offset == 0)
{
if (is_add == 0)
{
rv = -1;
goto unlock;
}
v = BV (value_alloc) (h, 0);
*v->kvp = *add_v;
tmp_b.as_u64 = 0;
tmp_b.offset = BV (clib_bihash_get_offset) (h, v);
tmp_b.refcnt = 1;
b->as_u64 = tmp_b.as_u64;
goto unlock;
}
/* Note: this leaves the cache disabled */
/* 为保证线程安全，进行bucket的备份，复制到working_copy中，
* 将原bucket的指针指向这个working_copy中，
* h->saved_bucket指向原bucket的内存位置
* PS: working_copy中的per_thread没看出什么用，求解惑
*/
BV (make_working_copy) (h, b);
// 找到bucket具体对应的pages
v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
// 确定循环范围， hash则从指定page内直接找， linear则全桶找
limit = BIHASH_KVP_PER_PAGE;
v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
if (b->linear_search)
limit <<= b->log2_pages;
if (is_add)
{
/*
* For obvious (in hindsight) reasons, see if we're supposed to
* replace an existing key, then look for an empty slot.
*/
for (i = 0; i < limit; i++)
{ // key相同，更新原value值，结束
if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
{
clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
CLIB_MEMORY_BARRIER ();
/* Restore the previous (k,v) pairs */
b->as_u64 = h->saved_bucket.as_u64;
goto unlock;
}
}
for (i = 0; i < limit; i++)
{ // 找到第一个空solt（bihash中全1为空）
if (BV (clib_bihash_is_free) (&(v->kvp[i])))
{
clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
CLIB_MEMORY_BARRIER ();
b->as_u64 = h->saved_bucket.as_u64;
b->refcnt++;
goto unlock;
}
}
/* no room at the inn... split case... */
// 没有空solt，则需要进行扩展
}
else
//非空桶 del 情况
{
for (i = 0; i < limit; i++)
{ // 找key，然后删除之
if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
{
memset (&(v->kvp[i]), 0xff, sizeof (*(add_v)));
CLIB_MEMORY_BARRIER ();
if (PREDICT_TRUE (h->saved_bucket.refcnt > 1))
{
h->saved_bucket.refcnt -= 1;
b->as_u64 = h->saved_bucket.as_u64;
goto unlock;
}
else
{ // bucket已经空了，将其释放，即放入freelist中
tmp_b.as_u64 = 0;
goto free_old_bucket;
}
}
}
// 没找到==
rv = -3;
b->as_u64 = h->saved_bucket.as_u64;
goto unlock;
}
// 开始进行扩展
old_log2_pages = h->saved_bucket.log2_pages;
new_log2_pages = old_log2_pages + 1;
mark_bucket_linear = 0;
working_copy = h->working_copies[thread_index];
resplit_once = 0;
// 首先尝试哈希扩展，失败则进行线性扩展
new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
new_log2_pages);
if (new_v == 0)
{
try_resplit:
resplit_once = 1;
new_log2_pages++;
/* Try re-splitting. If that fails, fall back to linear search */
new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
new_log2_pages);
if (new_v == 0)
{
mark_linear:
new_log2_pages--;
/* pinned collisions, use linear search */
new_v =
BV (split_and_rehash_linear) (h, working_copy, old_log2_pages,
new_log2_pages);
mark_bucket_linear = 1;
}
}
/* Try to add the new entry */
save_new_v = new_v;
new_hash = BV (clib_bihash_hash) (add_v);
limit = BIHASH_KVP_PER_PAGE;
if (mark_bucket_linear)
limit <<= new_log2_pages;
new_hash >>= h->log2_nbuckets;
new_hash &= (1 << new_log2_pages) - 1;
new_v += mark_bucket_linear ? 0 : new_hash;
for (i = 0; i < limit; i++)
{
if (BV (clib_bihash_is_free) (&(new_v->kvp[i])))
{
clib_memcpy (&(new_v->kvp[i]), add_v, sizeof (*add_v));
goto expand_ok;
}
}
/* Crap. Try again */
BV (value_free) (h, save_new_v, new_log2_pages);
/*
* If we've already doubled the size of the bucket once,
* fall back to linear search now.
*/
if (resplit_once)
goto mark_linear;
else
goto try_resplit;
expand_ok:
tmp_b.log2_pages = new_log2_pages;
tmp_b.offset = BV (clib_bihash_get_offset) (h, save_new_v);
tmp_b.linear_search = mark_bucket_linear;
tmp_b.refcnt = h->saved_bucket.refcnt + 1;
free_old_bucket:
CLIB_MEMORY_BARRIER ();
b->as_u64 = tmp_b.as_u64;
v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
BV (value_free) (h, v, h->saved_bucket.log2_pages);
unlock:
BV (clib_bihash_reset_cache) (b);
BV (clib_bihash_unlock_bucket) (b);
CLIB_MEMORY_BARRIER ();
h->writer_lock[0] = 0;
return rv;
}
search过程
1、对key进行hash；
2、根据hash值找到对应的bucket，若支持cache，则在bucket[k]->cache中查找，找到return 0；
3、在b0:new_pages 中查找，根据bucket[0]-> linear_search，进行hash或者线型查找，找到，则更新bucket[0]->cache，循环bucket[0]->cache_lru，否则return -1。
int BV (clib_bihash_search)
(BVT (clib_bihash) * h,
BVT (clib_bihash_kv) * search_key, BVT (clib_bihash_kv) * valuep)
{
u64 hash;
u32 bucket_index;
BVT (clib_bihash_value) * v;
#if BIHASH_KVP_CACHE_SIZE > 0
BVT (clib_bihash_kv) * kvp;
#endif
BVT (clib_bihash_bucket) * b;
int i, limit;
ASSERT (valuep);
// 计算hash值
hash = BV (clib_bihash_hash) (search_key);
// 定位bucket
bucket_index = hash & (h->nbuckets - 1);
b = &h->buckets[bucket_index];
if (b->offset == 0)
return -1;
// 若cache enable了 则先从cache中进行查找
#if BIHASH_KVP_CACHE_SIZE > 0
/* Check the cache, if currently enabled */
if (PREDICT_TRUE ((b->cache_lru & (1 << 15)) == 0))
{
limit = BIHASH_KVP_CACHE_SIZE;
kvp = b->cache;
for (i = 0; i < limit; i++)
{
if (BV (clib_bihash_key_compare) (kvp[i].key, search_key->key))
{
*valuep = kvp[i];
h->cache_hits++;
return 0;
}
}
}
#endif
hash >>= h->log2_nbuckets;
// 找到bucket具体对应的pages
v = BV (clib_bihash_get_value) (h, b->offset);
// 确定查找范围
limit = BIHASH_KVP_PER_PAGE;
// hash从指定page开始查找，否则从头开始找
v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
if (PREDICT_FALSE (b->linear_search))
limit <<= b->log2_pages;
// 循环查找
for (i = 0; i < limit; i++)
{
if (BV (clib_bihash_key_compare) (v->kvp[i].key, search_key->key))
{
*valuep = v->kvp[i];
// 更新cache
#if BIHASH_KVP_CACHE_SIZE > 0
u8 cache_slot;
/* Shut off the cache */
if (BV (clib_bihash_lock_bucket) (b))
{
cache_slot = BV (clib_bihash_get_lru) (b);
b->cache[cache_slot] = v->kvp[i];
BV (clib_bihash_update_lru) (b, cache_slot);
/* Reenable the cache */
BV (clib_bihash_unlock_bucket) (b);
h->cache_misses++;
}
#endif
return 0;
}
}
return -1;
}
free过程
释放mheap， munmap(h->mheap);
清空结构体，memset (h, 0, sizeof (*h))。
void BV (clib_bihash_free) (BVT (clib_bihash) * h)
{ // 释放内存
mheap_free (h->mheap);
// 清空bihash结构体
memset (h, 0, sizeof (*h));
}
以上～