本次笔记未涉及到slab的动态重新平衡分配

/**首先介绍一下一个跟内存相关的非常重要的概念，内存块类型数据结构:*/typedef struct {    unsigned int size;      /* chunk的大小 sizes of items */    unsigned int perslab;   /* 整个slab有chunk的数量 how many items per slab */     void *slots;            /* item串起来的链表 list of item ptrs */    unsigned int sl_curr;   /* 当前slabclass 有多少可用的 chunk total free items in list */     unsigned int slabs;     /* 之前已经分配这种类型slab的数量 how many slabs were allocated for this class */     void **slab_list;       /* 同类型的slab构成一个数组 array of slab pointers */    unsigned int list_size; /* 已经分配空间的slab_list的数组长度，实际使用数量为slabs  size of prev array */     unsigned int killing;   /* index+1 of dying slab, or zero if none */    size_t requested;       /* 已经被申请使用的字节数 The number of requested bytes */} slabclass_t; static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES]; /** 全局变量存储了系统所有的slab块类型*/ static size_t mem_limit = 0;static size_t mem_malloced = 0;static int power_largest; /** 记录有多少种slab块类型*/ static void *mem_base = NULL; /** 指向最初向系统申请的那大片空间，默认64M*/static void *mem_current = NULL; /** 指向当前系统申请大片空间的首地址*/static size_t mem_avail = 0;    /** 统计系统申请的大片空间还有多少字节可以用*/ /* * Figures out which slab class (chunk size) is required to store an item of * a given size. * * Given object size, return id to use when allocating/freeing memory for object * 0 means error: can't store such a large object */ /** * 计算出哪一个slab class 适合存储一个size长度的item, 返回0 表示无法存储这个item */unsigned int slabs_clsid(const size_t size) {    int res = POWER_SMALLEST;     if (size == 0)        return 0;    while (size > slabclass[res].size)        if (res++ == power_largest)     /* won't fit in the biggest slab */            return 0;    return res;} /** * Determines the chunk sizes and initializes the slab class descriptors * accordingly. */ /**  * 确定chunk的大小并初始化slab的类型  * @limit 总的申请的内存块的大小 默认为 64M  * @相邻slab 之间的chunck大小进阶因子，比如第一种slab_class1的chunk为48 bytes,第二种slab_class2的chunk大小就为48*factor,第三种48*factor^2...  */  /**   * slabs_init 主要逻辑,初始化内存块类型   * 首先理解一下memcached内存的划分逻辑，memcached在启动时会一次性向系统申请一大块内存，根据启动参数决定申请的大小，   * 默认为64M，之后便不再会向系统申请内存，而是在已申请的大块内存数组里面划分，少了系统调用，所以速度提高了。   * 获得一大块内存之后，memcached开始基于这块内存进行使用以及管理，首先是定义了内存块的概念，每一块默认大小为1M，   * 之后再对这一块内存进行划分为每一个chunk,每一个1M块里面的chunks都是一样大小的，不同的1M块包含的chunks的大小会有不同，   * 因此便有了块的类型，memcached 用一个数组来存储所有的类型slabclass, 默认类型不超过200种。那么memcached其实是用来存储   * key-value结构的，所以作为内存粒度最小的chunk自然就是用来存key-value了，将key-value进行包装一下用一个结构来表示，名称   * 为item，item就包含了一对key-value的信息，因此item所占的空间即长度就决定了需要用哪一种chunk来存储，不同的key-value所对应   * 的item长度自然是不一样，因而就需要不同大小的chunk来存储，也就是不同类型的slabclass.因而memcached引入了一个factor参数，   * 这个factor参数就是用来生成不同的slabclass，比如slabcalss[0]的chunk的大小为48bytes,则slabclass[1]的chunk大小则为48*factor bytes,   * factoe默认为1.25,所以相同大小的两块1M内存，slabclass[1]划分出来的chunk数量就比slabclass[0]要少，但是每个chunk比较大些，大点的   * 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; /** setting.chunk_size为默认的大小*/     mem_limit = limit;     if (prealloc) {        /* Allocate everything in a big chunk with malloc */        /** 一次性向系统申请一大块的内存*/        mem_base = malloc(mem_limit);        if (mem_base != NULL) {            mem_current = mem_base;            mem_avail = mem_limit;        } else {   fprintf(stderr, "Warning: Failed to allocate requested memory in"                    " one large chunk.\nWill allocate in smaller chunks\n");        }    }    /** 初始化slabclass数组*/    memset(slabclass, 0, sizeof(slabclass));     /**     * 初始化内存块的类型，默认最多200种     * setting.items_size_max就表示了一块内存默认大小为1M     */    while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {        /* 确定内存对齐? Make sure items are always n-byte aligned */        if (size % CHUNK_ALIGN_BYTES)            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);         /** slabclass.size 表示适合存储的item的大小, 这里似乎忽略了chunk的概念，其实chunk就是用来存item的*/        slabclass[i].size = size;        /** slabclass.perslab 表示这块1M内存会有多少个item*/        slabclass[i].perslab = settings.item_size_max / slabclass[i].size;         /** 下一种slabclass chunk的大小*/        size *= factor;        ...        }    }     /** 记录最终有多少种slabclass*/    power_largest = i;     /** 最后一种item的大小就是块的大小了，也就是item可能就是1M大小，一个1M内存块就存了1个item*/    slabclass[power_largest].size = settings.item_size_max;    slabclass[power_largest].perslab = 1;    ...     /* for the test suite:  faking of how much we've already malloc'd */    {        char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC");        if (t_initial_malloc) {            mem_malloced = (size_t)atol(t_initial_malloc);        }    }     /** 是否预分配*/    if (prealloc) {        slabs_preallocate(power_largest);    }} /** * 系统启动时预分配内存块的主要逻辑 * @spec maxslabs 表示有多少种slabclass * * 预分配的效果就是为每一种slabclass初始化一个slab块，并将slab块划分为对应大小的chunks * 预分配不是系统启动默认的，因为有可能分配的slab始终不会用到，浪费了存储空间，但是被用 * 到时由于已经分配好，直接可以使用，系统效率会高点，具体看存入的item实际大小的情况了 */ static void slabs_preallocate (const unsigned int maxslabs) {    int i;    unsigned int prealloc = 0;     /* pre-allocate a 1MB slab in every size class so people don't get       confused by non-intuitive "SERVER_ERROR out of memory"       messages.  this is the most common question on the mailing       list.  if you really don't want this, you can rebuild without       these three lines.  */    /**     * 为每一种slabclass预分配1个1M的块，并将其划分为对应大小的的chunks     */    for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) {        if (++prealloc > maxslabs)            return;        if (do_slabs_newslab(i) == 0) { /** 具体看do_slabs_newslab()注释*/            fprintf(stderr, "Error while preallocating slab memory!\n"                "If using -L or other prealloc options, max memory must be "                "at least %d megabytes.\n", power_largest);            exit(1);        }    } }/** 登记到某一种类型的slab_list数组中*/static int grow_slab_list (const unsigned int id) {    slabclass_t *p = &slabclass[id];    /** 如果数组没有空间再放多一个slab,就需要扩容数组*/    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 page 拆分(成小块)添加到可用链表-_- * 将(申请到的)内存首地址作为参数，根据id找到所属的slabclass类型， * 找到对应的chunk大小，将每一个chunk添加到slabclass的slot链表，具体由do_slabs_free()操作 */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; /** 指针移动size的长度*/    }} /** 申请一个slab, id 表示所属的class*/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;     /** 先判断可申请长度是否满足，之后判断是否需要扩容slabclass中记录申请的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); /** 将这一页的内存块瓜分成各个chunk小块，添加到slabclass可用slots链表*/     /**在slabclass中的数组记录多分配一个slab*/    p->slab_list[p->slabs++] = ptr;    mem_malloced += len;    MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);     return 1;} /*@null@*//** 分配一个slab块 size 表示item的大小，id 表示slabclass id*/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) {        MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);        return NULL;    }     p = &slabclass[id];    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 */    /* 先确保slabclass有咩有可用的slot, 再去申请新的slab, 申请也有可能失败*/    if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) {        /* We don't have more memory available */        ret = NULL;    } else if (p->sl_curr != 0) { /** 在slot有可用空间的时候申请失败则直接从slot那里取一个*/        /* 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;    } if (ret) {        p->requested += size; /** 统计已经被使用的字节数量*/        MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret);    } else {        MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);    }    return ret;} /** 按照函数名理解，释放一个slab块 * ptr 表示首地址，size表示item已使用字节大小，id是所属的slabclass */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->it_flags |= ITEM_SLABBED;    it->prev = 0;    it->next = p->slots; /** 串在 slabcalss的slots链表头部*/    if (it->next) it->next->prev = it; /*下一个节点不为空时，将下一个节点的prev指向it*/    p->slots = it; /** 更新slots */     p->sl_curr++; /**更新当前可用的chunk数量, slot代表了链表的名称, sl_curr表示可用的数量*/    p->requested -= size; /** 更新已经被请求使用了的字节数，多了一个相当于requested 减掉一个*/    return;} /** 从已经申请的内存块中申请slab内存块*/static void *memory_allocate(size_t size) {    void *ret;    if (mem_base == NULL) { /**全局变量指向系统申请时的内存块*/        /* We are not using a preallocated large memory chunk */        ret = malloc(size); /** 表示尚未向系统申请过，这里就直接调用系统调用申请*/    } else {        ret = mem_current; /** mem_current同样是一个全局变量，指向mem_base申请之后剩余的可用内存*/         if (size > mem_avail) { /** 判断申请是不是过大*/            return NULL;        }        /* mem_current pointer _must_ be aligned!!! */        if (size % CHUNK_ALIGN_BYTES) { /** 官方注释这里必须内存对齐*/            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);        }        mem_current = ((char*)mem_current) + size; /** mem_current向前移动*/        if (size < mem_avail) {            mem_avail -= size; /* 更新全局统计量*/        } else {            mem_avail = 0;        }    }    return ret;} /*分配slab块的对外接口，主要是加了锁，基本上do_xxx()函数都是不加锁的*/void *slabs_alloc(size_t size, unsigned int id) {    void *ret;    pthread_mutex_lock(&slabs_lock);    ret = do_slabs_alloc(size, id);    pthread_mutex_unlock(&slabs_lock);    return ret;}... /**更新已经slabclass使用的字节数*/void slabs_adjust_mem_requested(unsigned int id, size_t old, size_t ntotal){    pthread_mutex_lock(&slabs_lock);    slabclass_t *p;    if (id < POWER_SMALLEST || id > power_largest) {        fprintf(stderr, "Internal error! Invalid slab class\n");        abort();    }    p = &slabclass[id];    p->requested = p->requested - old + ntotal;    pthread_mutex_unlock(&slabs_lock);}

　　以上注释仅代表个人见解，若有误导，请见谅！