C 工具库6：通用内存分配器

本篇将介绍一个通用内存分配器的实现.
上一篇的开头已经介绍过,这个实现是组合first fit pool和fix_obj_pool以处理不同大小的分配请求.


首先看由fix_obj_pool返回的内存的头结构:

struct head_fix
{
unsigned short idx;/*0-255,表示在fix_objs的下标*/
unsigned short chunk_idx;
};

这个头不会返回给上层应用,是给释放内存使用的.因为内存的请求是对齐到4字节的,小于1024字节的请求,被分成256个分配大小,分别是4,
8,12,....1024.每个大小的请求由一个fix_obj_pool处理.idx的作用就是记录是由哪个fix_obj_pool分配的内存.还有一点要注意的是,head_fix
本身占用了4个字节,所以fix_obj_pool分配的对象大小实际是请求大小对齐到4倍数的大小再加上4.例如如果分配1个字节,对齐到4就是4字节,
所以实际分配内存的大小是8,只有后面4个字节会返回给上层应用.


这种空间的浪费对于小的内存请求有点过分了,所以在实际使用中,这个所谓的通用内存分配器,其实不是为编译时就已经可以确定大小的对象
使用的,对于编译期就确定大小的对象,应该直接使用fix_obj_pool.只有那些在运行时才确定大小的内存分配请求,例如字符串,变长结构等
才应该使用通用内存分配器.


下面介绍chunk_idx的作用.
首先回顾fix_obj_pool的实现,一个chunk中的所有对象在地址上都是连续的,当chunk的空间不够时,会再分配一个chunk,然后将这些chunk按期首地
址大小的升序排序.这样,释放一个对象时,可以根据对象地址使用2分查找快速的找到对象归属的chunk.
虽然2分查找效率是比较高的,但最好还是能避免.在单独使用fix_obj_pool的情况小,一般可以大致估算到系统中最大可能会分配多少个这类对象.
在创建fix_obj_pool时,传入这个估算值,就可以生成一个大小基本符合要求的chunk,这样几乎在大多数情况下都避免了释放内存时的一次2分查找.


但对于通用内存分配器,我们不太好估计这个值,所以,chunk的初始大小一般都不会设得太大.为了避免二分查找,在分配分时,通过调用:
void *pool_alloc2(struct fix_obj_pool *pool,unsigned short *chunk_idx)
把chunk的下标一并返回,释放时直接把这个下标传进去就可以定位到正确的chunk了.

下面是通用内存分配器的代码:

mem_allocator.h

#ifndef _MEM_ALLOCATOR_H
#define _MEM_ALLOCATOR_H

struct allocator;

/*
* max:可以分配的最大请求字节数
*/
struct allocator *allocator_create(unsigned int max);
void   allocator_destroy(struct allocator **);

void *allocator_alloc(struct allocator*,int);
void  allocator_dealloc(struct allocator*,void*);

#endif

mem_allocator.c

#include "mem_allocator.h"
#include "../first_fit/first_fit.h"
#include "../first_fit/first_fit_define.h"
#include "../fix_obj_pool/fix_obj_pool.h"
#include "http://www.cnblogs.com/vector/vector.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>


#define FIRST_FIT_DEFAULT_SIZE 1024*1024*16 //默认first_fit分配器大小是16MB

/*
* fix_obj_pool用于分配从1-1024字节大小的请求
* 请求对齐到4字节.所以总共有1024/4 = 256种大小
*/

struct allocator
{
    unsigned int max_request; //可以处理的最大分配请求
    struct fix_obj_pool *fix_objs[1024/4];
    struct vector *first_fits;//存放first_fit
    int last_dealloc_idx;
};

struct head_fix
{
    unsigned short idx;/*0-255,表示在fix_objs的下标*/
    unsigned short chunk_idx;
};

struct head_first_fit
{
    unsigned int idx;//在first_fits中的下标
};

struct chunk;
extern void *pool_alloc2(struct fix_obj_pool*,unsigned short *chunk_idx);
extern void pool_dealloc2(struct fix_obj_pool *pool,unsigned short chunk_idx,void* obj);

struct allocator *allocator_create(unsigned int max)
{
    struct allocator *al = malloc(sizeof(*al));
    if(!al)
        return 0;
    memset(al,sizeof(*al),0);
    al->max_request = max;
    al->last_dealloc_idx = -1;
    al->first_fits = 0;
    int i = 0;
    for(; i < 1024/4; ++i)
    {
        unsigned int real_size = (i+1)*4 + sizeof(struct head_fix);
        al->fix_objs[i] = create_pool(real_size,1024,1);
        if(!al->fix_objs[i])
        {
            allocator_destroy(&al);
            return 0;
        }
    }
    
    al->first_fits = vector_create(sizeof(struct first_fit_pool*),0);
    struct first_fit_pool *first_fit = first_fit_create(FIRST_FIT_DEFAULT_SIZE);
    if(!first_fit)
    {
        allocator_destroy(&al);
        return 0;
    }
    VECTOR_PUSH_BACK(struct first_fit_pool*,al->first_fits,first_fit);
    return al;
}

void   allocator_destroy(struct allocator **al)
{
    assert(al);
    assert(*al);
    unsigned int i = 0;
    if((*al)->first_fits)
    {    
        unsigned int size = vector_size((*al)->first_fits);
        struct first_fit_pool **first_fits = VECTOR_TO_ARRAY(struct first_fit_pool *,(*al)->first_fits);
        for( ; i < size; ++i)
            first_fit_destroy(&first_fits[i]);
    }
    
    i = 0;
    for( ; i < 1024/4;++i)
    {
        if((*al)->fix_objs[i])
            destroy_pool(&(*al)->fix_objs[i]);
    }
    
    free(*al);
    *al = 0;
}

void *allocator_alloc(struct allocator *al,int size)
{
    assert(al);
    unsigned int alloc_size = size;
    if(size <= 0)
        alloc_size = 1;
    //将请求大小调整为4的倍数
    alloc_size = alignsize(alloc_size);     
    if(alloc_size > al->max_request)
        return 0;//无法处理这个请求
    if(alloc_size > 1024)
    {
        struct head_first_fit *hff = 0;
        //交给first fit分配器
        alloc_size += sizeof(struct head_first_fit);
        if(al->last_dealloc_idx >= 0)
        {
            //首先尝试从上次释放的first_fit分配
            struct first_fit_pool *ff = VECTOR_GET(struct first_fit_pool *,al->first_fits,al->last_dealloc_idx);
            assert(ff);
            hff = (struct head_first_fit*)first_fit_alloc(ff,alloc_size);
        }
        
        if(!hff)
        {
            //遍历first_fits
            struct first_fit_pool **ffs = VECTOR_TO_ARRAY(struct first_fit_pool *,al->first_fits);
            unsigned int i = 0;
            unsigned int end = vector_size(al->first_fits);
            for( ; i < end; ++i)
            {
                hff = first_fit_alloc(ffs[i],alloc_size);
                if(hff)
                    break;
            }
            if(!hff)
            {
                //分配一个新的first_fit;
                struct first_fit_pool *ff = first_fit_create(FIRST_FIT_DEFAULT_SIZE);
                if(!ff)
                    return 0;
                VECTOR_PUSH_BACK(struct first_fit_pool*,al->first_fits,ff);
                hff = first_fit_alloc(ff,alloc_size);
            }
            
            void *ret = (void*)((char*)hff + sizeof(*hff)); 
            return ret;
        }
    }
    else
    {
        //由fix_obj_pool处理
        unsigned char idx = alloc_size/4 - 1;
        unsigned short chunk_idx;
        struct head_fix *hf = pool_alloc2(al->fix_objs[idx],&chunk_idx);
        if(!hf)
            return 0;
        hf->idx = idx;
        hf->chunk_idx = chunk_idx;
        void *ret = (void*)((char*)hf + sizeof(*hf)); 
        return ret;
    }    
}

void  allocator_dealloc(struct allocator *al,void *ptr)
{
    assert(al);
    assert(ptr);
    struct first_fit_chunk dummy;
    //首先确定是哪种类型的分配器分配的
    struct first_fit_chunk *ffc = (struct first_fit_chunk *)((int*)ptr - sizeof(struct head_first_fit)/4 - sizeof(dummy.tag)/4 - sizeof(dummy.size)/4);
    if(ffc->tag == USED_TAG)
    {
        //由first_fit分配的
        struct head_first_fit *hff = (struct head_first_fit *)((int*)ptr - sizeof(struct head_first_fit)/4);
        if(hff->idx < vector_size(al->first_fits))
        {
            struct first_fit_pool *ff = VECTOR_GET(struct first_fit_pool *,al->first_fits,hff->idx);
            assert(ff);
            first_fit_dealloc(ff,hff);
            al->last_dealloc_idx = hff->idx;
        }
    }
    else
    {
        struct head_fix *hf = (struct head_fix *)((int*)ptr - sizeof(struct head_fix)/4);
        if(hf->idx <= 255)
        {
            pool_dealloc2(al->fix_objs[hf->idx],hf->chunk_idx,ptr);
        }
    }
}