SGI STL 的 一，二级配置器浅析

补充知识：
由于小型区块可能会造成内存破损，所以SGI设计了双层配置器，第一级配置器直接使用malloc()和free(),第二级配置器则根据配置区块的大小采用不同策略（若区块大小大于128bytes就调用一级配置器，若小于128bytes就调用二级配置器（内存池处理））

SGI STL 的第一级配置器 和 第二级配置器的关系

<一> 第一级配置器的工作机制：

allocate()和reallocate()函数在调用malloc()和realloc()失败后，调用oom_malloc()和oom_realloc()，oom_malloc()和oom_realloc()函数内都有内循环，不断的调用“内存不足处理例程”，期望在某次调用后可以获得足够的内存；但若内存不足处理例程客端没有设定，oom_malloc()和oom_realloc()会直接调用__THROW_BAD_ALLOC抛出bad_alloc异常信息，或者利用exit(1)直接终止程序。

第一级配置器的代码如下：

#if 1
#include <iostream>
#include <malloc.h>
#include <stdlib.h>

using namespace std;
#define __THROW_BAD_ALLOC cerr<<"out of memory."<<endl; exit(1);
#elif !defined(__THROW_BAD_ALLOC)
#include <iostream.h>
#define __THROW_BAD_ALLOC cerr<<"out of memory."<<endl; exit(1);
#endif

template<int inst>
class __malloc_alloc_template
{
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)
    {
        void *result = malloc(n);
        if(0 == result){
            result = oom_malloc(n);
        }
        return result;
    }
    static void *deallocate(void *p, size_t)
    {
        free(p);
    }
    static void *reallocate(void *p, size_t, size_t new_sz)
    {
        void *result = realloc(p, new_sz);
        if(0 == result){
            result = oom_realloc(p, new_sz);
        }
        return result;
    }

    static void (*set_malloc_handler(void (*f)()))()
    {
        void(*old)() = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = f;
        return old;
    }
};

template<int inst>
void(*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;

template<int inst>
void *__malloc_alloc_template<inst>::oom_malloc(size_t n)
{
    void (*my_malloc_handler)();
    void *result;

    for(; ;){
        my_malloc_handler = __malloc_alloc_oom_handler;
        if(0 == my_malloc_handler){
            __THROW_BAD_ALLOC;
        }
        (*my_malloc_handler)();
        result = malloc(n);
        if(result){
            return result;
        }
    }
}

template<int inst>
void *__malloc_alloc_template<inst>::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){
            __THROW_BAD_ALLOC;
        }
        (*my_malloc_handler)();
        result = realloc(p, n);
        if(result){
            return result;
        }
    }
}

测试代码如下：

void my_new_handler()
{
    cout<<"OMG, Out Of Memory."<<endl;
    //exit(1);
}

int main()
{
    __malloc_alloc_template<0>::set_malloc_handler(my_new_handler);
    int *p = (int*)__malloc_alloc_template<0>::allocate(sizeof(int)*100000000000000000);
    *p = 100;
    cout<<*p<<endl;
    __malloc_alloc_template<0>::deallocate(p,0);
    return 0;
}

<二>第二级配置器的工作机制：若需要的区块的大小超过128bytes，直接转交第一级配置器处理；若区块小于128bytes就调用二级配置器；二级配置器维护着16个free_lists(自由链表)，各自管理的大小依次为8的整数倍（即8， 16， 24， 32， 40， 48， 56， 64，72， 80， 88， 96，104， 112， 120， 128bytes的区块）

(1)第一次使用，内存池没有可用的空间
allocate()函数首先判断区块的大小决定用哪一级的配置器，大于128bytes就用一级配置器，否则就用二级配置器并根据区块大小找到相应的free_list,若free_list内有可用的区块，就直接使用，若free_list内没有可用的区块，就将区块大小上调至8的倍数，然后调用refill()函数填充空间，refill()调用内存池函数chunk_alloc()函数来填充空间，第一次调用chunk_alloc()时内存池是没有空间的，因此chunk_alloc()在heap（堆）上申请2倍的需求量（total_bytes）再加上一个附加量(heap_size>>4)，之后又回调chunk_alloc()函数修改nobjs；若内存池剩余空间大小大于需求量（total_bytes = nobjs * n),则将内存池的开始位置返回给refill()函数，并将内存池开始位置移动到total_bytes大小后的位置；返回至refill()后将0位置的区块给予客端，并将剩下的区块用free_list_link链接起来放在当前的free_list下；
（2）内存池有可用空间，但是剩余的空间不够20个区块所需的空间
则当refill()函数调用chunk_alloc()函数时，如果剩余内存池空间足够供应一个或一个以上的区块，就返回nobjs块的区块大小，并将一块返回给客端，将剩余的区块链接起来，放在当前的free_list下；若只返回了一个区块的大小，就直接将该区块返回给客端，free_list没有新的节点可以链接；
（3）内存池剩余的空间不足一个区块的大小
先将内存池剩余的空间配置给合适的free_list；
然后重新在heap上申请需求量的2倍加附加量（heap_size>>4）的空间,并将total_bytes大小的空间返回给refill()函数，refill()函数将其中的一块区块给予客端，之后将剩余的区块依次链接起来放在对应的free_list下；
（4）内存池没有剩余空间，heap也没有可以申请的空间
就在free_list中寻找可用的区块
（5）内存池没有剩余空间，heap上也无法申请到空间，并且free_list中也没有可用的合适区块
就调用一级配置器，看看内存处理例程能否得到足够的空间，可以达到就成功，不可以就会抛出bad_alloc异常

第二级配置器的代码：

enum{__ALIGN = 8};
enum{__MAX_BYTES = 128};
enum{__NFREELISTS = __MAX_BYTES / __ALIGN};

template<bool threads, int inst>
class __default_alloc_template
{
private:
    static size_t ROUND_UP(size_t bytes)
    {
        return ((bytes + __ALIGN - 1) & ~(__ALIGN - 1));   //将byte提升为8的倍数
    }
private:
    union obj
    {
        union obj * free_list_link;
        char client_data[1];
    };
private:
    static obj * volatile free_list[__NFREELISTS];    //free_list是一个可变的二级指针, 16个自由链表
    static size_t FREELIST_INDEX(size_t bytes)   //根据区块大小，决定使用第几个free_list
    {
        return ((bytes + __ALIGN - 1) / __ALIGN - 1);
    }

    static char *start_free;  //内存池开始位置
    static char *end_free;    //内存池结束位置
    static size_t heap_size;  //容量

private:
    static void *refill(size_t n);   //填充自由链表空间
    static char* chunk_alloc(size_t size, int &nobjs);   //配置内存池空间

public:
    static void *allocate(size_t n)
    {
        obj * volatile *my_free_list;
        obj * result;

        if(n > __MAX_BYTES){
            return malloc_alloc::allocate(n);
        }
        my_free_list = free_list + FREELIST_INDEX(n);   //在16个自由链表中找到合适的链表
        result = *my_free_list;
        if(0 == result){      //没有找到可用的free_list，重新填充free_list
            void *r = refill(ROUND_UP(n));
            return r;
        }
        *my_free_list = result->free_list_link;   //将result所指向的free_list抽出，将my_free_list指向rsult所指的下一个free_list空间
        return result;
    }

    static void dealocate(void *p, size_t n)   //就是将被释放的free_list头插入相对应的free_list区块
    {
        obj *q = (obj *)p;
        obj * volatile *my_free_list;
        if(n > __MAX_BYTES){
            malloc_alloc::deallocate(p, n);
            return ;
        }

        //找到对应的free_list
        my_free_list = free_list + FREELIST_INDEX(n);
        //调整free_list，回收区块(即头插如对应的free_list)
        q->free_list_link = *my_free_list;
        *my_free_list = q;
    }
};


//初始化
template<bool threads, int inst>
char *__default_alloc_template<threads, inst>::start_free = 0;

template<bool threads, int inst>
char *__default_alloc_template<threads, inst>::end_free = 0;

template<bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;

template<bool threads, int inst>
typename __default_alloc_template<threads, inst>::obj * volatile
__default_alloc_template<threads, inst>::free_list[__NFREELISTS] = 
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};


//填充函数refill
template<bool threads, int inst>
void * __default_alloc_template<threads, inst>::refill(size_t n)
{
    int nobjs = 20;
    char *chunk = chunk_alloc(n, nobjs);   //配置内存池空间
    obj * volatile *my_free_list;
    obj * result;
    obj * current_obj, * next_obj;
    int i;

    //若只得到一个区块，直接分配给调用者用，free_list无新节点
    if(1 == nobjs){
        return chunk;
    }
    //否则调整free_list, 纳入新的节点
    my_free_list = free_list + FREELIST_INDEX(n);  

    //在chunk（内存池）空间内建立新的free_list,并依次将其链接起来
    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;  //到达最后一个区块，其link为空
            break;
        }else{
            current_obj->free_list_link = next_obj;
        }
    }

    return result;
}

template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::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){
            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;
        }

        //配置heap，用来补充内存池
        start_free = (char *)malloc(bytes_to_get);
        if(0 == start_free){
            int i;
            obj* volatile *my_free_list, *p;
            //若heap空间不足,就试着在size大小后的区块中查找未用的区块足够大的free_list
            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中有未用的空间，则调整free_list,释放出空间
                    *my_free_list = p->free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    return chunk_alloc(size, nobjs);    //为修正nobjs
                }
            }

            end_free = 0;   //即就是heap，和 区块中都没有内存了，就调用一级配置器
            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);
    }
}

//////////////////////////////////////////////////////////////////////////////

#ifdef __USE_MALLOC
typedef __malloc_alloc_template<0> malloc_alloc;
typedef malloc_alloc alloc;
#else
typedef __default_alloc_template<0, 0> alloc;
#endif 
//////////////////////////////////////////////////////////////////////////////
#endif

测试代码如下：

int main()
{
 int *p = (int*)alloc::allocate(sizeof(int));
 //int *p1 = (int*)alloc::allocate(sizeof(int));
 //alloc::deallocate(p,sizeof(int));
    /*
    int* pa[19];
    for(int i=0; i<19; ++i)
    {
 pa[i] = (int*)alloc::allocate(sizeof(int));
    }

 //int *p1 = (int *)alloc::allocate(sizeof(int)*10);
 //int *p2 = (int*)alloc::allocate(sizeof(int)*10);
 //int *p3 = (int*)alloc::allocate(sizeof(int)*10);

 //int *p4 = (int*)alloc::allocate(96);
 //int *p5 = (int*)alloc::allocate(72);
 //alloc::deallocate(p,4);
    */
    return 0;
}