我看的原始碼版本是1.2.4

memcached的儲存

memcached擁有一個記憶體池，記憶體池中的記憶體分成多種大小的chunk，chunk的大小有一個基礎大小（最小的chunk大小，base chunk size），然後後面大小的是以settings.factor為因子不斷的增大。比如說base chunk size為64byte， setting.factor = 1.5,那麼memcached擁有的chunk size有64byte, 64 * 1.5 = 96byte, 96 * 1.5 = 144byte, … 一直到頁的大小的1/2。

需要儲存資料的時候，從slab中找一個最小匹配的chunk來儲存資料。比如說，我現在有個資料大小是112byte，那麼memcached就會找一個最小的、能容下這個資料的chunk來儲存這個資料（144byte）。

這樣做雖然有記憶體浪費，但是好處是不需要管理記憶體碎片的問題。

slabclass_t的簡圖

注：這個圖是簡化版的slabclass，我將slab_list看為一個管理著chunk的陣列，事實上，他只是管理著多個slab，slab再管理著chunk而已。

如上圖，使用者向slabclass請求記憶體，memcached先會到對應大小到的slabclass_t中檢視slot是否有空閒chunk，如果有的話，就從空閒陣列中分配；沒有，則會從slab中分配一個沒用過的。當用戶釋放slab分配的chunk時，則會將它放到slabclass_t的slot裡。

slab的結構

slab的結構體

typedef struct {
    unsigned int size;      /* sizes of items */ //就是chunk的大小
    unsigned int perslab;   /* how many items per slab */ //每個slab中有多少個chunk，它會管理著一個slab_list，slab_list裡面有多個slab，每個slab管理著perslab個chunk

    void **slots;           /* list of item ptrs */ //指向空閒陣列，回收釋放的chunk
    unsigned int sl_total;  /* size of previous array */
 
 //空閒陣列的大小
    unsigned int sl_curr;   /* first free slot */ //指向第一個沒有回收chunk的空閒陣列。

    void *end_page_ptr;         /* pointer to next free item at end of page, or 0 */
    unsigned int end_page_free; /* number of items remaining at end of last alloced page */

    unsigned int slabs;     /* how many slabs were allocated for this class */

    void **slab_list;       /* array of slab pointers */
    unsigned int list_size; /* size of prev array */

    unsigned int killing;  /* index+1 of dying slab, or zero if none */
} slabclass_t;

這裡藍色的表示已經被使用者使用過的chunk，即使它被使用者釋放，它只會放到slot中，end_page_ptr並不會管理那些申請了的後來被使用者釋放的chunk，end_page_ptr指向第一個還沒被用過的chunk。

slabs初始化

slabs_init(settings.maxbytes, settings.factor);

#define POWER_SMALLEST 1
#define POWER_LARGEST  200
#define POWER_BLOCK 1048576   //1 M
#define CHUNK_ALIGN_BYTES (sizeof(void *))

static slabclass_t slabclass[POWER_LARGEST + 1]; 
static size_t mem_limit = 0;
static size_t mem_malloced = 0;
static int power_largest;

void slabs_init(const size_t limit, const double factor) {
    int i = POWER_SMALLEST - 1;
    unsigned int size = sizeof(item) + settings.chunk_size;  //這裡是對使用者設定的大小加大一個item結構體的大小，因為儲存資料的時候，使用者資料是存在item結構體之後，item結構體記錄著這個資料的一些資訊。

    /* Factor of 2.0 means use the default memcached behavior */
    if (factor == 2.0 && size < 128)
        size = 128;

    mem_limit = limit;
    memset(slabclass, 0, sizeof(slabclass));

    while (++i < POWER_LARGEST && size <= POWER_BLOCK / 2) {
        /* 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[i].perslab = POWER_BLOCK / slabclass[i].size;
        size *= factor;
    }

    power_largest = i;
    slabclass[power_largest].size = POWER_BLOCK;
    slabclass[power_largest].perslab = 1;

}

預設情況下這樣就初始化完了，設定好了slabclass的資訊，沒有給slabs真正開闢儲存空間。當用戶向slabclass申請空間的時候，memcached發現slab沒有可用空間再向系統申請空間。那我們看看初始化時到底是如何給slabs分配記憶體空間的，memcached發現slab沒有可用空間時申請記憶體空間的方式跟這個也類似。

初始化時預先分配slabs

//為每個chunk size大小的slab_class分配空間
static void slabs_preallocate (const unsigned int maxslabs) {
    int i;
    unsigned int prealloc = 0;

    for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) {
        if (++prealloc > maxslabs)
            return;
        do_slabs_newslab(i);
    }
}

//為第i個slab_class分配空間，分配失敗的時候返回0，成功返回1
static int do_slabs_newslab(const unsigned int id) {
    slabclass_t *p = &slabclass[id];
    int len = p->size * p->perslab;
    char *ptr;

    if (mem_limit && mem_malloced + len > mem_limit && p->slabs > 0)
        return 0;
    //grow slab list返回0的時候是失敗
    if (grow_slab_list(id) == 0) return 0;

    ptr = malloc((size_t)len);
    if (ptr == 0) return 0;

    memset(ptr, 0, (size_t)len);
    //指向第一個沒有分配的chunk，slab分配chunk是從slab_list裡順序分配的。
    p->end_page_ptr = ptr;
    p->end_page_free = p->perslab;
    //為每個slab分配一個1M的page
    p->slab_list[p->slabs++] = ptr;
    mem_malloced += len;
    return 1;
}

//為slab_list新增一個slab，需要看看slab_list是否已滿。
//如果滿了，就需要分配更大的slab_list來裝下slabs。如果滿了，重新分配空間失敗返回0。
static int grow_slab_list (const unsigned int id) {
    slabclass_t *p = &slabclass[id];
    if (p->slabs == p->list_size) {
        size_t new_size =  (p->list_size != 0) ? p->list_size * 2 : 16;
        void *new_list = realloc(p->slab_list, new_size * sizeof(void *));
        if (new_list == 0) return 0;
        p->list_size = new_size;
        p->slab_list = new_list;
    }
    return 1;
}

為使用者從slab中找個合適大小的chunk

void *do_slabs_alloc(const size_t size) {
    slabclass_t *p;
    //找到最小的能裝下size的slab
    unsigned int id = slabs_clsid(size);
    p = &slabclass[id];

    //如果slot中又空閒的chunk，那就從slot中取一個
    /* return off our freelist, if we have one */
    if (p->sl_curr != 0)
        return p->slots[--p->sl_curr];
    //否則我們就從slab_list中取一個
    /* if we recently allocated a whole page, return from that */
    if (p->end_page_ptr) {
        void *ptr = p->end_page_ptr;
        if (--p->end_page_free != 0) {
            p->end_page_ptr += p->size;
        } else {
            p->end_page_ptr = 0;
        }
        return ptr;
    }
    return NULL;  /* shouldn't ever get here */
}

使用者釋放chunk

void do_slabs_free(void *ptr, const size_t size) {
    unsigned char id = slabs_clsid(size);
    slabclass_t *p;
    p = &slabclass[id];
    //如果slot中已經裝滿了空閒chunk，那麼就得給slot分配一個更大的陣列，否則直接將空閒chunk放到slot中
    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;
    return;
}