STL的第二级配置器

本文不考虑异常处理情况。

STL的第二级配置器是默认使用的配置器，第一级配置器只是简单的调用malloc(),free(),realloc()等函数，并没有真正意义上对内存进行管理

STL的第二级配置器相对较为复杂，利用了链表的形式管理16种内存大小不同的区块。由于链表的存在，当使用内存不再需要时，不是简单的释放(free())，而是将其回收到链表中，省去了反复释放和申请内存的开销。

 

代码如下：

 

 

#ifndef __H_DEFAULT
#define __H_DEFAULT
#include "__malloc_alloc_template.h"

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


template<bool threads, int inst>
class __defalut_alloc_template
{
private:
    // ROUND_UP() 将bytes上调至8的倍数
    static size_t ROUND_UP(size_t bytes)
    {
        return ((bytes) + __ALIGN - 1) & ~(__ALIGN - 1);
    }

private:
    union obj   // free-lists 的节点构造
    {
        union obj* free_list_link;
        char client_data[1];
    };

private:
    // 16个free-lists
    static obj * volatile  free_list[__NFREELISTS];
    // 以下函数根据区块大小，决定使用第n号free-list，n从0算起
    static size_t FREELIST_INDEX(size_t bytes)
    {
        return (((bytes) + __ALIGN - 1)/__ALIGN -1);
    }

    // 返回一个大小为n的对象，并可能加入大小为n的其他区块到free list
    static void* refill(size_t n);
    static char* chunk_alloc(size_t size, int& nobjs);

    // Chunk allocation state
    static char* start_free; // 内存池的起始位置，只在chunk_alloc()中变化
    static char* end_free;   // 内存池的结束位置，只在chunk_alloc()中变化
    static size_t heap_size;

public:
    static void* allocate(size_t n)
    {
        // a pointer to a valatile pointer to  obj
        obj * volatile * my_free_list;
        obj * result;
        // 大于128就使用第一级配置器
        if(n > (size_t) __MAX_BYTES)
        {
            return malloc_alloc::allocate(n);
        }

        // 寻找16个free list中适当的一个
        my_free_list = free_list + FREELIST_INDEX(n);
        result = *my_free_list;
        if(result == 0)
        {
            // 没有找到可用的free list，准备重新填充free list
            void* r = refill(ROUND_UP(n));
            return r;
        }
        *my_free_list = result->free_list_link;
        return result;
    }

public:
    static void deallocate(void* p, size_t n)
    {
        obj* q = (obj *)p;
        obj * volatile * my_free_list;

        // 大于128就调用第一级配置器
        if(n > (size_t)__MAX_BYTES)
        {
            malloc_alloc::deallocate(p, n);
            return;
        }

        // 寻找对应的free list
        my_free_list = free_list + FREELIST_INDEX(n);
        // 调整free list，回收区块
        q->free_list_link = *my_free_list;
        *my_free_list = q;
    }

    static void* reallocate(void* p, size_t old_sz, size_t new_sz);
};

// 以下是static data member 的定义与初值设定
template<bool threads, int inst>
char* __defalut_alloc_template<threads, inst>::start_free = 0;

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

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

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


template<bool threads, int inst>
void* __defalut_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(nobjs == 1)
        return chunk;
    // 否则准备调整free list，纳入新节点
    my_free_list = free_list + FREELIST_INDEX(n);

    // 以下在chunk空间内建立free list
    result = (obj *)chunk;  // 这一块返回给客端
    // 以下引导free list 指向新配置的空间（取自内存池）
    *my_free_list = next_obj = (obj *)(chunk + n);
    // 以下将free list 串接起来
    for(i = 1; ; i++)   // 从1开始，因为第0个将返回给客端
    {
        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;
}

template<bool thread, int inst>
char* __defalut_alloc_template<thread, 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)
        {
            // 内存池内还有一些零头，先配给适当的free list
            // 首先寻找适当的free list
            obj * volatile * my_free_list =
                free_list + FREELIST_INDEX(bytes_left);
            // 调整free list，将内存池中的残余空间编入
            ((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)
        {
            // heap 空间不足，malloc()失败
            int i;
            obj * volatile * my_free_list, *p;
            // 试着检视我们手上拥有的东西
            // 以下搜寻适当的free list
            // 所谓适当是指"尚有未用，且区块足够大"的free list
            for(i = size; i < __MAX_BYTES; i += __ALIGN)
            {
                my_free_list = free_list + FREELIST_INDEX(size);
                p = *my_free_list;
                if(p != 0)
                {
                    // 调整free list以释放未用区块
                    *my_free_list = p->free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    // 递归调用自己，修正nobjs
                    return chunk_alloc(size, nobjs);
                }
            }
            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;
        // 递归调用自己，修正nobjs
        return chunk_alloc(size, nobjs);
    }
}

typedef __defalut_alloc_template<0,0> alloc;


#endif