memcached源码分析-----LRU队列与item结构体

   转载请注明出处：http://blog.csdn.net/luotuo44/article/details/42869325

 

 

LRU队列：

 

        之前的《slab内存分配》博文已经写到：一个slab class里面的所有slab分配器只分配相同大小的item，不同的slab class分配不同大小的item。item结构体里面有一个slabs_clsid成员，用来指明自己是属于哪个slab class的。这里把slabs_clsid值相同的item称为是同一类item。

        slab分配器负责分配一个item，但这个item并非直接被哈希表进行管理。从《哈希表的删除操作》可以得知，对哈希表中的某一个item进行删除只是简单地将这个item从哈希表的冲突链中删除掉，并没有把item内存归还给slab。实际上，slab分配器分配出去的item是由一个LRU队列进行管理的。当一个item从LRU队列中删除就会归还给slab分配器 。

 

        LRU队列其实是一个双向链表。memcached里面有多条LRU队列，条数等于item的种类数。所以呢，同一类item(slabs_clsid成员变量值相等)将放到同一条LRU队列中。之所以是双向链表，是因为要方便从前后两个方向插入和遍历链表。下面浏览一下item结构体的部分成员。

 

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. typedef struct _stritem {  
  2.     struct _stritem *next; //next指针，用于LRU链表  
  3.     struct _stritem *prev; //prev指针，用于LRU链表  
  4.     struct _stritem *h_next;//h_next指针，用于哈希表的冲突链  
  5.     rel_time_t      time;   //最后一次访问时间。绝对时间  
  6.       ...  
  7.     uint8_t         slabs_clsid;/* which slab class we're in */  
  8. } item;  


        接下来阅读管理LRU队列的数据结构。其实是超级简单的，就三个全局数组而已，而且是static数组(开心吧)。

 

 

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. //memcached.h文件  
  2. #define POWER_LARGEST  200  
  3.   
  4. //items.c文件  
  5. #define LARGEST_ID POWER_LARGEST  
  6. static item *heads[LARGEST_ID];//指向每一个LRU队列头  
  7. static item *tails[LARGEST_ID];//指向每一个LRU队列尾  
  8. static unsigned int sizes[LARGEST_ID];//每一个LRU队列有多少个item  

 

 

        可以看到这三个数组的大小是和slabclass提供的最大slab class个数是一样的。这样也印证了一个LRU队列就对应一类item。heads[i]指向第i类LRU链表的第一个item，tails[i]则指向了第i类LRU链表的最后一个item，sizes[i]则指明第i类LRU链表有多少个item。由LRU队列和heads和tails构成的结构如下图所示：

        

 

 

LRU队列的基本操作：

 

插入操作：

 

        假设我们有一个item要插入到LRU链表中，那么可以通过调用item_link_q函数把item插入到LRU队列中。下面是具体的实现代码。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. //将item插入到LRU队列的头部  
  2. static void item_link_q(item *it) { /* item is the new head */  
  3.     item **head, **tail;  
  4.     assert(it->slabs_clsid < LARGEST_ID);  
  5.     assert((it->it_flags & ITEM_SLABBED) == 0);  
  6.   
  7.     head = &heads[it->slabs_clsid];  
  8.     tail = &tails[it->slabs_clsid];  
  9.     assert(it != *head);  
  10.     assert((*head && *tail) || (*head == 0 && *tail == 0));  
  11.   
  12.     //头插法插入该item  
  13.     it->prev = 0;  
  14.     it->next = *head;  
  15.     if (it->next) it->next->prev = it;  
  16.     *head = it;//该item作为对应链表的第一个节点  
  17.   
  18.     //如果该item是对应id上的第一个item，那么还会被认为是该id链上的最后一个item  
  19.     //因为在head那里使用头插法，所以第一个插入的item，到了后面确实成了最后一个item  
  20.     if (*tail == 0) *tail = it;  
  21.     sizes[it->slabs_clsid]++;//个数加一  
  22.     return;  
  23. }  

 

删除操作：

        有了插入函数，肯定有对应的删除函数。删除函数是蛮简单，主要是处理删除这个节点后，该节点的前后驱节点怎么拼接在一起。

 

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. //将it从对应的LRU队列中删除  
  2. static void item_unlink_q(item *it) {  
  3.     item **head, **tail;  
  4.     assert(it->slabs_clsid < LARGEST_ID);  
  5.     head = &heads[it->slabs_clsid];  
  6.     tail = &tails[it->slabs_clsid];  
  7.   
  8.       
  9.     if (*head == it) {//链表上的第一个节点  
  10.         assert(it->prev == 0);  
  11.         *head = it->next;  
  12.     }  
  13.     if (*tail == it) {//链表上的最后一个节点  
  14.         assert(it->next == 0);  
  15.         *tail = it->prev;  
  16.     }  
  17.     assert(it->next != it);  
  18.     assert(it->prev != it);  
  19.   
  20.     //把item的前驱节点和后驱节点连接起来  
  21.     if (it->next) it->next->prev = it->prev;  
  22.     if (it->prev) it->prev->next = it->next;  
  23.     sizes[it->slabs_clsid]--;//个数减一  
  24.     return;  
  25. }  

 

 

        可以看到无论是插入还是删除一个item，其耗时都是常数。其实对于memcached来说几乎所有的操作时间复杂度都是常数级的。

 

更新操作：

 

        为什么要把item插入到LRU队列头部呢？当然实现简单是其中一个原因。但更重要的是这是一个LRU队列！！还记得操作系统里面的LRU吧。这是一种淘汰机制。在LRU队列中，排得越靠后就认为是越少使用的item，此时被淘汰的几率就越大。所以新鲜item(访问时间新)，要排在不那么新鲜item的前面，所以插入LRU队列的头部是不二选择。下面的do_item_update函数佐证了这一点。do_item_update函数是先把旧的item从LRU队列中删除，然后再插入到LRU队列中(此时它在LRU队列中排得最前)。除了更新item在队列中的位置外，还会更新item的time成员，该成员指明上一次访问的时间(绝对时间)。如果不是为了LRU，那么do_item_update函数最简单的实现就是直接更新time成员即可。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #define ITEM_UPDATE_INTERVAL 60 //更新频率为60秒  
  2.   
  3. void do_item_update(item *it) {  
  4.     //下面的代码可以看到update操作是耗时的。如果这个item频繁被访问，  
  5.     //那么会导致过多的update，过多的一系列费时操作。此时更新间隔就应运而生  
  6.     //了。如果上一次的访问时间(也可以说是update时间)距离现在(current_time)  
  7.     //还在更新间隔内的，就不更新。超出了才更新。  
  8.     if (it->time < current_time - ITEM_UPDATE_INTERVAL) {  
  9.   
  10.         mutex_lock(&cache_lock);  
  11.         if ((it->it_flags & ITEM_LINKED) != 0) {  
  12.             item_unlink_q(it);//从LRU队列中删除  
  13.             it->time = current_time;//更新访问时间  
  14.             item_link_q(it);//插入到LRU队列的头部  
  15.         }  
  16.         mutex_unlock(&cache_lock);  
  17.     }  
  18. }  

 

        memcached处理get命令时会调用do_item_update函数更新item的访问时间，更新其在LRU队列的位置。在memcached中get命令是很频繁的命令，排在LRU队列第一或者前几的item更是频繁被get。对于排在前几名的item来说，调用do_item_update是意义不大的，因为调用do_item_update后其位置还是前几名，并且LRU淘汰再多item也难于淘汰不到它们(一个LRU队列的item数量是很多的)。另一方面，do_item_update函数耗时还是会有一定的耗时，因为要抢占cache_lock锁。如果频繁调用do_item_update函数性能将下降很多。于是memcached就是使用了更新间隔。

 

 

 

        前面讲了怎么在LRU队列中插入和删除一个item，现在讲一下怎么从slab分配器中申请一个item和怎么归还item给slab分配器。

 

item结构体：

        虽然前面多次提到了item，但item长成什么样子估计读者还是迷迷糊糊的。下面看一下item结构体的完整定义吧，留意英文注释。

 

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #define ITEM_LINKED 1 //该item插入到LRU队列了  
  2. #define ITEM_CAS 2 //该item使用CAS  
  3. #define ITEM_SLABBED 4 //该item还在slab的空闲队列里面，没有分配出去  
  4. #define ITEM_FETCHED 8 //该item插入到LRU队列后，被worker线程访问过  
  5.   
  6. typedef struct _stritem {  
  7.     struct _stritem *next;//next指针，用于LRU链表  
  8.     struct _stritem *prev;//prev指针，用于LRU链表  
  9.     struct _stritem *h_next;//h_next指针，用于哈希表的冲突链  
  10.     rel_time_t      time;//最后一次访问时间。绝对时间  
  11.     rel_time_t      exptime;//过期失效时间，绝对时间  
  12.     int             nbytes;//本item存放的数据的长度     
  13.     unsigned short  refcount;//本item的引用数  
  14.     uint8_t         nsuffix;//后缀长度    /* length of flags-and-length string */  
  15.     uint8_t         it_flags;//item的属性   /* ITEM_* above */  
  16.     uint8_t         slabs_clsid;/* which slab class we're in */  
  17.     uint8_t         nkey;//键值的长度       /* key length, w/terminating null and padding */  
  18.     /* this odd type prevents type-punning issues when we do 
  19.      * the little shuffle to save space when not using CAS. */  
  20.     union {  
  21.         uint64_t cas;  
  22.         char end;  
  23.     } data[];  
  24.     /* if it_flags & ITEM_CAS we have 8 bytes CAS */  
  25.     /* then null-terminated key */  
  26.     /* then " flags length\r\n" (no terminating null) */  
  27.     /* then data with terminating \r\n (no terminating null; it's binary!) */  
  28. } item;  

 

 

        上面代码里面的英文注释说明了item布局。item结构体的最后一个成员是data[]，这样的定义称为柔性数组。柔性数组的一个使用特点是，数据域就存放在数组的后面。memcached的item也是这样使用柔性数组的。上面的item只是定义了item结构体本身的成员，但之前的博文一直用item表示item存储的数据。这样写是合理的。因为item结构体本身和item对应的数据都是存放slab分配器分配的同一块内存里面。在《slab内存分配器》初始化slabclass数组的时候，其分配的内存块大小是sizeof(item) +settings.chunk_size。

 

        item结构体后面紧接着的是一堆数据，并非仅仅是用户要存储的data，具体如下图所示：

        

 

 

        看上面的图可能还不完全清楚明了item以及对应数据的存储形式。我懂的，码农是需要代码才能完全清楚明了的。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #define ITEM_key(item) (((char*)&((item)->data)) \  
  2.          + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0))  
  3.   
  4. #define ITEM_suffix(item) ((char*) &((item)->data) + (item)->nkey + 1 \  
  5.          + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0))  
  6.   
  7. #define ITEM_data(item) ((char*) &((item)->data) + (item)->nkey + 1 \  
  8.          + (item)->nsuffix \  
  9.          + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0))  
  10.   
  11. #define ITEM_ntotal(item) (sizeof(struct _stritem) + (item)->nkey + 1 \  
  12.          + (item)->nsuffix + (item)->nbytes \  
  13.          + (((item)->it_flags & ITEM_CAS) ? sizeof(uint64_t) : 0))  
  14.   
  15.   
  16. static size_t item_make_header(const uint8_t nkey, const int flags, const int nbytes,  
  17.                      char *suffix, uint8_t *nsuffix) {  
  18.     /* suffix is defined at 40 chars elsewhere.. */  
  19.     *nsuffix = (uint8_t) snprintf(suffix, 40, " %d %d\r\n", flags, nbytes - 2);  
  20.     return sizeof(item) + nkey + *nsuffix + nbytes;//计算总大小  
  21. }  
  22.   
  23. //key、flags、exptime三个参数是用户在使用set、add命令存储一条数据时输入的参数。  
  24. //nkey是key字符串的长度。nbytes则是用户要存储的data长度+2,因为在data的结尾处还要加上"\r\n"  
  25. //cur_hv则是根据键值key计算得到的哈希值。  
  26. item *do_item_alloc(char *key, const size_t nkey, const int flags,  
  27.                     const rel_time_t exptime, const int nbytes,  
  28.                     const uint32_t cur_hv) {  
  29.     uint8_t nsuffix;  
  30.     item *it = NULL;  
  31.     char suffix[40];  
  32.     //要存储这个item需要的总空间。要注意第一个参数是nkey+1，所以上面的那些宏计算时  
  33.     //使用了(item)->nkey + 1  
  34.     size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix);  
  35.     if (settings.use_cas) {//开启了CAS功能  
  36.         ntotal += sizeof(uint64_t);  
  37.     }  
  38.   
  39.     //根据大小判断从属于哪个slab  
  40.     unsigned int id = slabs_clsid(ntotal);  
  41.     if (id == 0)//0表示不属于任何一个slab  
  42.         return 0;  
  43.       
  44.     ...  
  45.   
  46.     it = slabs_alloc(ntotal, id);//从slab分配器中申请内存  
  47.     it->refcount = 1;  
  48.     it->it_flags = settings.use_cas ? ITEM_CAS : 0;  
  49.     it->nkey = nkey;  
  50.     it->nbytes = nbytes;  
  51.     memcpy(ITEM_key(it), key, nkey);//这里只拷贝nkey个字节，最后一个字节空着  
  52.     it->exptime = exptime;  
  53.     memcpy(ITEM_suffix(it), suffix, (size_t)nsuffix);  
  54.     it->nsuffix = nsuffix;  
  55.   
  56.     return it;  
  57. }  

 

        码农们好好体会上面代码中的几个宏定义以及item_make_header函数。上面的代码还只是超级简单地介绍了do_item_alloc函数，之所以说超级简单是因为这个函数实际上是相当复杂的，完整版本点击这里查看。

 

 

        上面简单给出了向slab申请一个item，现在贴出归还item的代码。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. //items.c文件  
  2. void item_free(item *it) {  
  3.     size_t ntotal = ITEM_ntotal(it);  
  4.     unsigned int clsid;  
  5.   
  6.     clsid = it->slabs_clsid;  
  7.     it->slabs_clsid = 0;  
  8.     slabs_free(it, ntotal, clsid);  
  9. }  
  10.   
  11. //slabs.c文件  
  12. void slabs_free(void *ptr, size_t size, unsigned int id) {  
  13.     pthread_mutex_lock(&slabs_lock);  
  14.     do_slabs_free(ptr, size, id);//归还给slab分配器  
  15.     pthread_mutex_unlock(&slabs_lock);  
  16. }  



item和哈希表的联系：

 

        前面的do_item_alloc函数是根据所需的大小申请一个item。从do_item_alloc实现代码来看，它没有把这个item插入到哈希表和LRU队列中。实际上这个任务是由另外的函数实现的。

插入和删除item：

        接下来阅读，如何把item传给哈希表、LRU队列以及如何从哈希表、LRU队列收回item(有时还需要归还给slab的)。

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. //将item插入到哈希表和LRU队列中，插入到哈希表需要哈希值hv  
  2. int do_item_link(item *it, const uint32_t hv) {  
  3.   
  4.     //确保这个item已经从slab分配出去并且还没插入到LRU队列中  
  5.     assert((it->it_flags & (ITEM_LINKED|ITEM_SLABBED)) == 0);  
  6.   
  7.     //当哈希表不在为扩展而迁移数据时，就往哈希表插入item  
  8.     //当哈希表在迁移数据时，会占有这个锁。  
  9.     mutex_lock(&cache_lock);  
  10.     it->it_flags |= ITEM_LINKED;//加入 已link标志  
  11.     it->time = current_time;  
  12.   
  13.     /* Allocate a new CAS ID on link. */  
  14.     ITEM_set_cas(it, (settings.use_cas) ? get_cas_id() : 0);  
  15.     assoc_insert(it, hv);//将这个item插入到哈希表中  
  16.     item_link_q(it);//将这个item插入到链表中  
  17.     refcount_incr(&it->refcount);//引用计数加一  
  18.     mutex_unlock(&cache_lock);  
  19.   
  20.     return 1;  
  21. }  
  22.   
  23. //从哈希表删除，所以需要哈希值hv  
  24. void do_item_unlink(item *it, const uint32_t hv) {  
  25.   
  26.     mutex_lock(&cache_lock);  
  27.     if ((it->it_flags & ITEM_LINKED) != 0) {  
  28.         it->it_flags &= ~ITEM_LINKED;//减去已link标志  
  29.   
  30.         assoc_delete(ITEM_key(it), it->nkey, hv);//将这个item从哈希表中删除  
  31.         item_unlink_q(it);//从链表中删除该item  
  32.         do_item_remove(it);//向slab归还这个item  
  33.     }  
  34.     mutex_unlock(&cache_lock);  
  35. }  
  36.   
  37.   
  38. void do_item_remove(item *it) {  
  39.     assert((it->it_flags & ITEM_SLABBED) == 0);  
  40.     assert(it->refcount > 0);  
  41.   
  42.     if (refcount_decr(&it->refcount) == 0) {//引用计数等于0的时候归还  
  43.         item_free(it);//归还该item给slab  
  44.     }  
  45. }  


        在使用do_item_remove函数向slab归还item时，会先测试这个item的引用数是否等于0。引用数可以简单理解为是否有worker线程在使用这个item。引用数的将会在后面的《item引用计数》中详细讲解。

 

 

 

        前面的代码中很少使用锁。但实际上前述的item操作都是需要加锁的，因为可能多个worker线程同时操作哈希表和LRU队列。之所以很少看到锁是因为他们都使用了包裹函数(如果看过《UNIX网络编程》，这个概念应该不陌生)。在包裹函数中加锁和解锁。前面的函数中，函数名一般都是以do_作为前缀。其对应的包裹函数名就是去掉前缀do_。锁的介绍不是本博文的任务，后面会有专门的博文介绍锁的使用。

posted on 2016-04-10 11:54  c++kuzhon  阅读(229)  评论(0)    收藏  举报

导航