typedef struct _stritem {
    struct _stritem *next;      /* 前后指针用于在链表slab->slots中连接前后数据 */
    struct _stritem *prev;
    struct _stritem *h_next;    /* hash chain next */
    rel_time_t      time;       /* 最后一次访问时间 */
    rel_time_t      exptime;    /* 过期时间 */
    int             nbytes;     /* 数据大小 */
    unsigned short  refcount;   /* 引用次数 */
    uint8_t         nsuffix;    /* suffix长度 */
    uint8_t         it_flags;   /* ITEM_* above */
    uint8_t         slabs_clsid;/* 所有slab的id */
    uint8_t         nkey;       /* key长度 */
    /* this odd type prevents type-punning issues when we do
     * the little shuffle to save space when not using CAS. */
    union {
        uint64_t cas;
        char end;
    } data[]; /* cas|key|suffix|value */
} item;

void slabs_init(const size_t limit, const double factor, const bool prealloc) {
    int i = POWER_SMALLEST - 1;
    unsigned int size = sizeof(item) + settings.chunk_size; /* 得到每一个item的大小 */

    mem_limit = limit;

    if (prealloc) { /* 预分配一块内存 */
        ...
    }

    memset(slabclass, 0, sizeof(slabclass)); /* 把slabclass置为0，slabclass是一个slab数组，存储所有slab的信息 */

    while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {  /* 循环初始化每一个slab的内容,保证slab中item的size小于max_size/factor */
        /* Make sure items are always n-byte aligned */
        if (size % CHUNK_ALIGN_BYTES)  /* 用于内存对齐 */
            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);

        slabclass[i].size = size; /* 初始化slabclass中item的大小 */
        slabclass[i].perslab = settings.item_size_max / slabclass[i].size; /* 初始化每个slab中item的数量 */
        size *= factor;  /* item的大小随factor逐渐增大 */
        ...
    }
    /* 初始化最后一个slab,大小为最大的max_size，只有一个item */
    power_largest = i;
    slabclass[power_largest].size = settings.item_size_max;
    slabclass[power_largest].perslab = 1;
    ...
}

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]; /* 获取slab */
    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 */
    if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) { /*如果sl_curr为0，没有剩余的item，那么就执行do_slabs_newslab申请内存空间*/
        /* We don‘t have more memory available */
        ret = NULL;
    } else if (p->sl_curr != 0) { /* 如果有未使用的空间，则获取该item，并从slots链表中删除该item */
        /* return off our freelist */
        it = (item *)p->slots;
        p->slots = it->next;
        if (it->next) it->next->prev = 0;
        p->sl_curr--;
        ret = (void *)it;
    }
    ...
    return ret;
}

static int do_slabs_newslab(const unsigned int id) {
    slabclass_t *p = &slabclass[id];
    int len = settings.slab_reassign ? settings.item_size_max
        : p->size * p->perslab;
    char *ptr;
    /* 1. 判断是否超过内存限制
         2. 判断是否申请过内存空间
         3. 如果没有申请过，则申请slab->size*slab->perslab大小的整块内存
         4.如果申请过，调用grow_slab_list来扩大slab大小 */
    if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0) ||
        (grow_slab_list(id) == 0) ||
        ((ptr = memory_allocate((size_t)len)) == 0)) {

        MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
        return 0;
    }

    memset(ptr, 0, (size_t)len);
    split_slab_page_into_freelist(ptr, id); /* 把申请的内存分配到slots链表中 */

    p->slab_list[p->slabs++] = ptr;
    mem_malloced += len;
    MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);

    return 1;
}

static void split_slab_page_into_freelist(char *ptr, const unsigned int id) {
    slabclass_t *p = &slabclass[id];
    int x;
    for (x = 0; x < p->perslab; x++) { /* 循环分配内存 */
        do_slabs_free(ptr, 0, id);
        ptr += p->size;
    }
}

static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
    slabclass_t *p;
    item *it;
    ...
    p = &slabclass[id];
    /* 获取内存指针，把item块挂在到slots链表中，增加sl_curr */
    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;
}

unsigned int slabs_clsid(const size_t size) {
    int res = POWER_SMALLEST;

    if (size == 0)
        return 0;
    while (size > slabclass[res].size)    /* 遍历slabclass来找到适合size的item */
        if (res++ == power_largest)     /* won‘t fit in the biggest slab */
            return 0;
    return res;
}