Memcached源码分析

Memcached源码分析之Hash表扩容

Hash表是Memcached里面最重要的结构之一，其采用链接法来处理Hash冲突，当Hash表中的项太多时，也就是Hash冲突比较高的时候，Hash表的遍历就脱变成单链表，此时为了提供Hash的性能，Hash表需要扩容，Memcached的扩容条件是当表中元素个数超过Hash容量的1.5倍时就进行扩容，扩容过程由独立的线程来完成，扩容过程中会采用2个Hash表，将老表中的数据通过Hash算法映射到新表中，每次移动的桶的数目可以配置，默认是每次移动老表中的1个桶。

 //hash表中增加元素
 int assoc_insert(item *it, const uint32_t hv) {
     unsigned int oldbucket;
     //如果已经进行扩容且目前进行扩容还没到需要插入元素的桶，则将元素添加到旧桶中
     if (expanding &&(oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)
     {
         it->h_next = old_hashtable[oldbucket];//添加元素
         old_hashtable[oldbucket] = it;
     } else {//如果没扩容，或者扩容已经到了新的桶中，则添加元素到新表中
         it->h_next = primary_hashtable[hv & hashmask(hashpower)];//添加元素
         primary_hashtable[hv & hashmask(hashpower)] = it;
     }

     hash_items++;//元素数目+1
     //还没开始扩容，且表中元素个数已经超过Hash表容量的1.5倍
     if (! expanding && hash_items > (hashsize(hashpower) * 3) / 2) {
         assoc_start_expand();//唤醒扩容线程
     }

     MEMCACHED_ASSOC_INSERT(ITEM_key(it), it->nkey, hash_items);
     return 1;
 }
 //唤醒扩容线程
 static void assoc_start_expand(void) {
     if (started_expanding)
         return;
     started_expanding = true;
     pthread_cond_signal(&maintenance_cond);//唤醒信号量
 }
 //启动扩容线程，扩容线程在main函数中会启动，启动运行一遍之后会阻塞在条件变量maintenance_cond上面，插入元素超过规定，唤醒条件变量
 static void *assoc_maintenance_thread(void *arg) {
     //do_run_maintenance_thread的值为1，即该线程持续运行
     while (do_run_maintenance_thread) {
         int ii = 0;

         item_lock_global();//加Hash表的全局锁
         mutex_lock(&cache_lock);//加cache_lock锁
         //执行扩容时，每次按hash_bulk_move个桶来扩容
         for (ii = 0; ii < hash_bulk_move && expanding; ++ii) {
             item *it, *next;
             int bucket;
             //老表每次移动一个桶中的一个元素
             for (it = old_hashtable[expand_bucket]; NULL != it; it = next) {
                 next = it->h_next;//要移动的下一个元素

                 bucket = hash(ITEM_key(it), it->nkey, 0) & hashmask(hashpower);//按新的Hash规则进行定位
                 it->h_next = primary_hashtable[bucket];//挂载到新的Hash表中
                 primary_hashtable[bucket] = it;
             }

             old_hashtable[expand_bucket] = NULL;//旧表中的这个Hash桶已经按新规则完成了扩容

             expand_bucket++;//老表中的桶计数+1
             if (expand_bucket == hashsize(hashpower - 1)) {//hash表扩容结束,expand_bucket从0开始,一直递增
                 expanding = false;//修改扩容标志
                 free(old_hashtable);//释放老的表结构
                 STATS_LOCK();//更新一些统计信息
                 stats.hash_bytes -= hashsize(hashpower - 1) * sizeof(void *);
                 stats.hash_is_expanding = 0;
                 STATS_UNLOCK();
                 if (settings.verbose > 1)
                     fprintf(stderr, "Hash table expansion done\n");
             }
         }

         mutex_unlock(&cache_lock);//释放cache_lock锁
         item_unlock_global();//释放Hash表的全局锁

         if (!expanding) {//完成扩容
             //修改Hash表的锁类型，此时锁类型更新为分段锁，默认是分段锁，在进行扩容时，改为全局锁
             switch_item_lock_type(ITEM_LOCK_GRANULAR);
             slabs_rebalancer_resume();//释放用于扩容的锁
             /* We are done expanding.. just wait for next invocation */
             mutex_lock(&cache_lock);//加cache_lock锁，保护条件变量
             started_expanding = false;//修改扩容标识
             pthread_cond_wait(&maintenance_cond, &cache_lock);//阻塞扩容线程
             mutex_unlock(&cache_lock);
             slabs_rebalancer_pause();//加用于扩容的锁
             switch_item_lock_type(ITEM_LOCK_GLOBAL);//修改锁类型为全局锁
             mutex_lock(&cache_lock);//临时用来实现临界区
             assoc_expand();//执行扩容
             mutex_unlock(&cache_lock);
         }
     }
     return NULL;
 }
 //按2倍容量扩容Hash表
 static void assoc_expand(void) {
     old_hashtable = primary_hashtable;//old_hashtable指向主Hash表

     primary_hashtable = calloc(hashsize(hashpower + 1), sizeof(void *));//申请新的空间
     if (primary_hashtable) {//空间申请成功
         if (settings.verbose > 1)
             fprintf(stderr, "Hash table expansion starting\n");
         hashpower++;//hash等级+1
         expanding = true;//扩容标识打开
         expand_bucket = 0;
         STATS_LOCK();//更新全局统计信息
         stats.hash_power_level = hashpower;
         stats.hash_bytes += hashsize(hashpower) * sizeof(void *);
         stats.hash_is_expanding = 1;
         STATS_UNLOCK();
     } else {//空间事情失败
         primary_hashtable = old_hashtable;
     }
 }

Memcached源码分析之item结构

item是Memcached中抽象实际数据的结构，我们分析下item的一些特性，便于后续Memcached的其他特性分析。

 typedef struct _stritem {
     struct _stritem *next;//item在slab中存储时，是以双链表的形式存储的,next即后向指针
     struct _stritem *prev;//prev为前向指针
     struct _stritem *h_next;//Hash桶中元素的链接指针
     rel_time_t      time; //最近访问时间
     rel_time_t      exptime;//过期时间
     int             nbytes;//数据大小
     unsigned short  refcount;//引用次数
     uint8_t         nsuffix;    //不清楚什么意思?
     uint8_t         it_flags;   //不清楚什么意思?
     uint8_t         slabs_clsid;//标记item属于哪个slabclass下
     uint8_t         nkey;       //key的长度
     union {
         uint64_t cas;
         char end;
     } data[];//真实的数据信息
 } item;

其结构图如下所示：

即Item由两部分组成，item的属性信息和item的数据部分，属性信息解释如上，数据部分包括cas，key和真实的value信息，item在内存中的存储形式如下：

这个图画出了部分结构，还有Hash表的结构没有画出。

这里大概介绍了item的一些信息，后面我们会分析item插入Hash表等信息。

注：本篇博客的图片摘自：http://kenby.iteye.com/blog/1423989

                                               http://www.nosqlnotes.net/archives/222

Memcached源码阅读之get过程

我们在前面分析过，Memcached从网络读取完数据，解析数据，如果是get操作，则执行get操作，下面我们分析下get操作的流程。

 //根据key信息和key的长度信息读取数据
 item *item_get(const char *key, const size_t nkey) {
     item *it;
     uint32_t hv;
     hv = hash(key, nkey, 0);//获得分段锁信息，如果未进行扩容，则item的hash表是多个hash桶共用同一个锁，即是分段的锁
     item_lock(hv);//执行分段加锁
     it = do_item_get(key, nkey, hv);//执行get操作
     item_unlock(hv);//释放锁
     return it;
 }
 //执行分段加锁
 void item_lock(uint32_t hv) {
     uint8_t *lock_type = pthread_getspecific(item_lock_type_key);
     if (likely(*lock_type == ITEM_LOCK_GRANULAR)) {
         mutex_lock(&item_locks[(hv & hashmask(hashpower)) % item_lock_count]);//执行分段加锁
     } else {//如果在扩容过程中
         mutex_lock(&item_global_lock);
     }
 }
 //执行分段解锁
 void item_unlock(uint32_t hv) {
     uint8_t *lock_type = pthread_getspecific(item_lock_type_key);
     if (likely(*lock_type == ITEM_LOCK_GRANULAR)) {
         mutex_unlock(&item_locks[(hv & hashmask(hashpower)) % item_lock_count]);//释放分段锁
     } else {//如果在扩容过程中
         mutex_unlock(&item_global_lock);
     }
 }
 //执行读取操作
 item *do_item_get(const char *key, const size_t nkey, const uint32_t hv) {
     item *it = assoc_find(key, nkey, hv);//从Hash表中获取相应的结构
     if (it != NULL) {
         refcount_incr(&it->refcount);//item的引用次数+1
         if (slab_rebalance_signal && //如果正在进行slab调整，且该item是调整的对象
             ((void *)it >= slab_rebal.slab_start && (void *)it < slab_rebal.slab_end)) {
             do_item_unlink_nolock(it, hv);//将item从hashtable和LRU链中移除
             do_item_remove(it);//删除item
             it = NULL;//置为空
         }
     }
     int was_found = 0;
     //打印调试信息
     if (settings.verbose > 2) {
         if (it == NULL) {
             fprintf(stderr, "> NOT FOUND %s", key);
         } else {
             fprintf(stderr, "> FOUND KEY %s", ITEM_key(it));
             was_found++;
         }
     }

     if (it != NULL) {
         //判断Memcached初始化是否开启过期删除机制，如果开启，则执行删除相关操作
         if (settings.oldest_live != 0 && settings.oldest_live <= current_time &&
             it->time <= settings.oldest_live) {
             do_item_unlink(it, hv);//将item从hashtable和LRU链中移除
             do_item_remove(it);//删除item
             it = NULL;
             if (was_found) {
                 fprintf(stderr, " -nuked by flush");
             }
         //判断item是否过期
         } else if (it->exptime != 0 && it->exptime <= current_time) {
             do_item_unlink(it, hv);//将item从hashtable和LRU链中移除
             do_item_remove(it);//删除item
             it = NULL;
             if (was_found) {
                 fprintf(stderr, " -nuked by expire");
             }
         } else {
             it->it_flags |= ITEM_FETCHED;//item的标识修改为已经读取
             DEBUG_REFCNT(it, '+');
         }
     }

     if (settings.verbose > 2)
         fprintf(stderr, "\n");

     return it;
 }

 //移除item
 void do_item_remove(item *it) {
     MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes);
     assert((it->it_flags & ITEM_SLABBED) == 0);//判断item的状态是否正确

     if (refcount_decr(&it->refcount) == 0) {//修改item的引用次数
         item_free(it);//释放item
     }
 }
 //释放item
 void item_free(item *it) {
     size_t ntotal = ITEM_ntotal(it);//获得item的大小
     unsigned int clsid;
     assert((it->it_flags & ITEM_LINKED) == 0);//判断item的状态是否正确
     assert(it != heads[it->slabs_clsid]);//item不能为LRU的头指针
     assert(it != tails[it->slabs_clsid]);//item不能为LRU的尾指针
     assert(it->refcount == 0);//释放时，需保证引用次数为0

     /* so slab size changer can tell later if item is already free or not */
     clsid = it->slabs_clsid;
     it->slabs_clsid = 0;//断开slabclass的链接
     DEBUG_REFCNT(it, 'F');
     slabs_free(it, ntotal, clsid);//slabclass结构执行释放
 }
 //slabclass结构释放
 void slabs_free(void *ptr, size_t size, unsigned int id) {
     pthread_mutex_lock(&slabs_lock);//保持同步
     do_slabs_free(ptr, size, id);//执行释放
     pthread_mutex_unlock(&slabs_lock);
 }
 //slabclass结构释放
 static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
     slabclass_t *p;
     item *it;

     assert(((item *)ptr)->slabs_clsid == 0);//判断数据是否正确
     assert(id >= POWER_SMALLEST && id <= power_largest);//判断id合法性
     if (id < POWER_SMALLEST || id > power_largest)//判断id合法性
         return;

     MEMCACHED_SLABS_FREE(size, id, ptr);
     p = &slabclass[id];

     it = (item *)ptr;
     it->it_flags |= ITEM_SLABBED;//修改item的状态标识，修改为空闲
     it->prev = 0;//断开数据链表
     it->next = p->slots;
     if (it->next) it->next->prev = it;
     p->slots = it;

     p->sl_curr++;//空闲item个数+1
     p->requested -= size;//空间增加size
     return;
 }
 //将item从hashtable和LRU链中移除。是do_item_link的逆操作
 void do_item_unlink(item *it, const uint32_t hv) {
     MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes);
     mutex_lock(&cache_lock);//执行同步
     if ((it->it_flags & ITEM_LINKED) != 0) {//判断状态值，保证item还在LRU队列中
         it->it_flags &= ~ITEM_LINKED;//修改状态值
         STATS_LOCK();//更新统计信息
         stats.curr_bytes -= ITEM_ntotal(it);
         stats.curr_items -= 1;
         STATS_UNLOCK();
         assoc_delete(ITEM_key(it), it->nkey, hv);//从Hash表中删除
         item_unlink_q(it);//将item从slabclass对应的LRU队列摘除
         do_item_remove(it);//移除item
     }
     mutex_unlock(&cache_lock);
 }

Memcached的get操作在读取数据时，会判断数据的有效性，使得不用额外去处理过期数据，get操作牵涉到Slab结构，Hash表，LRU队列的更新，我们后面专门分析这些的变更，这里暂不分析。

 

Memcached源码分析之set操作

之前分析了Memcached的get操作，下面分析set操作的流程。

 //存储item
 enum store_item_type store_item(item *item, int comm, conn* c) {
     enum store_item_type ret;
     uint32_t hv;

     hv = hash(ITEM_key(item), item->nkey, 0);//获取Hash表的分段锁
     item_lock(hv);//执行数据同步
     ret = do_store_item(item, comm, c, hv);//存储item
     item_unlock(hv);
     return ret;
 }
 //存储item
 enum store_item_type do_store_item(item *it, int comm, conn *c,const uint32_t hv)
 {
     char *key = ITEM_key(it);//读取item对应的key
     item *old_it = do_item_get(key, it->nkey, hv);//读取相应的item,如果没有相关的数据,old_it为NULL
     enum store_item_type stored = NOT_STORED;//item状态标记

     item *new_it = NULL;
     int flags;

     if (old_it != NULL && comm == NREAD_ADD)//如果old_it不为NULL,且操作为add操作
     {
         do_item_update(old_it);//更新数据
     }
     else if (!old_it
             && (comm == NREAD_REPLACE || comm == NREAD_APPEND
                     || comm == NREAD_PREPEND)) //old_it为空，且操作为REPLACE，则什么都不做
     {
           //memcached的Replace操作是替换已有的数据，如果没有相关数据，则不做任何操作
     }
     else if (comm == NREAD_CAS)//以cas方式读取
     {
         if (old_it == NULL) //为空
         {
             // LRU expired
             stored = NOT_FOUND;//修改状态
             pthread_mutex_lock(&c->thread->stats.mutex);//更新Worker线程统计数据
             c->thread->stats.cas_misses++;
             pthread_mutex_unlock(&c->thread->stats.mutex);
         }
         else if (ITEM_get_cas(it) == ITEM_get_cas(old_it))//old_it不为NULL，且cas属性一致
         {
             pthread_mutex_lock(&c->thread->stats.mutex);
             c->thread->stats.slab_stats[old_it->slabs_clsid].cas_hits++;//更新Worker线程统计信息
             pthread_mutex_unlock(&c->thread->stats.mutex);

             item_replace(old_it, it, hv);//执行item的替换操作，用新的item替换老的item
             stored = STORED;//修改状态值
         }
         else//old_it不为NULL,且cas属性不一致
         {
             pthread_mutex_lock(&c->thread->stats.mutex);
             c->thread->stats.slab_stats[old_it->slabs_clsid].cas_badval++;//更新Worker线程统计信息
             pthread_mutex_unlock(&c->thread->stats.mutex);

             if (settings.verbose > 1)
             {
                 fprintf(stderr, "CAS:  failure: expected %llu, got %llu\n",
                         (unsigned long long) ITEM_get_cas(old_it),
                         (unsigned long long) ITEM_get_cas(it));
             }
             stored = EXISTS;//修改状态值，修改状态值为已经存在，且不存储最新的数据
         }
     }
     else //执行其他操作的写
     {
         if (comm == NREAD_APPEND || comm == NREAD_PREPEND)//以追加的方式执行写
         {

             if (ITEM_get_cas(it) != 0)//验证cas有效性
             {
                 if (ITEM_get_cas(it) != ITEM_get_cas(old_it))//cas验证不通过
                 {
                     stored = EXISTS;//修改状态值为已存在
                 }
             }

             if (stored == NOT_STORED)//状态值为没有存储,也就是cas验证通过，则执行写操作
             {
                 flags = (int) strtol(ITEM_suffix(old_it), (char **) NULL, 10);
                 //申请新的空间
                 new_it = do_item_alloc(key, it->nkey, flags, old_it->exptime,it->nbytes + old_it->nbytes - 2 , hv);

                 if (new_it == NULL)
                 {
                     //空间不足
                     if (old_it != NULL)
                         do_item_remove(old_it);//删除老的item

                     return NOT_STORED;
                 }

                 if (comm == NREAD_APPEND)//追加方式
                 {
                     memcpy(ITEM_data(new_it), ITEM_data(old_it),old_it->nbytes);//老数据拷贝到新数据中
                     memcpy(ITEM_data(new_it) + old_it->nbytes - 2,ITEM_data(it), it->nbytes);//同时拷贝最近缓冲区已有的数据
                 }
                 else
                 {
                     //这里和具体协议相关
                     memcpy(ITEM_data(new_it), ITEM_data(it), it->nbytes);//拷贝it的数据到new_it中
                     memcpy(ITEM_data(new_it) + it->nbytes - 2 ,ITEM_data(old_it), old_it->nbytes);//同时拷贝最近缓冲区已有的数据
                 }

                 it = new_it;
             }
         }

         if (stored == NOT_STORED)
         {
             if (old_it != NULL)//如果old_it不为空
                 item_replace(old_it, it, hv);//替换老的值
             else
                 do_item_link(it, hv);//重新存储数据

             c->cas = ITEM_get_cas(it);//获取cas值

             stored = STORED;
         }
     }

     if (old_it != NULL)
         do_item_remove(old_it);//释放空间
     if (new_it != NULL)
         do_item_remove(new_it);//释放空间

     if (stored == STORED)//如果已经存储了
     {
         c->cas = ITEM_get_cas(it);//获取cas属性
     }

     return stored;
 }
 //更新item，这个只更新时间
 void do_item_update(item *it) {
     MEMCACHED_ITEM_UPDATE(ITEM_key(it), it->nkey, it->nbytes);
     if (it->time < current_time - ITEM_UPDATE_INTERVAL) {//更新有时间限制
         assert((it->it_flags & ITEM_SLABBED) == 0);

         mutex_lock(&cache_lock);//保持同步
         if ((it->it_flags & ITEM_LINKED) != 0) {//更新LRU队列的Item
             item_unlink_q(it);//断开连接
             it->time = current_time;//更新item的时间
             item_link_q(it);//重新添加
         }
         mutex_unlock(&cache_lock);
     }
 }
 //用新的item替换老的item
 int do_item_replace(item *it, item *new_it, const uint32_t hv) {
     MEMCACHED_ITEM_REPLACE(ITEM_key(it), it->nkey, it->nbytes,
                            ITEM_key(new_it), new_it->nkey, new_it->nbytes);
     assert((it->it_flags & ITEM_SLABBED) == 0);//判断it是已经分配过的，如果未分配，则断言失败

     do_item_unlink(it, hv);//断开连接
     return do_item_link(new_it, hv);//重新添加
 }

有些item的操作已经在get操作中有分析，我们此处不做分析，我们下一篇分析下Memcached内部如何选择合适的空间来存放item.

上文来自：http://blog.csdn.net/lcli2009?viewmode=contents