memcached源码分析之hashtable

        memcached中hashtable部分的源码主要分布在assoc.h/c、hash.h/c中，总得来说代码比较简单，这里就稍微介绍一下。

        hashtable通常包括哈希函数和解决冲突的方法两个最主要的因素，memcached使用的哈希函数为Bob Jenkins在1996年发明的，定义位于hash.h中，实现在hash.c中，作者与2006年时提出另一个新的hash算法，其具有更快的速度（近2倍）和更大的吞吐量，详情请参照：http://burtleburtle.net/bob/hash/doobs.html，这里不进行介绍了。

        解决冲突的方法，memcached中采用了链地址法（或拉链法），从数据结构书中截取的一个采用链地址法(哈希函数为：key MOD 13)解决冲突的示意图：

 

        所不同的是，memcached中定义了primary_hashtable和old_hashtable，当hashtable的填装因子（memcached中硬编码为 3/2，无法确定如何定值的），assoc_maintenance_thread线程会将old_hashtable中的items以hash_bulk_move个buckets为单位，逐步移到primary_hashtable中。

        对外接口：

        // 完成primary_hashtable的初始化

        void assoc_init(void);   

        // 根据key和nkey查找对应的item

        item *assoc_find(const char *key, const size_t nkey); 

        // 将item插入hashtable中

        int assoc_insert(item *item); 

        // 从hashtable中删除key对应的item

        void assoc_delete(const char *key, const size_t nkey);

        // 下面两个函数分别为启动和结束hashtable维护的线程，如果不需要这个功能，可以不调用，就是会浪费primary_hashtable指针数组占用的内存资源

        int start_assoc_maintenance_thread(void);
        void stop_assoc_maintenance_thread(void);

        void do_assoc_move_next_bucket(void); // 函数没有实现

 

        实现部分：

         首先介绍几个用到的变量：

           static pthread_cond_t maintenance_cond; // 同步insert和hashtable维护线程的条件变量

           static unsigned int hashpower = 16;          
           #define hashsize(n) ((ub4)1<<(n))              //hashtable初始化大小设置为2^16
           #define hashmask(n) (hashsize(n)-1)         // 初始hashmask=0x1111 1111 1111 1111，用来将哈希函数计算的结果映射到hashsize域内，hashmask二进制值永远是hashpower位1的串

          static unsigned int hash_items = 0;            // hashtable中存在的item数量

          static bool expanding = false;                     // 是否正在扩展的flag

          static unsigned int expand_bucket = 0;      // 当前扩展的位置（old_hashtable中的索引）

[cpp] view plaincopy

1. // hashtable初始化  
2. void assoc_init(void) {  
3.     // 分配hashsize个buckets，每个bucket就是一个单向链表或null  
4.     primary_hashtable = calloc(hashsize(hashpower), sizeof(void *));  
5.     if (! primary_hashtable) {  
6.         fprintf(stderr, "Failed to init hashtable.\n");  
7.         exit(EXIT_FAILURE);  
8.     }  
9. }  

[cpp] view plaincopy

1. 根据key和nkey查找对应的item，不存在返回NULL  
2. item *assoc_find(const char *key, const size_t nkey) {  
3.     uint32_t hv = hash(key, nkey, 0);  
4.     item *it;  
5.     unsigned int oldbucket;  
6.   
7.     // 如果正在扩展中，且hash值映射到尚未移入新primary_hashtable中的item，在old_hashtable查找，  
8.     // 当前即将扩展索引expand_bucket位置的bucket，大于等于expand_bucket表示还在old_hashtable中  
9.     if (expanding &&  
10.         (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)  
11.     {  
12.         it = old_hashtable[oldbucket];  
13.     } else {  
14.         it = primary_hashtable[hv & hashmask(hashpower)];  
15.     }  
16.   
17.     item *ret = NULL;  
18.     int depth = 0;  
19.     while (it) {  
20.         // 遍历单向链表，查找相应的item  
21.         if ((nkey == it->nkey) && (memcmp(key, ITEM_key(it), nkey) == 0)) {  
22.             ret = it;  
23.             break;  
24.         }  
25.         it = it->h_next;  
26.         ++depth;  
27.     }  
28.     MEMCACHED_ASSOC_FIND(key, nkey, depth);  
29.     return ret;  
30. }  

[cpp] view plaincopy

1. /* returns the address of the item pointer before the key.  if *item == 0, 
2.    the item wasn't found */  
3.   
4. static item** _hashitem_before (const char *key, const size_t nkey) {  
5.     uint32_t hv = hash(key, nkey, 0);  
6.     item **pos;  
7.     unsigned int oldbucket;  
8.   
9.     if (expanding &&  
10.         (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)  
11.     {  
12.         pos = &old_hashtable[oldbucket];  
13.     } else {  
14.         pos = &primary_hashtable[hv & hashmask(hashpower)];  
15.     }  
16.   
17.     while (*pos && ((nkey != (*pos)->nkey) || memcmp(key, ITEM_key(*pos), nkey))) {  
18.         pos = &(*pos)->h_next;  
19.     }  
20.     return pos;  
21. }  

         比较函数assoc_find和_hashitem_before，发现两者只是返回值不同，assoc_find使用了item指针（item*），而_hashitem_before使用了item指针的指针（item**），查找过程都是一样的，_hashitem_before只是在assoc_delete中调用，返回指针的指针，方便直接修改指向的地址，从而删除此item；使用指针同样可以达到效果，但是必须修改指向的item的值，相比较前者效率更高。

[cpp] view plaincopy

1. /* Note: this isn't an assoc_update.  The key must not already exist to call this */  
2. // 上面英文注释已经说的很清楚了，插入的item的key必须在hashtable中不存在，否则assert错误  
3. int assoc_insert(item *it) {  
4.     uint32_t hv;  
5.     unsigned int oldbucket;  
6.   
7.     assert(assoc_find(ITEM_key(it), it->nkey) == 0);  /* shouldn't have duplicately named things defined */  
8.   
9.     // 计算hash值  
10.     hv = hash(ITEM_key(it), it->nkey, 0);  
11.     if (expanding &&  
12.         (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)  
13.     {  
14.         // 如果正在展开hashtable过程中，则将映射到expand_bucket之后的，  
15.         // 即还没有展开的bucket部分，继续放在old_hashtable中，  
16.         // 这样，当查询这些item时，从old_hashtable能够获得，参见assoc_find  
17.         it->h_next = old_hashtable[oldbucket];  
18.         old_hashtable[oldbucket] = it;  
19.     } else {  
20.         // 链表操作，放入链表起始位置  
21.         it->h_next = primary_hashtable[hv & hashmask(hashpower)];   
22.         primary_hashtable[hv & hashmask(hashpower)] = it;  
23.     }  
24.   
25.     hash_items++;  
26.     if (! expanding && hash_items > (hashsize(hashpower) * 3) / 2) { //3、2不知道怎么定的  
27.         assoc_expand(); // 启动扩展  
28.     }  
29.   
30.     MEMCACHED_ASSOC_INSERT(ITEM_key(it), it->nkey, hash_items);  
31.     return 1;  
32. }  

[cpp] view plaincopy

1. // 从hashtable中删除键值为key的item  
2. void assoc_delete(const char *key, const size_t nkey) {  
3.     // 返回值是键值为key的item的指针的指针，感觉before用的不太恰当，开始以为是指向它前面的一个item  
4.     item **before = _hashitem_before(key, nkey);  
5.   
6.     if (*before) {  
7.         item *nxt;  
8.         hash_items--;  
9.         /* The DTrace probe cannot be triggered as the last instruction 
10.          * due to possible tail-optimization by the compiler 
11.          */  
12.         MEMCACHED_ASSOC_DELETE(key, nkey, hash_items);  
13.         nxt = (*before)->h_next;  
14.         (*before)->h_next = 0;   /* probably pointless, but whatever. */  
15.         *before = nxt;  
16.         return;  
17.     }  
18.     /* Note:  we never actually get here.  the callers don't delete things 
19.        they can't find. */  
20.     assert(*before != 0);  
21. }  

[cpp] view plaincopy

1. // 扩展hashtable（这里只分配新的hashtable指针数组，设置相应的标志等，  
2. // 真正的扩展在assoc_maintenance_thread线程中完成）  
3. /* grows the hashtable to the next power of 2. */  
4. static void assoc_expand(void) {  
5.     old_hashtable = primary_hashtable;  
6.   
7.     // 扩大为原来的2倍  
8.     primary_hashtable = calloc(hashsize(hashpower + 1), sizeof(void *));  
9.     if (primary_hashtable) {  
10.         if (settings.verbose > 1)  
11.             fprintf(stderr, "Hash table expansion starting\n");  
12.         hashpower++;  
13.         expanding = true;  
14.         expand_bucket = 0;  
15.         pthread_cond_signal(&maintenance_cond); // 设置条件变量  
16.     } else {  
17.         primary_hashtable = old_hashtable;  
18.         /* Bad news, but we can keep running. */  
19.     }  
20. }  

[cpp] view plaincopy

1. // 创建hashtable维护线程  
2. int start_assoc_maintenance_thread() {  
3.     int ret;  
4.     // 如果环境变量MEMCACHED_HASH_BULK_MOVE设置，则使用此设置值  
5.     // 维护线程中，每次扩展的粒度(每次hash_bulk_move个buckets)  
6.     char *env = getenv("MEMCACHED_HASH_BULK_MOVE");  
7.     if (env != NULL) {  
8.         hash_bulk_move = atoi(env);  
9.         if (hash_bulk_move == 0) {  
10.             hash_bulk_move = DEFAULT_HASH_BULK_MOVE;  
11.         }  
12.     }  
13.     if ((ret = pthread_create(&maintenance_tid, NULL,  
14.                               assoc_maintenance_thread, NULL)) != 0) {  
15.         fprintf(stderr, "Can't create thread: %s\n", strerror(ret));  
16.         return -1;  
17.     }  
18.     return 0;  
19. }  

[cpp] view plaincopy

1. // 停止hashtable维护线程  
2. void stop_assoc_maintenance_thread() {  
3.     pthread_mutex_lock(&cache_lock);  
4.     do_run_maintenance_thread = 0;          // 结束标志  
5.     pthread_cond_signal(&maintenance_cond);  
6.     pthread_mutex_unlock(&cache_lock);  
7.   
8.     /* Wait for the maintenance thread to stop */  
9.     pthread_join(maintenance_tid, NULL);  
10. }  

[cpp] view plaincopy

1. #define DEFAULT_HASH_BULK_MOVE 1  
2. int hash_bulk_move = DEFAULT_HASH_BULK_MOVE;     // 数据转移粒度，即每次移动的bucket数量  
3.   
4. // hashtable维护线程(hashtable扩展使用)  
5. static void *assoc_maintenance_thread(void *arg) {  
6.   
7.     // 维护线程运行标志  
8.     while (do_run_maintenance_thread) {  
9.         int ii = 0;  
10.   
11.         /* Lock the cache, and bulk move multiple buckets to the new 
12.          * hash table. */  
13.         pthread_mutex_lock(&cache_lock);  // 互斥访问old_hashtable  
14.   
15.         // 每次扩展hash_bulk_move(这里定义为1)个buckets到新的hashtable中  
16.         for (ii = 0; ii < hash_bulk_move && expanding; ++ii) {  
17.             item *it, *next;  
18.             int bucket;  
19.   
20.             // expand_bucket: 当前正在扩展的bucket索引  
21.             for (it = old_hashtable[expand_bucket]; NULL != it; it = next) {  
22.                 next = it->h_next;  
23.   
24.                 bucket = hash(ITEM_key(it), it->nkey, 0) & hashmask(hashpower);  
25.                 it->h_next = primary_hashtable[bucket];  
26.                 primary_hashtable[bucket] = it;  
27.             }  
28.   
29.             old_hashtable[expand_bucket] = NULL;  
30.   
31.             // 到达old_hashtable结尾，则扩展结束  
32.             expand_bucket++;  
33.             if (expand_bucket == hashsize(hashpower - 1)) {  
34.                 expanding = false;  
35.                 free(old_hashtable);  
36.                 if (settings.verbose > 1)  
37.                     fprintf(stderr, "Hash table expansion done\n");  
38.             }  
39.         }  
40.           
41.         if (!expanding) {  
42.             /* We are done expanding.. just wait for next invocation */  
43.             pthread_cond_wait(&maintenance_cond, &cache_lock);  
44.         }  
45.   
46.         pthread_mutex_unlock(&cache_lock);  
47.     }  
48.     return NULL;  
49. }  

        查找的性能分析

        从hashtable的构建和查找过程可见：

        1.虽然hashtable在关键字和记录的存储位置之间建立了直接映像，但由于“冲突”的产生，hashtable的查找过程仍然是一个给定值和关键字相比较的过程，因此通常以平均查找长度作为衡量hashtable的度量。

        2.查找过程中与关键字进行比较的次数通常取决于三个因素：哈希函数，解决冲突的方法和哈希表的填装因子。

        哈希函数的好坏首先影响出现冲突的频繁程度，但是，对于“均匀”的哈希函数可以假定：不同的哈希函数对于同一组随机的关键字，产生冲突的可能性相同，因为一般情况下都假定哈希函数是均匀的，则不考虑它对平均查找长度的影响。

        采用不同的处理冲突的方法，它们的平均查找长度也不同，通常处理冲突方法相同的hashtable，其平均查找长度依赖于哈希表的装填因子：

               装填因子a = 表中填入的记录数/哈希表长度

         哈希表装填因子a表明哈希表的装满程度，一般越小发生冲突的可能性也就越小，反之，冲突可能性越大，查找过程中与关键字比较的次数越多。

        平均查找长度一般符合下式（来自《数据结构》书籍）：

        

        由此可见hashtable的平均查找长度是a的函数，而不是n的函数，由此，不管n多大，总可以选择一个合适的装填因子a以便将平均查找长度限定在一个范围内。

        程序中hashtable扩展时出现的3/2就是装填因子，不确定具体的值是怎么选取的。

        研究开源软件一方面是学习，另一方是应用，memcached的hashtable模块化设计非常好，只要稍加改动就可以应用了。

        第一个就是item结构体的定义，在hashtable内部只用到了item结构体的nkey，h_next字段和ITEM_key宏，保留前2个字段，并改写ITEM_key宏就可以忽略memcached的协议相关的设计；

        第二个就是pthread_mutex_t cache_lock定义，用于assoc_*函数的互斥操作hashtable；

        第三个是#define ENDIAN_LITTLE 1宏定义，由于hash函数采用了位操作，所以必须定义；

        其它的就是trace.h中定义的宏和一些基本变量的别名定义，如uint8_t，uint16_t，uint32_t等；

        最后一定要将上述的定义include进入hash.c和assoc.c中。