C++STL中Allocator分析

C++STL中Allocator分析

C++ SGI STL的allocator分为两级：

• 第一级配置器：超过128bytes的内存分配通过第一级分配器进行分配。

• 第二级配置器：不超过128bytes的内存分配通过第二级分配器进行分配。

为了简单起见，文本在讨论的时候无考虑多线程的场景以及模板化。

第一级配置器

第一级配置器的实现比较简单，直接通过malloc请求内存，通过free释放内存。若通过malloc请求内存失败，则先尝试通过调用用户注册的处理函数尝试释放不再使用的内存，之后再次使用malloc进行请求内存。

具体的代码如下：

class __malloc_alloc{
private:
    static void *oom_malloc(size_t);
    static void *oom_realloc(void *, size_t);
    static void (* __malloc_alloc_oom_handler)();
public:
    static void *allocate(size_t n);
    static void deallocate(void *p, size_t n);
    static void *reallocate(void *p, size_t old_sz, size_t new_sz);
    static void (* set_malloc_handler(void (*f)()))(){
        void (*old)() = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = f;
        return old;
    }

};

void (*__malloc_alloc::__malloc_alloc_oom_handler)() = 0;

void *__malloc_alloc::oom_malloc(size_t n){
    void (*my_malloc_handler)();
    void *result;
    for(;;){
        my_malloc_handler = __malloc_alloc_oom_handler;             
        if(0 == my_malloc_handler) {
            std::cerr<<"out of memory"<<std::endl;      //若没有注册回调函数，抛出异常
            exit(0);
        }
        (*my_malloc_handler)();     //回调用户注册的内存释放函数，以寻求释放空闲内存
        result = malloc(n);
        if(result) return result;
    }
}

void *__malloc_alloc::oom_realloc(void *p, size_t n){
    void (*my_malloc_handler)();
    void *result;
    for(;;){
        my_malloc_handler = __malloc_alloc_oom_handler;
        if(0 == my_malloc_handler) {
            std::cerr<<"out of memory"<<std::endl;
            exit(0);
        }
        (*my_malloc_handler)();
        result = realloc(p, n);
        if(result) return result;
    }
}

void *__malloc_alloc::allocate(size_t n){
    void *result = malloc(n);                   //第一级适配器直接使用malloc请求内存
    if(0 == result) result = oom_malloc(n);     //若malloc无法请求内存，则先调用用户注册的回调函数尝试释放内存
    return result;
}

void __malloc_alloc::deallocate(void *p, size_t n){
    free(p);                                    //第一级适配器直接使用free释放内存
}

void *__malloc_alloc::reallocate(void *p, size_t old_sz, size_t new_sz){
    void *result = realloc(p, new_sz);
    if(0 == result) result = oom_realloc(p, new_sz);
    return result;
}

第二级配置器

第二级配置多了一些机制，避免太多小额区块造成内存的碎片。小额区块带来的起始不仅是内存碎片，配置时的额外负担也是一个大问题。SGI第二级配置器的做法是，如果区块够大，超过128b时，就移交第一级配置器处理。当区块小于128b时，则以内存池管理，此法又称为次层配置：每次配置一大块内存，并维护对应之自由链表。下次若再有相同大小的内存需求，就直接从free_list中拿出。如果客户端还释还小额区块，就由配置器回收到free_list中。为了方便管理，SGI第二级配置器会主动将任何小额区块的内存需求量上调至8的倍数（例如客户端需求为30b，就自动调整为32b）。

其维护两个数据结构：

空闲链表：16个free_lists，各种管理大小为8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128btyes的小额区块。

内存池：在堆上分配的内存空间，free_start为可用空间起点，free_end为可用空间终点。

enum {__ALIGN = 8};             //小型区块的上调边界
enum {__MAX_BYTES = 128};       //小型区块的上限
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};  //free-lists个数

class __default_alloc{
private:
    static size_t ROUND_UP(size_t bytes){       //将bytes上调至8的倍数
        return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
    }
    union obj{
        union obj * free_list_link;
        char client_data[1];
    };
    static obj * volatile free_list[__NFREELISTS];
    static size_t FREELIST_INDEX(size_t bytes){
        return (((bytes) + __ALIGN-1)/__ALIGN - 1);
    }
    static void *refill(size_t n);          //填充大小n的空闲链表
    static char *chunk_alloc(size_t size, int &nobjs);  //从内存池中分配size*nobjs大小的内存空间

    static char *start_free;    //内存池开始地址
    static char *end_free;      //内存池结束地址
    static size_t heap_size;

public:
    static void * allocate(size_t n);
    static void deallocate(void *p, size_t n);
    static void * reallocate(void *p, size_t old_sz, size_t new_sz);
};

void * __default_alloc::allocate(size_t n){
    obj * volatile *my_free_list;
    obj * result;
    if(n > (size_t)__MAX_BYTES){    //大于阈值则通过第一级分配器分配
        return __malloc_alloc::allocate(n);
    }

    my_free_list = free_list + FREELIST_INDEX(n);   //寻找合适的空闲链表
    result = *my_free_list;
    if(result==0){         //空闲链表中无空闲空间
        void *r = refill(ROUND_UP(n));  //填充空闲链表
        return r;
    }
    *my_free_list = result->free_list_link;
    return result;
}

void  __default_alloc::deallocate(void *p, size_t n){
    obj *q = (obj*) p;
    obj * volatile * my_free_list;
    if(n > (size_t)__MAX_BYTES){    //大于阈值则通过第一级分配器分配
        __malloc_alloc::deallocate(p, n);
        return;
    }
    my_free_list = free_list + FREELIST_INDEX(n);   //寻找对应的空闲链表
    q->free_list_link = *my_free_list;      //将内存区域插入空闲链表
    *my_free_list = q;
    return;
}

void *__default_alloc::refill(size_t n){
    int nobjs = 20;
    char *chunk = chunk_alloc(n, nobjs);    //尝试请求n*nobjs空间，实际得到的数量为nobjs
    obj *volatile * my_free_list;
    obj *result;
    obj* current_obj, *next_obj;
    int i;

    //如果只获得一个区块，这个区块就分配给调用者使用，free_list无新结点
    if(1==nobjs) return chunk;
    my_free_list = free_list + FREELIST_INDEX(n);

    result = (obj *)chunk;
    *my_free_list = next_obj = (obj *)(chunk + n);
    for(i=1;;i++){      //构造空闲链表
        current_obj = next_obj;
        next_obj = (obj*)((char*)next_obj + n);
        if(nobjs-1==i){
            current_obj->free_list_link = 0;
            break;
        }
        else{
            current_obj->free_list_link = next_obj;
        }
    }   
    return result; 
}

char * __default_alloc::chunk_alloc(size_t size, int &nobjs){
    char * result;
    size_t total_bytes = size*nobjs;
    size_t bytes_left = end_free - start_free;

    if(bytes_left >= total_bytes){ //内存池剩余空间完全满足需求量
        result = start_free;
        start_free += total_bytes;
        return result;
    }
    else if(bytes_left>=size){      //内存池剩余空间不能完全满足需求量，但足够供应一个以上的区块
        nobjs = bytes_left/size;
        total_bytes = size*nobjs;
        result = start_free;
        start_free += total_bytes;
        return result;
    }
    else{   //内存池剩余空间连一个区块的大小都无法提供
        size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size>>4);
        if(bytes_left>0){ //内存池中还有一些零头，先配给适当的free_list;
            obj * volatile *my_free_list = free_list + FREELIST_INDEX(bytes_left);
            ((obj *)start_free) -> free_list_link = *my_free_list;
            *my_free_list = (obj *)start_free;
        }
        start_free = (char*)malloc(bytes_to_get); //配置heap空间，用来补充内存池
        if(0==start_free){  //heap空间不足，malloc失败
            int i;
            obj *volatile *my_free_list, *p;
            //检查当前free_list，看是否有比size大的空闲的空间，并对其进行重新配置
            for(i = size; i <= __MAX_BYTES; i += __ALIGN){
                my_free_list = free_list + FREELIST_INDEX(i);
                p = *my_free_list;
                if(0 != p){         //在free_list找到合适的区域
                    *my_free_list = p->free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    return chunk_alloc(size, nobjs); //递归调用自己，修正nobjs
                    //任何残余的零头总将被编入适当的free_list中备用
                }
            }
            end_free = 0; //执行到这一步说明山穷水尽了
            //调用第一级配置器，看看out-of-memory机制能否尽点力
            start_free = (char *)__malloc_alloc::allocate(bytes_to_get);
        }
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        return chunk_alloc(size, nobjs); //递归调用自己，为了修正nobjs
    }
}