上节在分析slab内存管理机制时分析Memcached整个Item存储系统的初始化过程slabs_init()函数：分配slabclass数组空间，到最后将各slab划分为各种级别大小的空闲item并挂载到对应大小slab的空闲链表slots上。本节将继续分析对slab和item的主要操作过程。
slab机制中所采用的LRU算法：
在memcached运行过程中，要把一个item调入内存，但内存已无空闲空间时，为了保证程序能正常运行，系统必须从内存中调出一部分数据，送磁盘的对换区中。但应将哪些数据调出，须根据一定的算法来确定。通常，把选择换出数据(页面)的算法称为页面置换算法(Page Replacement Algorithms)。 Memcached采用最近最久未使用（LRU）置换算法，是根据数据（页面）调入内存后的使用情况进行决策的。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。
每个slabclass维护一个双向链表，所有分配出去的item按照最近访问时间依次放到该链表中，该链表也就相当于LRU队列。所有slabclass的链表头 尾分表保存在*heads、 *tails两个数组中。当内存不足时，memcached会对应大小的slabclass维护的双向链表的尾部开始检测，即最近最久未使用的item，往前一直寻找合适的item予以淘汰。所以该LRU算法为局部的slabclass淘汰机制。但是在一些特定情形也会可能引起一些不必要的麻烦，可以在运行时加入”-M”参数禁止该算法。
Slab相关操作：
/*
*根据给定的大小在slabclass数组中找到合适的slabclass，返回该slabclass的下标
*如果给定大小为0，或者大于最大的slab的item大小，则返回0
*/
unsigned int slabs_clsid(const size_t size) {
int res = POWER_SMALLEST;
if (size == 0)
return 0;
while (size > slabclass[res].size)
if (res++ == power_largest) /* won't fit in the biggest slab */
return 0;//物件过大，不能直接存放
return res;
}
//当该slabcalss的slots空闲链表为空时为指定大小的item分配空间：
//size为给定的item大小，id为对应的slabclass编号,返回item指针
static void *do_slabs_alloc(const size_t size, unsigned int id) {
slabclass_t *p;
void *ret = NULL;
item *it = NULL;
if (id < POWER_SMALLEST || id > power_largest) {//id编号不合法
MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);
return NULL;
}
p = &slabclass[id];//获取对应的slabclass
assert(p->sl_curr == 0 || ((item *)p->slots)->slabs_clsid == 0);
/* fail unless we have space at the end of a recently allocated page,
we have something on our freelist, or we could allocate a new page */
//如果空闲链表为空且 为该大小的slab分配一个slabcalss(1M)失败
if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) {
/* We don't have more memory available */
ret = NULL;//如果所有空间都用尽的时候，则返回NULL表示目前资源已经枯竭了。
} else if (p->sl_curr != 0) {//不管是原来的空闲item或者新分配的item,都将挂在到slots上
/* return off our freelist */
it = (item *)p->slots;//返回空闲链表的头item
p->slots = it->next;
if (it->next) it->next->prev = 0;
p->sl_curr--;
ret = (void *)it;
}
if (ret) {
p->requested += size;
MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret);
} else {
MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);
}
return ret;
}
//创建空闲item ，挂载到对应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)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
it = (item *)ptr;
it->it_flags |= ITEM_SLABBED;
it->prev = 0;
it->next = p->slots;//挂载到slabclass的空闲链表中
if (it->next) it->next->prev = it;
p->slots = it;
p->sl_curr++;//空闲item个数+1
p->requested -= size;//已经申请到的空间数量更新
return;
}
Item相关操作：
主要接口函数：
do_item_alloc() ：
首先调用slabs_clsid给item归类，然后调用slabs_alloc()函数分配内存，当可使用空间枯竭了的时候，就开始使用LRU算法了，从一个对应大小的尾部tails[id]开始，向前不断尝试能否释放，当发现一个item当前没有被使用(引用计数refcount为0)，且其生存时间已经为0或生存时间大于现在时间，就果断的把它释放掉。并再次调用slabs_alloc(),作者在此提到有一种非常罕见的bug能够使引用计数(refcount)发生泄漏，处理方法是，当item连续保持锁定状态3小时以上，说明它已经足够陈旧了，应该果断将其释放。最后再将数据复制到分配的空间内。
item_free()：
调用slabs_free将其释放。
do_item_link()：
1.调用assoc_insert()将item指针插入hash表中
2.调用get_cas_id()给it的cas_id赋值。
3.调用item_link_q(),把该item插入LRU队列的最前面
do_item_unlink ()：
1.调用assoc_delete()在hash表中删除此item
2.调用item_unlink_q()从该slab class去除此item的连接，此处考虑了item在链表头部，尾部等各种情况。
3.最后当引用计数为0的时候，调用item_free()将其释放。
do_item_remove () ：
减少引用计数refcount，当发现引用计数为0的时候，就将其释放。
do_item_update ()：
先调用item_unlink_q(),更新了时间以后，再调用item_link_q()。将其重新连接到LRU队列之中，即让该item移到LRU队列的最前。
do_item_replace ()：
调用do_item_unlink()解除原有item的连接，再调用do_item_link()连接到新的item。
item_get () ：
值得说明的是，memcached的懒惰删除逻辑在这里有体现。就是当你需要get 一个item的时候才考虑该item是否应该删除。 首先调用do_item_get_notedeleted()函数，根据关键字使用assoc_find()查找item,如果没找到，返回NULL，再判断是否达到最大的生存时间，如果是的话，就do_item_unlink该item，返回NULL。 如果该item没有满足删除条件，将其引用计数加1，并返回该item的指针。
具体分析见代码：
//key:键 nkey：键的长度 falgs：键falg exptime:过期时间（相对） cur_hv哈希值
item *do_item_alloc(char *key, const size_t nkey, const int flags,
const rel_time_t exptime, const int nbytes,
const uint32_t cur_hv) {
uint8_t nsuffix;//key的后缀长度
item *it = NULL;
char suffix[40];//存放key后缀
//该item所需的总长度
size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix);
if (settings.use_cas) {
ntotal += sizeof(uint64_t);
}
//以item总长来计算所属的slabclass
unsigned int id = slabs_clsid(ntotal);
if (id == 0)
return 0;
mutex_lock(&cache_lock);
/* do a quick check if we have any expired items in the tail.. */
int tries = 5;//执行5次尝试检查，（快速，而不是全部都检查一遍）
/* Avoid hangs if a slab has nothing but refcounted stuff in it. */
//将所有过期时间旧于设定的oldest_live时间的所有item视为过期item，以避免那些实际没用，但却被一直引用的item
int tries_lrutail_reflocked = 1000;
int tried_alloc = 0;
item *search;
item *next_it;
void *hold_lock = NULL;
rel_time_t oldest_live = settings.oldest_live;//对所有item设定的item最长生存时间
search = tails[id];//serch指向该slabclass对应的item链表尾部
/* We walk up *only* for locked items. Never searching for expired.
* Waste of CPU for almost all deployments */
for (; tries > 0 && search != NULL; tries--, search=next_it) {
/* we might relink search mid-loop, so search->prev isn't reliable */
next_it = search->prev;
if (search->nbytes == 0 && search->nkey == 0 && search->it_flags == 1) {
/* We are a crawler, ignore it. */
tries++;
continue;
}
//计算哈希值，用于锁定serch的该item，避免其他调用者增加该item的引用计数
uint32_t hv = hash(ITEM_key(search), search->nkey);
/* Attempt to hash item lock the "search" item. If locked, no
* other callers can incr the refcount
*/
/* Don't accidentally grab ourselves, or bail if we can't quicklock */
//如果该item正好是当前的item,则忽略
if (hv == cur_hv || (hold_lock = item_trylock(hv)) == NULL)
continue;
/* Now see if the item is refcount locked */
if (refcount_incr(&search->refcount) != 2) {
/* Avoid pathological case with ref'ed items in tail */
do_item_update_nolock(search);
tries_lrutail_reflocked--;
tries++;
refcount_decr(&search->refcount);
itemstats[id].lrutail_reflocked++;
/* Old rare bug could cause a refcount leak. We haven't seen
* it in years, but we leave this code in to prevent failures
* just in case */
if (settings.tail_repair_time &&
search->time + settings.tail_repair_time < current_time) {
itemstats[id].tailrepairs++;
search->refcount = 1;
do_item_unlink_nolock(search, hv);
}
if (hold_lock)
item_trylock_unlock(hold_lock);
if (tries_lrutail_reflocked < 1)
break;
continue;
}
/* Expired or flushed */
////还没过期，或者已经过期但是最近访问时间小于设定的最大过期时间，并且设定的最大过期时间小于当前时间
if ((search->exptime != 0 && search->exptime < current_time)
|| (search->time <= oldest_live && oldest_live <= current_time))
{
itemstats[id].reclaimed++;
if ((search->it_flags & ITEM_FETCHED) == 0) {
itemstats[id].expired_unfetched++;
}
it = search;
slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal);
do_item_unlink_nolock(it, hv);//从哈希表 及item链表中删除，递减引用计数
/* Initialize the item block: */
it->slabs_clsid = 0;//注意：slabs_clsid = 0表明不属于任何slabclass
} else if ((it = slabs_alloc(ntotal, id)) == NULL) {
tried_alloc = 1;
if (settings.evict_to_free == 0) {
itemstats[id].outofmemory++;
} else {
itemstats[id].evicted++;
itemstats[id].evicted_time = current_time - search->time;
if (search->exptime != 0)
itemstats[id].evicted_nonzero++;
if ((search->it_flags & ITEM_FETCHED) == 0) {
itemstats[id].evicted_unfetched++;
}
it = search;
slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal);
do_item_unlink_nolock(it, hv);
/* Initialize the item block: */
it->slabs_clsid = 0;
/* If we've just evicted an item, and the automover is set to
* angry bird mode, attempt to rip memory into this slab class.
* TODO: Move valid object detection into a function, and on a
* "successful" memory pull, look behind and see if the next alloc
* would be an eviction. Then kick off the slab mover before the
* eviction happens.
*/
if (settings.slab_automove == 2)
slabs_reassign(-1, id);
}
}
refcount_decr(&search->refcount);
/* If hash values were equal, we don't grab a second lock */
if (hold_lock)
item_trylock_unlock(hold_lock);
break;
}
if (!tried_alloc && (tries == 0 || search == NULL))
it = slabs_alloc(ntotal, id);
if (it == NULL) {
itemstats[id].outofmemory++;
mutex_unlock(&cache_lock);
return NULL;
}
assert(it->slabs_clsid == 0);
assert(it != heads[id]);
/* Item initialization can happen outside of the lock; the item's already
* been removed from the slab LRU.
*/
//初始化item。 由于该item已不在lru队列中，因此可以无锁操作
it->refcount = 1; //引用计数初始化为1 /* the caller will have a reference */
mutex_unlock(&cache_lock);
it->next = it->prev = it->h_next = 0;
it->slabs_clsid = id;//其所属id已经计算好
DEBUG_REFCNT(it, '*');
it->it_flags = settings.use_cas ? ITEM_CAS : 0;
it->nkey = nkey;//
it->nbytes = nbytes;//
memcpy(ITEM_key(it), key, nkey);
it->exptime = exptime;
memcpy(ITEM_suffix(it), suffix, (size_t)nsuffix);
it->nsuffix = nsuffix;
return it;
}
//释放一个item，挂载到slots的头部
void item_free(item *it) {
size_t ntotal = ITEM_ntotal(it);
unsigned int clsid;
assert((it->it_flags & ITEM_LINKED) == 0);
assert(it != heads[it->slabs_clsid]);
assert(it != tails[it->slabs_clsid]);
assert(it->refcount == 0);
/* so slab size changer can tell later if item is already free or not */
clsid = it->slabs_clsid;
it->slabs_clsid = 0;
DEBUG_REFCNT(it, 'F');
slabs_free(it, ntotal, clsid);
}
//将item插入到哈希表 lru队列
int do_item_link(item *it, const uint32_t hv) {
MEMCACHED_ITEM_LINK(ITEM_key(it), it->nkey, it->nbytes);
assert((it->it_flags & (ITEM_LINKED|ITEM_SLABBED)) == 0);
mutex_lock(&cache_lock);
it->it_flags |= ITEM_LINKED;
it->time = current_time;
STATS_LOCK();
stats.curr_bytes += ITEM_ntotal(it);
stats.curr_items += 1;
stats.total_items += 1;
STATS_UNLOCK();
/* Allocate a new CAS ID on link. */
ITEM_set_cas(it, (settings.use_cas) ? get_cas_id() : 0);
assoc_insert(it, hv);//将该item指针插入到hash表的对应bucket的头部（正常情况下插入到主表，扩容时插入到原表）
item_link_q(it);//将该item指针插入到对应slab的头部
refcount_incr(&it->refcount);//递增引用计数
mutex_unlock(&cache_lock);
return 1;
}
//将该item从哈希表 lru队列中删除，递减引用计数
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) {
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);//在哈希表中删除该item
item_unlink_q(it);//在slab中删除该item
do_item_remove(it);//如果item引用计数减到0，则释放，挂载到slots头部
}
mutex_unlock(&cache_lock);
}
//item引用计数为0，则释放
void do_item_remove(item *it) {
MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes);
assert((it->it_flags & ITEM_SLABBED) == 0);
assert(it->refcount > 0);
if (refcount_decr(&it->refcount) == 0) {
item_free(it);
}
}
//注意：避免过于频繁的获取该item带来的性能影响，设定最小更新时间ITEM_UPDATE_INTERVAL：
//即至少要这么久才更新一次该item在lru中的位置
//先从lru链表删除，然后更新访问时间，最后在插入到lru的头部
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) {
item_unlink_q(it);//从lru链表删除
it->time = current_time;//更新最近访问时间
item_link_q(it);//更新位置：放到lru头部
}
mutex_unlock(&cache_lock);
}
}
//以新的item替换给定的item（哈希表 lru）
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);
do_item_unlink(it, hv);//将旧的item从哈希表 lru队列去掉
return do_item_link(new_it, hv);//将该新的item加入哈希表 lru中
}
//如果该item过期则返回NULL，且同时在哈希表、lru中删除。（get中体现的正是惰性删除机制）
item *do_item_get(const char *key, const size_t nkey, const uint32_t hv) {
//mutex_lock(&cache_lock);
item *it = assoc_find(key, nkey, hv);//在哈希表中查找该item，然后利用该item的clsid信息去lru中查找该item
if (it != NULL) {
refcount_incr(&it->refcount);
/* Optimization for slab reassignment. prevents popular items from
* jamming in busy wait. Can only do this here to satisfy lock order
* of item_lock, cache_lock, slabs_lock. */
if (slab_rebalance_signal &&
((void *)it >= slab_rebal.slab_start && (void *)it < slab_rebal.slab_end)) {
do_item_unlink_nolock(it, hv);
do_item_remove(it);//递减引用计数
it = NULL;
}
}
//mutex_unlock(&cache_lock);
int was_found = 0;
if (settings.verbose > 2) {
int ii;
if (it == NULL) {
fprintf(stderr, "> NOT FOUND ");
} else {
fprintf(stderr, "> FOUND KEY ");
was_found++;
}
for (ii = 0; ii < nkey; ++ii) {
fprintf(stderr, "%c", key[ii]);
}
}
if (it != NULL) {
if (settings.oldest_live != 0 && settings.oldest_live <= current_time &&
it->time <= settings.oldest_live) {//超过最大生存时间，则从lru中删除
do_item_unlink(it, hv);
do_item_remove(it);
it = NULL;
if (was_found) {
fprintf(stderr, " -nuked by flush");
}
} else if (it->exptime != 0 && it->exptime <= current_time) {//过期
do_item_unlink(it, hv);
do_item_remove(it);
it = NULL;
if (was_found) {
fprintf(stderr, " -nuked by expire");
}
} else {
it->it_flags |= ITEM_FETCHED;
DEBUG_REFCNT(it, '+');
}
}
if (settings.verbose > 2)
fprintf(stderr, "\n");
return it;
}
经过前面的几节分析，到此对于Memcached中的内存操作，数据item的存储体系即基本存取操作等基础部分的剖析已完成。
接下来将主要分析Memcached中的核心部分：I/O框架库Libevent的具体应用，以及多线程的处理机制等。这部分也正是前段时间刚接触的内容，因此接下来将给出更为详细的讲解。