Memcached源码分析——slab的初始化

/**
 * Determines the chunk sizes and initializes the slab class descriptors
 * accordingly.
 */
 /**
  * 确定chunk的大小，初始化slabs类的相应的描述符
  */
void slabs_init(const size_t limit, const double factor, const bool prealloc) {
    /**
     * #define POWER_SMALLEST 1          //POWER_SMALLEST的定义，表示slab中最少包含一个chunk
     * 下面这行中的i为chunk计数器，记录当前slab已经分了多少个chunk，初始值为0
     */
    int i = POWER_SMALLEST - 1;
    /**
     * 下面的size为chunk的大小，单位为字节。
     * size的大小为item所占内存大小与settings.chunk_size之和
     * settings.chunk_size的默认值为48，初始化在memcached-1.4.22/memcached.c的static void settings_init(void);中。
     * settings的定义在memcached-1.4.22/memcached.h中。
     */
    unsigned int size = sizeof(item) + settings.chunk_size;

    /**
     * 限制使用内存的总量为limit MB，默认为64MB，这个默认值是由 settings.maxbytes 决定的。
     */
    mem_limit = limit;

    /**
     * 是否预先在内存中分配一个默认大小为64MB的大chunk，默认 prealloc=false
     */
    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对象的sizeof(slabclass)个字节全部初始化为0
     */
    memset(slabclass, 0, sizeof(slabclass));

    /**
     * 下面到了具体切割slab的地方了。
     * #define POWER_LARGEST  200   //这里定义的是slab的种类最多不得超过200种
     * settings.item_size_max为item的最大字节数，默认为1MB。
     * factor为chunk的增长系数，即增长为之前的factor倍。默认为1.25。
     */
    while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {
        /**
         * 下面的语句实现的功能：保证items的字节数为CHUNK_ALIGN_BYTES的整数倍
         * #define CHUNK_ALIGN_BYTES 8   //CHUNK_ALIGN_BYTES的定义
         */
        /* Make sure items are always n-byte aligned */
        if (size % CHUNK_ALIGN_BYTES)
            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);

        /**
         * 定义当前slab中的chunk的大小。
         */
        slabclass[i].size = size;
        /**
         * 定义当前slab中的chunk的数目。
         */
        slabclass[i].perslab = settings.item_size_max / slabclass[i].size;
        size *= factor;
        if (settings.verbose > 1) {
            fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
                    i, slabclass[i].size, slabclass[i].perslab);
        }
    }

    /**
     * 记录一共有多少种slabs
     */
    power_largest = i;
    /**
     * 设置slabs中尺寸最大的chunk的值
     */
    slabclass[power_largest].size = settings.item_size_max;
    /**
     * chunk尺寸最大的slab中chunk的数量
     */
    slabclass[power_largest].perslab = 1;
    if (settings.verbose > 1) {
        fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
                i, slabclass[i].size, slabclass[i].perslab);
    }

    /* 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);
    }
}

/**
 * powers-of-N allocation structures
 *代码在memcached-1.4.22/slabs.c
 */
typedef struct {
    unsigned int size;      /* sizes of items */
    unsigned int perslab;   /* how many items per slab */

    void *slots;           /* list of item ptrs */
    unsigned int sl_curr;   /* total free items in list */

    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 */
    size_t requested; /* The number of requested bytes */
} slabclass_t;
static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES];

/**
 * memcache中，每一条数据记录在一个item中，item的具体结构如下
 * Structure for storing items within memcached.
 * 以下代码在memcached-1.4.22/memcached.h的343行到368行
 */
typedef struct _stritem {
    struct _stritem *next;
    struct _stritem *prev;
    struct _stritem *h_next;    /* hash chain next */
    rel_time_t      time;       /* least recent access */
    rel_time_t      exptime;    /* expire time */
    int             nbytes;     /* size of data */
    unsigned short  refcount;
    uint8_t         nsuffix;    /* length of flags-and-length string */
    uint8_t         it_flags;   /* ITEM_* above */
    uint8_t         slabs_clsid;/* which slab class we‘re in */
    uint8_t         nkey;       /* key length, w/terminating null and padding */
    /* 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[];
    /* if it_flags & ITEM_CAS we have 8 bytes CAS */
    /* then null-terminated key */
    /* then " flags length\r\n" (no terminating null) */
    /* then data with terminating \r\n (no terminating null; it‘s binary!) */
} item;

$str = str_repeat(‘i‘,100);
$memc->set(‘JUST_a_TEST‘,$str,10);
$str = str_repeat(‘i‘,500);
$memc->set(‘JUST_a_TEST‘,$str,10);
$str = str_repeat(‘i‘,5);
$memc->set(‘JUST_a_TEST‘,$str,10);