memcached源码学习-hashtable

http://blog.csdn.net/tankles/article/details/7032756

  今天来介绍memcached中hashtable部分的源码，hash部分的源码主要分布在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中。

posted @ 2012-05-17 19:47  balaamwe  阅读(420)  评论(0)  编辑  收藏  举报