[CNT]关于自己的一个小小的slab内存分配器

引言：应用级别的内存分配器的作用主要在于减少malloc函数的调用，降低系统的内存碎片。作为高性能的服务器，一般都会有自己的内存分配方案。slab作为一款Linux内核的经典内存分配方式，应用在很多的应用级别的软件上，比如说Memcached 等。

        今天的主题就分享一下最近写的slab的一个简单的Demo，在于分享，代码有些粗糙，比如缺少对于内存字节的比例因子，缺少关于内存不足的情况下重分配等。不过各种应用各有各自的用途，在实现某些cached操作的软件中，由于带有LRU 算法等，在内存快使用完后就采取淘汰策略，所以不一定在内存不足的情况下重新给操作系统分配。

 

Slab内存分配器原理：

        

此图片来自自己的另一篇博文，如若不能显示，请google slab 内存分配器

slab内存分配器的原理大致如图所示，由index 确定一个由slot 组成的链表，这里也可以设置为一个固定长度大小的结构，然后划分为不同大小的slot

两种方式都有自己的好处，采用链表的方式可以动态增长，采用固定长度大小的块结构结构清晰，可以采用链式的数组构造slot，然后由empty_index 来确定空闲的slot，本篇博文就是讲解采用了这种方式的管理的。稍后会有详解，这里只是作为简单介绍。

我们只需要了解可以通过对齐后的内存大小找到index，然后通过index 找到slot数组，通过empty_index找到空闲的slot，改变empty_index 使其指向下一个空闲的slot。

对齐宏：

#define ALIGN(a,size) ((a+size-1)&(~(size-1)))

a为申请的内存大小，size为内存对齐大小

比如说 a = 127 size = 128 ， 那么小于128 的将a转化为128，总的来说，就是128的整数倍。

很多人说这样的方式会导致内存浪费，但是至今几乎都是采用这种方式。在没有找到一个更好的方式以前，这个也许就是最好的方式吧。

 

通过对齐后的内存大小，找到对应的index 是很容易的。比如说，我们的内存对齐是64，我们只需要将申请的 a>>6 .

#define MC_SLOT_ALIGN_SIZE  (64)

我们定义了默认的内存字节就是64Byte.可以通过自己的喜好做修改

 

解释一下这里的命名方式，CHUNK_ARRAY 就是由index 作为下标的数组。

我们定义

#define MC_CHUNK_ARRAY_SIZE (16)

就是说，index最大为15    0 不做为index。

 

每一个slot 的结构是这样定义的：

typedef struct _slot_s
{
    struct _slot_s         *data               ; /* The next              empty slot */
    mc_address             *star               ;
    mc_address             *end                ;
    mc_length               slot_length        ;
    int                     slot_index         ;
    mc_chunk_t             *which_chunk_p      ;
}mc_slot_t;

 

data 指针作为连接slot 数组的每一个槽的指针存在着，另一种方式是设置为 void *data ,这样可以复用 data指针，在申请出来后可以作为指向数据的指针。

#define mc_address        unsigned char 

#define mc_length         unsigned int  

mc_address  *start 用于指向slot申请的真正的内存地址，一般由malloc来申请。

mc_address  *end 指向内存的末尾。 end - start == slot_length 

slot_index 用于表示此slot是位于slot数组的下标

mc_chunkt_t   *which_chunk_p 是用来表示属于哪一个chunk 的，这个指针可以在释放的时候降低接口复杂度。

 

下面看看chunk的结构表示：

struct _chunk_s
{
    mc_length       chunk_length              ;
    mc_slot_t       *slots                    ;
    int             slots_size                ;  /*(int)(MC_CHUNK_SIZE/ALIGN(i,MC_SLOT_ALIGN_SIZE))*/
    int             empty_slot_index          ;
    int             last_slot_num             ;
    int             slots_array_num           ;  /*slot array size */
};

chunk_length 为宏定义的MC_CHUNK_ARRAY_SIZE 

slots 是一个指针，指向不同的slot数组，这里的slot数组也是通过动态分配的。后面会贴出相应代码。

slots_size是这个chunk下的slot数组中slot的内存大小。即end-statr

empty_slot_index是空闲的slot的index，这中数据结构可以查看类似的nginx的connection数组。

last_slot_num作为标示剩余的slot数量

slots_array_num是slot的数组的大小

 

下面看看头文件中的函数声明：

mc_slab_t * mc_slab_create(void);
    /*
     *    This function create a handle of slab and 
     *  you can use this handle to alloc slot
     *  besieds,when you free the slab , you must take this
     *  handle as a argument of mc_slab_free function
     */
     
mc_slot_t * mc_slot_alloc( mc_slab_t * par_slab , size_t par_size );
    /*
     *    mc_slot_alloc first arg is handle created by mc_slab_create
     *    the second arg is memory size you want
     *    NOTICE:because of handle is a global value , so this function is 
     *    not thread safty
     */

int mc_slot_free( mc_slot_t * par_slot_p );
    /*
     *    mc_slot_free take a slot structure as argument
     *    return 1 indicate successed
     *    
     *    this function find the lowest index of slot array     
     *  It's simple but useful
     */

void mc_slab_free( mc_slab_t * par_slab );
    /*
     *    free the whole slab
     *    argument is handle of create by mc_slab_create
     *    
     *    well done ,this function is test by valgrind and not memory leak

 

大致就是这几个函数，功能有说明。

 

mc_slab_t * mc_slab_create(void)
{
    mc_chunk_t *p_chunk ;
    mc_slot_t  *p_slot  ;
    int i;
    int j;
    
    int chunk_array_size = MC_CHUNK_ARRAY_SIZE  ;
    /* MALLOC */
    mc_slab_t * ret_big_array_p = (mc_slab_t *)malloc( sizeof(mc_slab_t) );
    
    /* alloc memory for chunk_array */
    /* MALLOC */
    ret_big_array_p->chunk_array = (mc_chunk_t *)malloc( sizeof(mc_chunk_t)*MC_CHUNK_ARRAY_SIZE );
    
    ret_big_array_p->total_alloced = MC_CHUNK_SIZE * MC_CHUNK_ARRAY_SIZE ;
    
    ret_big_array_p->chunk_array_size = MC_CHUNK_ARRAY_SIZE ;
    
    p_chunk =     ret_big_array_p->chunk_array ;
    
    /*
    p_chunk[0] = NULL ;
    */
    for( i = 1 ; i < chunk_array_size ; i++ )
    {
        p_chunk[i].chunk_length = MC_CHUNK_SIZE ;
        
        /* every slot has a stable size of MC_CHUNK_SIZE */
        p_chunk[i].slots_size = (int)(MC_CHUNK_SIZE/ALIGN(i,MC_SLOT_ALIGN_SIZE));
        
        /* alloc memory for slots every chunk */
        /* MALLOC */
        p_chunk[i].slots = (mc_slot_t *)malloc( sizeof(mc_slot_t)*p_chunk[i].slots_size );
        
        p_chunk[i].empty_slot_index = 0 ;
        
        p_chunk[i].last_slot_num = p_chunk[i].slots_size ;
        
        p_chunk[i].slots_array_num = p_chunk[i].slots_size ;
        
        
        
        /*initialize the slots*/
        j = p_chunk[i].slots_size - 1 ; 
        /*slot_size = */
        
        int slot_alloc_size = i<<6 ;
        
        /* ini the last slot of slot array */
        p_chunk[i].slots[j].data = NULL ;
        
        /* MALLOC */
        p_chunk[i].slots[j].star = (void *)malloc( slot_alloc_size );
        ret_big_array_p->total_lasted += slot_alloc_size ;
        p_chunk[i].slots[j].end = p_chunk[i].slots[j].star + slot_alloc_size ;
        p_chunk[i].slots[j].slot_length = slot_alloc_size ;
        p_chunk[i].slots[j].slot_index  = j ;
        p_chunk[i].slots[j].which_chunk_p = &(p_chunk[i]);
        
        /* for other slots initialize */
        for( j = p_chunk[i].slots_size -2 ; j >= 0 ; j-- )
        {
            p_chunk[i].slots[j].data = &(p_chunk[i].slots[j+1]) ;
            
            /* MALLOC */
            p_chunk[i].slots[j].star = (void *)malloc( slot_alloc_size );
            ret_big_array_p->total_lasted += slot_alloc_size ;
            
            p_chunk[i].slots[j].end = p_chunk[i].slots[j].star + slot_alloc_size ;
            
            p_chunk[i].slots[j].slot_length = slot_alloc_size ;
            
            p_chunk[i].slots[j].slot_index  = j ;
            
            p_chunk[i].slots[j].which_chunk_p = &(p_chunk[i]);
        }
    }
    ret_big_array_p->total_alloced    = 0 ;
    
    
    /* flag of wether this block is initialized  */
    ret_big_array_p->is_initialized = 1 ;
    return ret_big_array_p ;
}

mc_slot_t * mc_slot_alloc( mc_slab_t * par_slab , size_t par_size )
{
    if( par_slab == NULL || par_slab->is_initialized != 1 )
    {
        /*There may be some debug information*/
        return NULL ;
    }
    
    /* args checked right */
    
    mc_slot_t * ret_slot_p ;
    size_t  allocsize = ALIGN( par_size,MC_SLOT_ALIGN_SIZE ) ;
    int     chunk_index = allocsize >> 6 ;
    
    if( chunk_index >= MC_CHUNK_ARRAY_SIZE )
    {
        /* to protected out of chunk[] bound */
        /*We should do someting At least we should let users know there was no slot for him */
        return NULL ;
        
    } 
    
    if( par_slab->chunk_array[ chunk_index ].last_slot_num == 0 )
    {
        /*we should do something eh ??*/
        /*At least we should let user know there was no slot for him */
        return NULL ;
    }
    
    mc_chunk_t * p_chunk = &(par_slab->chunk_array[ chunk_index ]);
    int        empty_index = p_chunk->empty_slot_index ;
    
    /* find a empty slot for ret_slot_p point */
    ret_slot_p = &(p_chunk->slots[empty_index]) ;
    
    /* we should change the chunk's empty index */
    
    p_chunk->empty_slot_index = ret_slot_p->data->slot_index ;
    
    (p_chunk->last_slot_num)-- ;
    return ret_slot_p ;
    
}



/* Notice ! free slot but not slab  */
int mc_slot_free( mc_slot_t * par_slot_p )
{
    mc_chunk_t * chunk_p = par_slot_p->which_chunk_p ;
    chunk_p->slots[chunk_p->empty_slot_index].data = par_slot_p ; 
    chunk_p->empty_slot_index = par_slot_p->slot_index;
    (chunk_p->last_slot_num)++ ;
    return 1 ;
}

void mc_slab_free( mc_slab_t * par_slab )
{
    mc_chunk_t * chunk_p       ;
    mc_chunk_t * free_chunk_p ;
    mc_slot_t  * slot_p        ;
    mc_slot_t  * free_slot_p  ;
    
    
    /* free each slot first */
    int i = 0 ; 
    int j = 0 ;
    
    for( i = 1 ; i < MC_CHUNK_ARRAY_SIZE ; i++ )
    {
        
        chunk_p = &(par_slab->chunk_array[i]);
    
        slot_p = chunk_p->slots;
        
        for( j = 0 ; j < chunk_p->slots_array_num ; j++ )
        {
            free(slot_p[j].star);
        }
        free( slot_p );        
    }
    free( par_slab->chunk_array );
    free( par_slab );
}


/*
int main()
{
    mc_slab_t *my_slab = mc_slab_create();
    fprintf(stderr,"%d\n",my_slab->total_lasted);
    mc_slot_t * my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    mc_slot_free(my_slot);
    my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    my_slot = mc_slot_alloc( my_slab, 127 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    my_slot = mc_slot_alloc( my_slab, 62 ) ;
    fprintf(stderr,"%p\n",my_slot->star);
    fprintf(stderr,"%p\n",my_slot->end);
    fprintf(stderr,"%d\n",my_slot->slot_index);
    fprintf(stderr,"%d\n",my_slot->slot_length);
    
    mc_slab_free(my_slab);
    
    return 0;
}
    
*/
    

 

 

总结：slab内存分配器的核心在于理解通过对齐后的内存大小得到index