STL源码剖析-配置器

class Foo { ... }

Foo *f = new Foo();
delete f;

template <class T1, class T2>
inline void construct(T1* p, const T2& value) 
{
    new (p) T1(value); 
}

template <class T>
inline void destroy(T* pointer) 
{
    pointer->~T(); 
}

//就是一层封装
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) 
{
    __destroy(first, last, value_type(first));
}

//使用元编程技术，获取操作数据的类型，判断是POD类型还是非POD类型
template <class ForwardIterator, class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*)
{
    typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
    __destroy_aux(first, last, trivial_destructor());
}

//非POD类型，单个析构每一个对象
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type)
{
    for( ; first < last; ++first)
        destroy(&*first);
}

//POD类型无需析构
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) 
{
}

//下面两个函数是特化版本，只为提升效率
//char是8位，ANSI编码
//wchar_t是16位或32位，根据C或C++库而定，是Unicode编码
inline void destroy(char*, char*) {}
inline void destroy(wchar_t*, wchar_t*) {}

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);//oom_malloc中会尝试获取内存，并分配内存
        return result;
    }
    
    static void deallocate(void *p, size_t)
    {
        free(p); 
    }
    
    static void * 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);//oom_realloc中会尝试获取内存，并分配内存
        return result;
    }

    //设置回收内存的函数，并返回原来回收内存的函数
    static void (* set_malloc_handler(void (*f)()))()
    {
        void (* old)() = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = f;
        return(old);
    }
};

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

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; //抛出alloc的异常，表示申请内存失败
        }
        
        (*my_malloc_handler)();
        result = malloc(n);
        
        // 再次尝试配置内存。
        if (result) 
            return(result);
    }
}

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);
    }
}

union obj {
    union obj * free_list_link; //指向下一个节点
    char client_data[1]; //指向一块内存
};

enum {__ALIGN = 8}; // 对齐倍数是8
enum {__MAX_BYTES = 128}; //一二级配置器的分界点
enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; // free-lists的个数

class __default_alloc_template 
{
private:
    //将bytes调整从8的倍数，向上调整
    static size_t ROUND_UP(size_t bytes) 
    {
        return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
    }
    
private:
    // free-lists 的节点构造
    union obj 
    { 
        union obj * free_list_link;
        char client_data[1];
    };
    
private:
    // 16个free-lists
    static obj * volatile free_list[__NFREELISTS];

    // 根据申请的内存大小，获取数组下标，确定从哪个链表中获取内存
    // n从1算起
    static size_t FREELIST_INDEX(size_t bytes) 
    {
        return (((bytes) + __ALIGN-1)/__ALIGN - 1);
    }
    
    // 从内存池中获取一块内存，调用chunk_alloc，并插入到某一个链表中
    static void *refill(size_t n);
   
    // 从内存池中获取内存
    static char *chunk_alloc(size_t size, int &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){ /* 详述于后 */ }
};

// 以下是静态变量的定义
char *__default_alloc_template<threads, inst>::start_free = 0;

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

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

__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, };

static void * allocate(size_t n)
{
    obj * volatile * my_free_list;
    obj * result;
    
    // 大于128调用第一级配置器
    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);
};

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;
    }

    // 根据释放的内存大小，找出数组中的某一个列表
    my_free_list = free_list + FREELIST_INDEX(n);
    // 将释放的内存头插入链表
    q -> free_list_link = *my_free_list;
    // 将头结点放入数组
    *my_free_list = q;
}

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;

    // 如果从内存池中只获取到了一个节点的内存，那就直接返回
    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);
}

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;
    } 
    else if (bytes_left >= size) 
    {
        // 内存池中的内存大于一个节点的需要的内存大小，有多少返回多少
        nobjs = bytes_left/size;
        total_bytes = size * nobjs;
        result = start_free;
        start_free += total_bytes;
        return(result);
    } 
    else 
    {
        // 池子中的内存都不够一个节点所需要的大小，直接向堆空间申请
        // 每次申请的大小是2倍实际申请大小，加上一个越来越带的随机值(8的倍数)
        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;
        }
        
        // 直接向堆空间申请
        start_free = (char *)malloc(bytes_to_get);
        // 申请失败就在链表数组中，需要内存大的数组，找出一块内存返回
        if (0 == start_free) 
        {
            int i;
            obj * volatile * my_free_list, *p;

            for (i = size; i <= __MAX_BYTES; i += __ALIGN) 
            {
                my_free_list = free_list + FREELIST_INDEX(i);
                p = *my_free_list;
                if (0 != p) 
                {
                    *my_free_list = p -> free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    return(chunk_alloc(size, nobjs));
                }
            }
            // 数组中所有的链表都没有内存了，山穷水尽了，直接向一级配置器申请，可能抛异常
            end_free = 0;
            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));
    }
}

typedef typename __type_traits<T>::is_POD_type is_POD;

typename __type_traits<T>::is_POD_type //提取出类型T中is_POD_type的类型

is_POD() // 构造一个临时的is_POD对象，便于调用重载函数
    
// STL中，默认将所有类型都设置为非POD对象，即属于类型__false_type类的成员
    
// 例子：
    struct __false_type; // 定义类型
    struct __true_type;

    // 数据类型中定义is_POD_type，后续就可以使用了
    typedef  __false_type is_POD_type;

// 对外统一接口
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result)
{
    return __uninitialized_copy(first, last, result, value_type(result));
}

// 提取数据的类型，分别调用处理POD数据的函数和非POD数据的函数
template <class InputIterator, class ForwardIterator, class T>
inline ForwardIterator __uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result, T*)
{
    typedef typename __type_traits<T>::is_POD_type is_POD;
    return __uninitialized_copy_aux(first, last, result, is_POD());
}

// POD数据直接拷贝
template <class InputIterator, class ForwardIterator>
inline ForwardIterator __uninitialized_copy_aux(InputIterator first, InputIterator last, ForwardIterator result, __true_type) 
{
    return copy(first, last, result); // 后续讲解，算法章节
}

//非POD数据单独掉调用替换构造函数拷贝，循环处理
template <class InputIterator, class ForwardIterator>
ForwardIterator __uninitialized_copy_aux(InputIterator first, InputIterator last, ForwardIterator result, __false_type) 
{
    ForwardIterator cur = result;

    for ( ; first != last; ++first, ++cur)
        construct(&*cur, *first); 
    return cur;
}
// 特化函数
template<>
inline char* uninitialized_copy(const char* first, const char* last, char* result) 
{
    memmove(result, first, last - first); // 处理字符串的效率非常高
    return result + (last - first);
}

// 特化函数
template<>
inline wchar_t* uninitialized_copy(const wchar_t* first, const wchar_t* last, wchar_t* result) 
{
    memmove(result, first, sizeof(wchar_t) * (last - first));
    return result + (last - first);
}

// 对外统一接口
template <class ForwardIterator, class T>
inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x)
{
    __uninitialized_fill(first, last, x, value_type(first));
}

// 提取数据的类型，分别调用处理POD数据的函数和非POD数据的函数
template <class ForwardIterator, class T, class T1>
inline void __uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x, T1*) 
{
    typedef typename __type_traits<T1>::is_POD_type is_POD;
    __uninitialized_fill_aux(first, last, x, is_POD());
}

// POD数据直接拷贝
template <class ForwardIterator, class T>
inline void __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, const T& x, __true_type)
{
    fill(first, last, x); // 后续讲解，算法章节
}

//非POD数据单独掉调用替换构造函数拷贝，循环处理
template <class ForwardIterator, class T>
void __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, const T& x, __false_type)
{
    ForwardIterator cur = first;

    for ( ; cur != last; ++cur)
        construct(&*cur, x); 
}

// 对外统一接口
template <class ForwardIterator, class Size, class T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x) 
{
    return __uninitialized_fill_n(first, n, x, value_type(first));
}

// 提取数据的类型，分别调用处理POD数据的函数和非POD数据的函数
template <class ForwardIterator, class Size, class T, class T1>
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n, const T&x, T1*)
{
    typedef typename __type_traits<T1>::is_POD_type is_POD;
    return __uninitialized_fill_n_aux(first, n, x, is_POD());
}

// POD数据直接拷贝
template <class ForwardIterator, class Size, class T>
inline ForwardIterator __uninitialized_fill_n_aux(ForwardIterator first, Size n, const T& x, __true_type)
{
    return fill_n(first, n, x); // 后续讲解，算法章节
}

//非POD数据单独掉调用替换构造函数拷贝，循环处理
template <class ForwardIterator, class Size, class T>
ForwardIterator __uninitialized_fill_n_aux(ForwardIterator first, Size n, const T& x, __false_type) 
{
    ForwardIterator cur = first;

    for ( ; n > 0; --n, ++cur)
        construct(&*cur, x); 
    return cur;
}