void item_update(item *it) {
assert((it->it_flags & ITEM_SLABBED) == 0);
item_unlink_q(it);
it->time = current_time;
item_link_q(it);
}
void item_unlink(item *it) {
it->it_flags &= ~ITEM_LINKED;
assoc_delete(it->key);
item_unlink_q(it);
stats.curr_bytes -= it->ntotal;
stats.curr_items -= 1;
if (it->usecount == 0) free(it);
return;
}
void do_item_update(item *it) {
if (it->time < now_ms - ITEM_UPDATE_INTERVAL) {
if ((it->it_flags & ITEM_LINKED) != 0) {
item_unlink_q(it);
it->time = now_ms;
item_link_q(it);
}
}
}
void LRU_list::do_item_unlink_nolock(base_item* it, const uint32_t hv) {
if ((it->item_flag & Slab::ITEM_LINKED) != 0){
it->item_flag &= ~(Slab::ITEM_LINKED);
//省去状态更迭
hashtable.hash_delete(it->data, it->nkey, hv);
item_unlink_q(it);
do_item_remove(it);
}
}
static void _item_touch(struct item *it) {
assert(it->magic == ITEM_MAGIC);
assert(!item_is_slabbed(it));
if (it->atime >= (time_now() - ITEM_UPDATE_INTERVAL)) {
return;
}
assert(item_is_linked(it));
item_unlink_q(it);
item_link_q(it, false);
}
void item_reuse(struct item *it) {
assert(pthread_mutex_trylock(&cache_lock) != 0);
assert(it->magic == ITEM_MAGIC);
assert(!item_is_slabbed(it));
assert(item_is_linked(it));
assert(it->refcount == 0);
it->flags &= ~ITEM_LINKED;
assoc_delete(item_key(it), it->nkey);
item_unlink_q(it);
}
void item_unlink(item *it) {
if (it->it_flags & ITEM_LINKED) {
it->it_flags &= ~ITEM_LINKED;
stats.curr_bytes -= ITEM_ntotal(it);
stats.curr_items -= 1;
assoc_delete(ITEM_key(it));
item_unlink_q(it);
}
if (it->refcount == 0) item_free(it);
}
void do_item_update(item *it) {
if (it->time < current_time - ITEM_UPDATE_INTERVAL) {
assert((it->it_flags & ITEM_SLABBED) == 0);
if ((it->it_flags & ITEM_LINKED) != 0) {
item_unlink_q(it);
it->time = current_time;
item_link_q(it);
}
}
}
void do_item_unlink(item *it) {
// MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nbytes);
if ((it->it_flags & ITEM_LINKED) != 0) {
it->it_flags &= ~ITEM_LINKED;
stats.curr_bytes -= ITEM_ntotal(it);
stats.curr_items--;
assoc_delete(ITEM_key(it), it->nkey);
item_unlink_q(it);
if (it->refcount == 0) item_free(it);
}
}
static void _item_unlink(struct item *it) {
assert(it->magic == ITEM_MAGIC);
assert(item_is_linked(it));
if (item_is_linked(it)) {
it->flags &= ~ITEM_LINKED;
assoc_delete(item_key(it), it->nkey);
item_unlink_q(it);
if (it->refcount == 0) {
item_free(it);
}
}
}
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);
if ((it->it_flags & ITEM_LINKED) != 0) {
item_unlink_q(it);
it->time = current_time;
item_link_q(it);
}
}
}
void do_item_unlink(item *it) {
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);
item_unlink_q(it);
if (it->refcount == 0) item_free(it);
}
}
void do_item_update(struct default_engine *engine, hash_item *it) {
rel_time_t current_time = engine->server.core->get_current_time();
MEMCACHED_ITEM_UPDATE(item_get_key(it), it->nkey, it->nbytes);
if (it->time < current_time - ITEM_UPDATE_INTERVAL) {
assert((it->iflag & ITEM_SLABBED) == 0);
if ((it->iflag & ITEM_LINKED) != 0) {
item_unlink_q(engine, it);
it->time = current_time;
item_link_q(engine, it);
}
}
}
/* slawek */
void do_item_unlink_nolock_nostat(item *it, const uint32_t hv, uint64_t *items_removed, uint64_t *bytes_removed) {
MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes);
if ((it->it_flags & ITEM_LINKED) != 0) {
it->it_flags &= ~ITEM_LINKED;
*items_removed += 1;
*bytes_removed += ITEM_ntotal(it);
assoc_delete(ITEM_key(it), it->nkey, hv);
item_unlink_q(it);
do_item_remove(it);
}
}
/* FIXME: Is it necessary to keep this copy/pasted code? */
void do_item_unlink_nolock(item *it, const uint32_t hv) {
MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes);
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_unlink_q(it);
do_item_remove(it);
}
}
void LRU_list::do_item_update(base_item* item) {
if (item->realtime < current_time() - ITEM_UPDATE_INTERVAL) {
if ((item->item_flag & Slab::ITEM_SLABBED) != 0) {
return;
}
mutex_lock(&cache_lock);
if ((item->item_flag & Slab::ITEM_LINKED) != 0){
item_unlink_q(item);
item->realtime = current_time();
item_link_q(item);
}
cache_lock.unlock();
}
}
/* FIXME: Is it necessary to keep this copy/pasted code? */
void do_item_unlink_nolock(item *it, const uint32_t hv) {
syslog(LOG_INFO, "[%s:%s:%d]", __FILE__, __func__, __LINE__);
MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes);
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_unlink_q(it);
do_item_remove(it);
}
}
//unlink是把item从hashtable上和LRU上移除
void LRU_list::do_item_unlink(base_item* it, uint32_t hv) {
mutex_lock(&cache_lock);
if ((it->item_flag & Slab::ITEM_LINKED) != 0) {
it->item_flag &= ~Slab::ITEM_LINKED;
//stats.stat_lock.lock();
//stats.curr_bytes -= sizeof(base_item);
//stats.curr_items -= 1;
//stats.stat_lock.unlock();
hashtable.hash_delete(it->data, it->nkey, hv);
item_unlink_q(it);
do_item_remove(it);
}
cache_lock.unlock();
}
void do_item_update(item *it) {
syslog(LOG_INFO, "[%s:%s:%d]", __FILE__, __func__, __LINE__);
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);
it->time = current_time;
item_link_q(it);
}
mutex_unlock(&cache_lock);
}
}
void do_item_unlink(item *it) {
MEMCACHED_ITEM_UNLINK(ITEM_key(it), it->nkey, it->nbytes);
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);
item_unlink_q(it);
#ifndef MOXI_ITEM_MALLOC
if (it->refcount == 0) item_free(it);
#endif
}
}
//将item从hashtable和LRU链中移除,而且还释放掉 item 所占的内存 (其实只是把 item 放到空闲链表中),是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);
}
void do_item_unlink(item *it, const uint32_t hv) {
syslog(LOG_INFO, "[%s:%s:%d]", __FILE__, __func__, __LINE__);
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;//设置为非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); //从LRU链中删除
do_item_remove(it);
}
mutex_unlock(&cache_lock);
}
/* Copy/paste to avoid adding two extra branches for all common calls, since
* _nolock is only used in an uncommon case. */
void do_item_update_nolock(item *it) {
#ifdef CLOCK_REPLACEMENT
if (it->recency == 0) it->recency = 1;
#else
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);
if ((it->it_flags & ITEM_LINKED) != 0) {
item_unlink_q(it);
it->time = current_time;
item_link_q(it);
}
}
#endif
}
void do_item_unlink(struct default_engine *engine, hash_item *it) {
MEMCACHED_ITEM_UNLINK(item_get_key(it), it->nkey, it->nbytes);
if ((it->iflag & ITEM_LINKED) != 0) {
it->iflag &= ~ITEM_LINKED;
pthread_mutex_lock(&engine->stats.lock);
engine->stats.curr_bytes -= ITEM_ntotal(engine, it);
engine->stats.curr_items -= 1;
pthread_mutex_unlock(&engine->stats.lock);
assoc_delete(engine, engine->server.core->hash(item_get_key(it),
it->nkey, 0),
item_get_key(it), it->nkey);
item_unlink_q(engine, it);
if (it->refcount == 0) {
item_free(engine, it);
}
}
}
static bool do_item_walk_cursor(struct default_engine *engine,
hash_item *cursor,
int steplength,
ITERFUNC itemfunc,
void* itemdata,
ENGINE_ERROR_CODE *error)
{
int ii = 0;
*error = ENGINE_SUCCESS;
while (cursor->prev != NULL && ii < steplength) {
/* Move cursor */
hash_item *ptr = cursor->prev;
bool done = false;
++ii;
item_unlink_q(engine, cursor);
if (ptr == engine->items.heads[cursor->slabs_clsid]) {
done = true;
cursor->prev = NULL;
} else {
cursor->next = ptr;
cursor->prev = ptr->prev;
cursor->prev->next = cursor;
ptr->prev = cursor;
}
/* Ignore cursors */
if (item_get_key(ptr)->header.len == 0 && ptr->nbytes == 0) {
--ii;
} else {
*error = itemfunc(engine, ptr, itemdata);
if (*error != ENGINE_SUCCESS) {
return false;
}
}
if (done) {
return false;
}
}
return (cursor->prev != NULL);
}
//按访问时间，更新在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) {
//从LUR中删除
item_unlink_q(it);
//更新访问时间
it->time = current_time;
//插入到LRU队列头部
item_link_q(it);
}
mutex_unlock(&cache_lock);
}
}
//从哈希表和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_unlink_q(it);
//向slab归还这个item
do_item_remove(it);
}
mutex_unlock(&cache_lock);
}
//更新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);//保持同步
//更新LRU队列的Item ,先删除，然后在添加，相当于刚刚使用
if ((it->it_flags & ITEM_LINKED) != 0)
{
item_unlink_q(it);//断开连接
it->time = current_time;//更新item的时间
item_link_q(it);//重新添加
}
mutex_unlock(&cache_lock);
}
}
void do_item_unlink(struct default_engine *engine, hash_item *it) {
const hash_key* key = item_get_key(it);
MEMCACHED_ITEM_UNLINK(hash_key_get_client_key(key),
hash_key_get_client_key_len(key),
it->nbytes);
if ((it->iflag & ITEM_LINKED) != 0) {
it->iflag &= ~ITEM_LINKED;
cb_mutex_enter(&engine->stats.lock);
engine->stats.curr_bytes -= ITEM_ntotal(engine, it);
engine->stats.curr_items -= 1;
cb_mutex_exit(&engine->stats.lock);
assoc_delete(engine, crc32c(hash_key_get_key(key),
hash_key_get_key_len(key), 0),
key);
item_unlink_q(engine, it);
if (it->refcount == 0 || engine->scrubber.force_delete) {
item_free(engine, it);
}
}
}
void item_update(item *it) {
item_unlink_q(it);
item_link_q(it);
}