Memcached源码分析之do_item_alloc操作

小fish

　　前面我们分析了Memcached的set操作，其set操作在经过所有的数据有效性检查之后，如果需要存储item，则会执行item的实际存储操作，我们下面分析下其过程。
　　

//执行item的存储操作,该操作会将item挂载到LRU表和slabcalss中
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;
item *it = NULL;
char suffix[40];
size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix);//计算item的总大小(空间)
if (settings.use_cas) {//如果使用了cas
ntotal += sizeof(uint64_t);//增加cas的空间
}
unsigned int id = slabs_clsid(ntotal);//那大小选择合适的slab
if (id == 0)
return 0;
mutex_lock(&cache_lock);//执行LRU锁
//存储时，会尝试从LRU中选择合适的空间的空间
int tries = 5;//如果LRU中尝试5次还没合适的空间，则执行申请空间的操作
int tried_alloc = 0;
item *search;
void *hold_lock = NULL;
rel_time_t oldest_live = settings.oldest_live;//初始化时选择的过期时间
search = tails[id];//第id个LRU表的尾部
for (; tries > 0 && search != NULL; tries--, search=search->prev) {
uint32_t hv = hash(ITEM_key(search), search->nkey, 0);//获取分段锁
if (hv != cur_hv && (hold_lock = item_trylock(hv)) == NULL)//尝试执行锁操作，这里执行的乐观锁
continue;
if (refcount_incr(&search->refcount) != 2) {//判断item是否被锁住，item的引用次数其实充当的也是一种锁
refcount_decr(&search->refcount);//更新it的引用次数
            //如果it的添加时间比当前时间小于3*3600
            if (search->time + 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);//执行分段解锁操作
continue;
}
//过期时间判断
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);//slabclass申请合适的空间
do_item_unlink_nolock(it, hv);//执行的Hash表的分段解锁操作
it->slabs_clsid = 0;
} else if ((it = slabs_alloc(ntotal, id)) == NULL) {//申请合适的slabclass
tried_alloc = 1;//申请失败一次
if (settings.evict_to_free == 0) {//关闭了LRU的
itemstats[id].outofmemory++;//统计信息更新
} else {//打开了LRU的操作
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);//选择合适的slabclass空间
do_item_unlink_nolock(it, hv);//执行it的分段解锁操作
it->slabs_clsid = 0;
if (settings.slab_automove == 2)//如果打开了slab调整
slabs_reassign(-1, id);//唤醒调整线程
}
}
refcount_decr(&search->refcount);//更新引用次数
if (hold_lock)
item_trylock_unlock(hold_lock);//解分段锁
break;
}
if (!tried_alloc && (tries == 0 || search == NULL))//5次循环查找，未找到合适的空间
it = slabs_alloc(ntotal, id);//则从内存池申请新的空间
if (it == NULL) {//内存池申请失败
itemstats[id].outofmemory++;//更新统计信息
mutex_unlock(&cache_lock);//释放LRU锁
return NULL;
}
assert(it->slabs_clsid == 0);
assert(it != heads[id]);
    it->refcount = 1;     //更新it的引用次数
mutex_unlock(&cache_lock);
it->next = it->prev = it->h_next = 0;//执行初始化操作
it->slabs_clsid = id;//it所属的slabclass为第id个
DEBUG_REFCNT(it, '*');
it->it_flags = settings.use_cas ? ITEM_CAS : 0;
it->nkey = nkey;//it的key
it->nbytes = nbytes;//it的缓冲区的数据
memcpy(ITEM_key(it), key, nkey);//it的数据信息
it->exptime = exptime;//it的过期时间
memcpy(ITEM_suffix(it), suffix, (size_t)nsuffix);//it的前缀信息
it->nsuffix = nsuffix;//it的一些前缀信息
return it;
}
//计算item的大小
static size_t item_make_header(const uint8_t nkey, const int flags, const int nbytes,
                     char *suffix, uint8_t *nsuffix) {
    //suffix限定了40个字节
    *nsuffix = (uint8_t) snprintf(suffix, 40, &quot; %d %d\r\n&quot;, flags, nbytes - 2);
    return sizeof(item) + nkey + *nsuffix + nbytes;//返回item的长度
}
//选择合适的slabclass
unsigned int slabs_clsid(const size_t size) {
    int res = POWER_SMALLEST;
    if (size == 0)
        return 0;
    while (size > slabclass[res].size)//按slabclass的size的选择
        if (res++ == power_largest)//如果大于最大的slab的，则直接返回错误，按默认的，大于1M的申请空间失败   
            return 0;
    return res;
}
//从内存池申请合适的空间
void slabs_adjust_mem_requested(unsigned int id, size_t old, size_t ntotal)
{
    pthread_mutex_lock(&slabs_lock);//slabclass加锁，保持同步
    slabclass_t *p;
    if (id < POWER_SMALLEST || id > power_largest) {//判断数据合法性
        fprintf(stderr, &quot;Internal error! Invalid slab class\n&quot;);
        abort();
    }
    p = &slabclass[id];
    p->requested = p->requested - old + ntotal;//调整request信息，request表示的是old所在的slab申请空间大小
    pthread_mutex_unlock(&slabs_lock);
}



　　

版权声明：本文为博主原创文章，未经博主允许不得转载。