Memcache源码阅读（4）---内存管理

拼搏现实的明天。 2022-07-13 01:13 198阅读 0赞

我看的源码版本是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的简图 ###

![memcached\_slabclass\_simple][memcached_slabclass_simple]  
注：这个图是简化版的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;

![memcached\_slabclass\_detail][memcached_slabclass_detail]  
这里蓝色的表示已经被用户使用过的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;
    }

[memcached_slabclass_simple]: http://7xqdjj.com1.z0.glb.clouddn.com/memcached_slabclass_simple.png
[memcached_slabclass_detail]: http://7xqdjj.com1.z0.glb.clouddn.com/memcached_slabclass_detail.png