//创建或回收空闲的item
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的状态标识，修改为空闲
/* 采用倒插法插入subclass_t->slots中 */
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;
}
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
assert(((item *)ptr)->slabs_clsid == 0);
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
#ifdef USE_SYSTEM_MALLOC
mem_malloced -= size;
free(ptr);
return;
#endif
if (p->sl_curr == p->sl_total) { /* need more space on the free list */
int new_size = (p->sl_total != 0) ? p->sl_total * 2 : 16; /* 16 is arbitrary */
void **new_slots = realloc(p->slots, new_size * sizeof(void *));
if (new_slots == 0)
return;
p->slots = new_slots;
p->sl_total = new_size;
}
p->slots[p->sl_curr++] = ptr;
p->requested -= size;
return;
}
// 就是将ptr初始化成一个item放在slots的前面
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
item *it;
// free后的item的slabclassid是0，以此来判断是否已经free掉
assert(((item *)ptr)->slabs_clsid == 0);
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
// trace 信息
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
it = (item *)ptr;
// 只有free过的item才设置SLABBED标志
it->it_flags |= ITEM_SLABBED;
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
p->sl_curr++;
p->requested -= size;
return;
}
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);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
#ifdef USE_SYSTEM_MALLOC
mem_malloced -= size;
free(ptr);
return;
#endif
it = (item *)ptr;
it->it_flags |= ITEM_SLABBED;
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
p->sl_curr++;
p->requested -= size;
return;
}
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);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
it = (item *)ptr;
//为item的it_flags添加ITEM_SLABBED属性，标明这个item是在slab中没有被分配出去
it->it_flags |= ITEM_SLABBED;
//由split_slab_page_into_freelist调用时，下面4行的作用是
//让这些item的prev和next相互指向，把这些item连起来.
//当本函数是在worker线程向内存池归还内存时调用，那么下面4行的作用是,
//使用链表头插法把该item插入到空闲item链表中。
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;//slot变量指向第一个空闲可以使用的item
p->sl_curr++;//空闲可以使用的item数量
p->requested -= size;//减少这个slabclass_t分配出去的字节数
return;
}
static void do_slabs_free(struct default_engine *engine, void *ptr, const size_t size, unsigned int id)
{
slabclass_t *p;
if (size <= MAX_SM_VALUE_SIZE) {
do_smmgr_free(engine, ptr, size);
return;
}
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &engine->slabs.slabclass[id];
#ifdef USE_SYSTEM_MALLOC
engine->slabs.mem_malloced -= size;
free(ptr);
return;
#endif
if (p->sl_curr == p->sl_total) { /* need more space on the free list */
int new_size = (p->sl_total != 0) ? p->sl_total * 2 : 16; /* 16 is arbitrary */
void **new_slots = realloc(p->slots, new_size * sizeof(void *));
if (new_slots == 0)
return;
p->slots = new_slots;
p->sl_total = new_size;
}
p->slots[p->sl_curr++] = ptr;
p->requested -= size;
return;
}
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
item *it;
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
it = (item *)ptr;
if ((it->it_flags & ITEM_CHUNKED) == 0) {
it->it_flags = ITEM_SLABBED;
it->slabs_clsid = 0;
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
p->sl_curr++;
p->requested -= size;
} else {
do_slabs_free_chunked(it, size);
}
return;
}
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
assert(((item *)ptr)->slabs_clsid == 0);
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
#ifdef USE_SYSTEM_MALLOC
mem_malloced -= size;
free(ptr);
return;
#endif
#ifdef TEST_LRU
item *it = (item *)ptr;
//it->it_flags |= ITEM_SLABBED;
__sync_fetch_and_or(&it->it_flags, ITEM_SLABBED);
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
#endif
#ifdef TEST_CLOCK
slabbed_item *sl_it = (slabbed_item *)ptr;
//sl_it->it_flags |= ITEM_SLABBED;
__sync_fetch_and_or(&sl_it->it_flags, ITEM_SLABBED);
sl_it->prev = 0;
sl_it->next = p->slots;
if (sl_it->next) sl_it->next->prev = sl_it;
p->slots = sl_it;
#endif
p->sl_curr++;
p->requested -= size;
return;
}
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
assert(((item *)ptr)->slabs_clsid == 0);
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
#ifdef HOPSCOTCH_CLOCK
slabbed_item *sl_it = (slabbed_item *)ptr;
__sync_fetch_and_or(&sl_it->it_flags, ITEM_SLABBED);
DBG_INFO(DBG_ASSOC_HOPSCOTCH, "%s:%d: it_flags = %u\n", __func__, __LINE__,
sl_it->it_flags);
// TODO: This is not done in memc3
//sl_it->slabs_clsid = 0;
sl_it->prev = 0;
sl_it->next = p->slots;
if (sl_it->next)
sl_it->next->prev = sl_it;
p->slots = sl_it;
#else
item *it = (item *)ptr;
it->it_flags |= ITEM_SLABBED;
it->slabs_clsid = 0;
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
#endif
p->sl_curr++;
p->requested -= size;
return;
}
//创建空闲链表
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);
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++; // chunk可用数增1
p->requested -= size;
return;
}
//把 ptr 指向的 item 归还给 slabclass[id]操作很简单, 把 ptr 指向的 item 挂在 slots 空闲链表的最前面
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);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
/* 把 item 归还给slots指向的空闲链表, 插在链表的最前面 */
it = (item *)ptr;
it->it_flags |= ITEM_SLABBED;
it->prev = 0;
it->next = p->slots;
if (it->next) it->next->prev = it;
p->slots = it;
p->sl_curr++;
p->requested -= size;
return;
}
