memcached源码分析-----slab内存分配器

时间 2019-11-06

标签 memcached 源码分析 slab 内存分配器栏目 Memcached 繁體版

原文原文链接

舒适提示：本文用到了一些能够在启动memcached设置的全局变量。关于这些全局变量的含义能够参考《memcached启动参数详解》。对于这些全局变量，处理方式就像《如何阅读memcached源代码》所说的那样直接取其默认值。linux

slab内存池分配器：

slab简介：

memcached使用了一个叫slab的内存分配方法，有关slab的介绍能够参考连接1和连接2。能够简单地把它看做内存池。memcached内存池分配的内存块大小是固定的。虽然是固定大小，但memcached的能分配的内存大小(尺寸)也是有不少种规格的。通常来讲，是知足需求的。编程

memcached声明了一个slabclass_t结构体类型，而且定义了一个slabclass_t类型数组slabclass(是一个全局变量)。能够把数组的每个元素称为一个slab分配器。一个slab分配器能分配的内存大小是固定的，不一样的slab分配的内存大小是不一样的。下面借一幅经典的图来讲明：数组

从每一个slab class(slab分配器)分配出去的内存块都会用指针链接起来的(连起来才不会丢失啊)。以下图所示：网络

上图是一个逻辑图。每个item都不大，从几B到1M。若是每个item都是地动态调用malloc申请的，势必会形成不少内存碎片。因此memcached的作法是，先申请一个比较大的一块内存，而后把这块内存划分红一个个的item，并用两个指针(prev和next)把这些item链接起来。因此实际的物理图以下所示：memcached

上图中，每个slabclass_t都有一个slab数组。同一个slabclass_t的多个slab分配的内存大小是相同的，不一样的slabclass_t分配的内存大小是不一样的。由于每个slab分配器能分配出去的总内存都是有一个上限的，因此对于一个slabclass_t来讲，要想分配不少内存就必须有多个slab分配器。
函数

肯定slab分配器的分配规格：

看完了图，如今来看一下memcached是怎么肯定slab分配器的分配规格的。由于memcached使用了全局变量，先来看一下全局变量。spa

//slabs.c文件
typedef struct {
    unsigned int size;//slab分配器分配的item的大小 	
    unsigned int perslab; //每个slab分配器能分配多少个item

    void *slots;  //指向空闲item链表
    unsigned int sl_curr; 	//空闲item的个数

	//这个是已经分配了内存的slabs个数。list_size是这个slabs数组(slab_list)的大小	
    unsigned int slabs; //本slabclass_t可用的slab分配器个数   
	//slab数组，数组的每个元素就是一个slab分配器，这些分配器都分配相同尺寸的内存
    void **slab_list; 	
    unsigned int list_size; //slab数组的大小, list_size >= slabs

	//用于reassign，指明slabclass_t中的哪一个块内存要被其余slabclass_t使用
    unsigned int killing; 

    size_t requested; //本slabclass_t分配出去的字节数
} slabclass_t;

#define POWER_SMALLEST 1
#define POWER_LARGEST  200
#define CHUNK_ALIGN_BYTES 8
#define MAX_NUMBER_OF_SLAB_CLASSES (POWER_LARGEST + 1)


//数组元素虽然有MAX_NUMBER_OF_SLAB_CLASSES个，但实际上并非所有都使用的。
//实际使用的元素个数由power_largest指明
static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES];//201
static int power_largest;//slabclass数组中,已经使用了的元素个数.

能够看到，上面的代码定义了一个全局slabclass数组。这个数组就是前面那些图的slabclass_t数组。虽然slabclass数组有201个元素，但可能并不会全部元素都使用的。由全局变量power_largest指明使用了多少个元素.下面看一下slabs_init函数，该函数对这个数组进行一些初始化操做。该函数会在main函数中被调用。.net

//slabs.c文件
static size_t mem_limit = 0;//用户设置的内存最大限制
static size_t mem_malloced = 0;

//若是程序要求预先分配内存，而不是到了须要的时候才分配内存，那么
//mem_base就指向那块预先分配的内存.
//mem_current指向还可使用的内存的开始位置
//mem_avail指明还有多少内存是可使用的
static void *mem_base = NULL;
static void *mem_current = NULL;
static size_t mem_avail = 0;


//参数factor是扩容因子，默认值是1.25
void slabs_init(const size_t limit, const double factor, const bool prealloc) {
    int i = POWER_SMALLEST - 1;

	//settings.chunk_size默认值为48，能够在启动memcached的时候经过-n选项设置
	//size由两部分组成: item结构体自己 和 这个item对应的数据
	//这里的数据也就是set、add命令中的那个数据.后面的循环能够看到这个size变量会
	//根据扩容因子factor慢慢扩大，因此能存储的数据长度也会变大的
    unsigned int size = sizeof(item) + settings.chunk_size;

    mem_limit = limit;//用户设置或者默认的内存最大限制

	//用户要求预分配一大块的内存，之后须要内存，就向这块内存申请。
    if (prealloc) {//默认值为false
        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");
        }
    }

	//初始化数组，这个操做很重要，数组中全部元素的成员变量值都为0了
    memset(slabclass, 0, sizeof(slabclass));

	//slabclass数组中的第一个元素并不使用
	//settings.item_size_max是memcached支持的最大item尺寸，默认为1M(也就是网上
	//所说的memcached存储的数据最大为1MB)。
    while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {
        /* Make sure items are always n-byte aligned */
        if (size % CHUNK_ALIGN_BYTES)//8字节对齐
            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);

		//这个slabclass的slab分配器能分配的item大小
        slabclass[i].size = size;
        //这个slabclass的slab分配器最多能分配多少个item(也决定了最多分配多少内存)
        slabclass[i].perslab = settings.item_size_max / slabclass[i].size;
        size *= factor;//扩容
    }

	//最大的item
    power_largest = i;
    slabclass[power_largest].size = settings.item_size_max;
    slabclass[power_largest].perslab = 1;

	...


    if (prealloc) {//预分配内存
        slabs_preallocate(power_largest);
    }
}

上面代码中出现的item是用来存储咱们放在memcached的数据。代码中的循环决定了slabclass数组中的每个slabclass_t能分配的item大小，也就是slab分配器能分配的item大小，同时也肯定了slab分配器能分配的item个数。线程

上面的代码还能够看到，能够经过增大settings.item_size_max而使得memcached能够存储更大的一条数据信息。固然是有限制的，最大也只能为128MB。巧的是，slab分配器能分配的最大内存也是受这个settings.item_size_max所限制。由于每个slab分配器能分配的最大内存有上限，因此slabclass数组中的每个slabclass_t都有多个slab分配器，其用一个数组管理这些slab分配器。而这个数组大小是不受限制的，因此对于某个特定的尺寸的item是能够有不少不少的。固然整个memcached能分配的总内存大小也是有限制的，能够在启动memcached的时候经过-m选项设置，默认值为64MB。slabs_init函数中的limit参数就是memcached能分配的总内存。指针

预分配内存：

如今就假设用户须要预先分配一些内存，而不是等到客户端发送存储数据命令的时候才分配内存。slabs_preallocate函数是为slabclass数组中每个slabclass_t元素预先分配一些空闲的item。因为item可能比较小(上面的代码也能够看到这一点)，因此不能以item为单位申请内存（这样很容易形成内存碎片）。因而在申请的使用就申请一个比较大的一块内存，而后把这块内存划分红一个个的item，这样就等于申请了多个item。本文将申请获得的这块内存称为内存页，也就是申请了一个页。若是全局变量settings.slab_reassign为真，那么页的大小为settings.item_size_max，不然等于slabclass_t.size * slabclass_t.perslab。settings.slab_reassign主要用于平衡各个slabclass_t的。后文将统一使用内存页、页大小称呼这块分配内存，不区分其大小。

如今就假设用户须要预先分配内存，看一下slabs_preallocate函数。该函数的参数值为使用到的slabclass数组元素个数。slabs_preallocate函数的调用是分配slab内存块和和设置item的。

//参数值为使用到的slabclass数组元素个数
//为slabclass数组的每个元素(使用到的元素)分配内存
static void slabs_preallocate (const unsigned int maxslabs) {
    int i;
    unsigned int prealloc = 0;

	//遍历slabclass数组
    for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) {
        if (++prealloc > maxslabs)//固然是只遍历使用了的数组元素
            return;
        if (do_slabs_newslab(i) == 0) {//为每个slabclass_t分配一个内存页
			//若是分配失败，将退出程序.由于这个预分配的内存是后面程序运行的基础
			//若是这里分配失败了，后面的代码无从执行。因此就直接退出程序。
            exit(1);
        }
    }

}


//slabclass_t中slab的数目是慢慢增多的。该函数的做用就是为slabclass_t申请多一个slab
//参数id指明是slabclass数组中的那个slabclass_t
static int do_slabs_newslab(const unsigned int id) {
    slabclass_t *p = &slabclass[id];
	//settings.slab_reassign的默认值为false，这里就采用false。
    int len = settings.slab_reassign ? settings.item_size_max
        : p->size * p->perslab;//其积 <= settings.item_size_max
    char *ptr;

	//mem_malloced的值经过环境变量设置，默认为0
    if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0) ||
        (grow_slab_list(id) == 0) ||//增加slab_list(失败返回0)。通常都会成功,除非没法分配内存
        ((ptr = memory_allocate((size_t)len)) == 0)) {//分配len字节内存(也就是一个页)

        return 0;
    }

    memset(ptr, 0, (size_t)len);//清零内存块是必须的
    //将这块内存切成一个个的item，固然item的大小有id所控制
    split_slab_page_into_freelist(ptr, id);

	//将分配获得的内存页交由slab_list掌管
    p->slab_list[p->slabs++] = ptr;
    mem_malloced += len;

    return 1;
}

上面的do_slabs_newslab函数内部调用了三个函数。函数grow_slab_list的做用是增大slab数组的大小(以下图所示的slab数组)。memory_allocate函数则是负责申请大小为len字节的内存。而函数split_slab_page_into_freelist则负责把申请到的内存切分红多个item，而且把这些item用指向连起来，造成双向链表。以下图所示：前面已经见过这图了，看完代码再来看一下吧。

下面看一下那三个函数的具体实现。

//增长slab_list成员指向的内存，也就是增大slab_list数组。使得能够有更多的slab分配器
//除非内存分配失败，不然都是返回1,不管是否真正增大了
static int grow_slab_list (const unsigned int id) {
    slabclass_t *p = &slabclass[id];
    if (p->slabs == p->list_size) {//用完了以前申请到的slab_list数组的全部元素
        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;
}


//申请分配内存，若是程序是有预分配内存块的，就向预分配内存块申请内存
//不然调用malloc分配内存
static void *memory_allocate(size_t size) {
    void *ret;

	//若是程序要求预先分配内存，而不是到了须要的时候才分配内存，那么
	//mem_base就指向那块预先分配的内存.
	//mem_current指向还可使用的内存的开始位置
	//mem_avail指明还有多少内存是可使用的
    if (mem_base == NULL) {//不是预分配内存
        /* We are not using a preallocated large memory chunk */
        ret = malloc(size);
    } else {
        ret = mem_current;

		//在字节对齐中，最后几个用于对齐的字节自己就是没有意义的(没有被使用起来)
		//因此这里是先计算size是否比可用的内存大，而后才计算对齐

        if (size > mem_avail) {//没有足够的可用内存
            return NULL;
        }

		//如今考虑对齐问题，若是对齐后size 比mem_avail大也是无所谓的
		//由于最后几个用于对齐的字节不会真正使用
        /* mem_current pointer _must_ be aligned!!! */
        if (size % CHUNK_ALIGN_BYTES) {//字节对齐.保证size是CHUNK_ALIGN_BYTES (8)的倍数
            size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);
        }


        mem_current = ((char*)mem_current) + size;
        if (size < mem_avail) {
            mem_avail -= size;
        } else {//此时，size比mem_avail大也无所谓
            mem_avail = 0;
        }
    }

    return ret;
}


//将ptr指向的内存页划分红一个个的item
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++) {
		//将ptr指向的内存划分红一个个的item.一共划成perslab个
		//并将这些item先后连起来。
		//do_slabs_free函数原本是worker线程向内存池归还内存时调用的。但在这里
		//新申请的内存也能够看成是向内存池归还内存。把内存注入内存池中
        do_slabs_free(ptr, 0, id);
        ptr += p->size;//size是item的大小
    }
}


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;

    p = &slabclass[id];

    it = (item *)ptr;
	//为item的it_flags添加ITEM_SLABBED属性，标明这个item是在slab中没有被分配出去
    it->it_flags |= ITEM_SLABBED;

	//由split_slab_page_into_freelist调用时，下面4行的做用是
	//让这些item的prev和next相互指向，把这些item连起来.
	//当本函数是在worker线程向内存池归还内存时调用，那么下面4行的做用是,
	//使用链表头插法把该item插入到空闲item链表中。
    it->prev = 0;
    it->next = p->slots;
    if (it->next) it->next->prev = it;
    p->slots = it;//slot变量指向第一个空闲可使用的item

    p->sl_curr++;//空闲可使用的item数量
    p->requested -= size;//减小这个slabclass_t分配出去的字节数
    return;
}

在do_slabs_free函数的注释说到，在worker线程向内存池归还内存时，该函数也是会被调用的。由于同一slab内存块中的各个item归还时间不一样，因此memcached运行一段时间后，item链表就会变得很混乱，不会像上面那个图那样。有可能以下图那样：

虽然混乱，但确定仍是会有前面那张逻辑图那样的清晰链表图，其中slots变量指向第一个空闲的item。

向内存池申请内存：

与do_slabs_free函数对应的是do_slabs_alloc函数。当worker线程向内存池申请内存时就会调用该函数。在调用以前就要根据所申请的内存大小，肯定好要向slabclass数组的哪一个元素申请内存了。函数slabs_clsid就是完成这个任务。

unsigned int slabs_clsid(const size_t size) {//返回slabclass索引下标值
    int res = POWER_SMALLEST;//res的初始值为1

	//返回0表示查找失败，由于slabclass数组中，第一个元素是没有使用的
    if (size == 0)
        return 0;
	
	//由于slabclass数组中各个元素能分配的item大小是升序的
	//因此从小到大直接判断便可在数组找到最小但又能知足的元素
    while (size > slabclass[res].size)
        if (res++ == power_largest)     /* won't fit in the biggest slab */
            return 0;
    return res;
}

在do_slabs_alloc函数中若是对应的slabclass_t有空闲的item，那么就直接将之分配出去。不然就须要扩充slab获得一些空闲的item而后分配出去。代码以下面所示：

//向slabclass申请一个item。在调用该函数以前，已经调用slabs_clsid函数肯定
//本次申请是向哪一个slabclass_t申请item了，参数id就是指明是向哪一个slabclass_t
//申请item。若是该slabclass_t是有空闲item，那么就从空闲的item队列中分配一个
//若是没有空闲item，那么就申请一个内存页。再重新申请的页中分配一个item
//返回值为获得的item，若是没有内存了，返回NULL
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);
	
    //若是p->sl_curr等于0，就说明该slabclass_t没有空闲的item了。
    //此时须要调用do_slabs_newslab申请一个内存页
    if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) {
		//当p->sl_curr等于0而且do_slabs_newslab的返回值等于0时，进入这里
        /* We don't have more memory available */
        ret = NULL;
    } else if (p->sl_curr != 0) {
    //除非do_slabs_newslab调用失败，不然都会来到这里.不管一开始sl_curr是否为0。
    //p->slots指向第一个空闲的item，此时要把第一个空闲的item分配出去
    
        /* return off our freelist */
        it = (item *)p->slots;
        p->slots = it->next;//slots指向下一个空闲的item
        if (it->next) it->next->prev = 0;
        p->sl_curr--;//空闲数目减一
        ret = (void *)it;
    }

    if (ret) {
        p->requested += size;//增长本slabclass分配出去的字节数
    }

    return ret;
}

能够看到在do_slabs_alloc函数的内部也是经过调用do_slabs_newslab增长item的。

在本文前面的代码中，都没有看到锁的。做为memcached这个用锁大户，有点不正常。其实前面的代码中，有一些是要加锁才能访问的，好比do_slabs_alloc函数。之因此上面的代码中没有看到，是由于memcached使用了包裹函数(这个概念对应看过《UNIX网络编程》的读者来讲很熟悉吧)。memcached在包裹函数中加锁后，才访问上面的那些函数的。下面就是两个包裹函数。

static pthread_mutex_t slabs_lock = PTHREAD_MUTEX_INITIALIZER;
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;
}

void slabs_free(void *ptr, size_t size, unsigned int id) {
    pthread_mutex_lock(&slabs_lock);
    do_slabs_free(ptr, size, id);
    pthread_mutex_unlock(&slabs_lock);
}