<STL源码剖析>配置器

1、stl六大部件

容器：各种数据结构，包括vector，list，deque,set,map等等
算法：各种常用算法，sort，search
迭代器：容器和算法之间的粘合器
防函数：类似于函数
配接器：一种修饰容器或者仿函数或者迭代器接口的东西
配置器：负责空间配置和管理。

2、空间配置器：运用层面不需要关注空间配置器，但是在容器背后，空间分配器负责容器中元素空间的分配。不称为内存分配器而称为空间分配器，是因为空间不一定是内存。可以是磁盘或其它辅助存储介质。

一般而言，内容配置操作和释放操作如下：

class Foo{};
Foo* pf = new Foo;
delete pf;

new内含两阶段操作:

调用::operator new配置内存。
调用Foo::Foo()构造对象内容。

delete同样内含两阶段操作：

先调用Foo::~Foo()将对象析构
调用::operator delete释放内存。

stl将这两个过程分离开来：

内存配置：由alloc::allocate()负责。
内存释放：由alloc::deallocate()负责。
对象构造: 由::construct()负责。
对象析构：由::destory()负责。

allocator::value_type
allocator::pointer
allocator::const_pointer
allocator::reference
allocator::const_reference
allocator::size_type
allocator::difference_type

//一个嵌套的class template，class rebind<U> 拥有唯一成员other,是一个typedef，代表allocator<U> 
allocator::rebind

//构造函数
allocator::allocator()
//拷贝构造函数
allocator::allocator(const allocator&)  
template <class U> allocator::allocator(const allocator<U>&)
//析构函数
allocator::~allocator

//返回某个对象的地址，等同于&x
pointer allocator::address(reference x) const   
const_pointer allocator::address(const_reference x) const

//分配空间，足以容纳n个元素
pointer allocator::allocate(size_type n,const void* = 0)
//归还之前分配的空间
void allocator::deallocate(pointer p,size_type n)
//可分配的最大空间
size_type allocator::max_size() const

//通过x，在p指向的地址构造一个对象。相当于new((void*)p) T(x)
void allocator::construct(pointer p,const T& x)
//析构地址p的对象
void allocator::destroy(pointer p)

std::alloc：分配器位于<memory>中，内含两个文件，负责分离的2阶段操作。

对象构造和析构

相关文件位于<stl_construct.h>

stl规定分配器必须拥有名有construct()和destory()两个成员函数

内存配置和释放

对象构造前的空间配置和内存释放由<stl_alloc.h>负责。设计哲学如下：

向system heap请求空间
考虑多线程状态
考虑内存不足的应变措施
考虑过多小型区块造成的内存碎片问题。

c++的内存分配基本操作是::operator new()，内存释放基本操作是::operator delete(),这两个函数相当于c中的malloc和free函数。

两级分配器:

第一级分配器：直接使用malloc()和free()
第二级分配器

当配置区域超过128byte时，使用第一级分配器
当配置区域小于128byte时，使用第二级分配器。使用了内存池。

无论alloc被定义为第一级或第二级分配器，SGI还为它再包装一个接口，使分配器的接口能够符合STL规格：

template<class T, class Alloc>
class simple_alloc {

public:
    static T *allocate(size_t n)
                { return 0 == n? 0 : (T*) Alloc::allocate(n * sizeof (T)); }
    static T *allocate(void)
                { return (T*) Alloc::allocate(sizeof (T)); }
    static void deallocate(T *p, size_t n)
                { if (0 != n) Alloc::deallocate(p, n * sizeof (T)); }
    static void deallocate(T *p)
                { Alloc::deallocate(p, sizeof (T)); }
};

第一级分配器:__malloc_alloc_template

//一般而言是线程安全，并且对于空间的运用比较高效
//无“template型别参数”，至于”非型别参数“inst，则完全没派上用场
template <int inst>
class __malloc_alloc_template {

private:
//oom：out of memory ，用来处理内存不足的情况
static void *oom_malloc(size_t);

static void *oom_realloc(void *, size_t);

#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
    static void (* __malloc_alloc_oom_handler)();
#endif

public:

static void * allocate(size_t n)
{
    void *result = malloc(n);//第一级分配器直接使用malloc()
    //以下无法满足需求时，改用oom_malloc()
    if (0 == result) result = oom_malloc(n);
    return result;
}

static void deallocate(void *p, size_t /* n */)
{
    free(p);//第一级分配器直接使用free()
}

static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz)
{
    void * result = realloc(p, new_sz);//第一级分配器直接使用realloc()
    //以下无法满足需求时，改用oom_realloc()
    if (0 == result) result = oom_realloc(p, new_sz);
    return result;
}

//以下仿真C++的set_new_handler()。可以通过它指定自己的
//out-of-memory handler
//不能直接运用C++ new-handler机制，因为它并非使用::operator new来分配内存
static void (* set_malloc_handler(void (*f)()))()
{
    void (* old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = f;
    return(old);
}

};

// malloc_alloc out-of-memory handling

#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
//初值为0，有待客户设定
template <int inst>
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;
#endif

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

第二级分配器：__default_alloc_template

第二级分配器多了一些机制，避免太多小额内存造成内存碎片。小额区块存在以下问题

产生内存碎片
额外负担主要指一些区块信息，用以管理内存。区块越小，额外负担所占的比例越大，越显浪费。
当区块大于128bytes,看成大区块
当区块小于128bytes，看成小区块

以内存池管理(也称为次层分配)：分配一大块内存，并维护对应的自由链表。下次若载有相同大小的内存需求，就直接从free-list中拔出。如果释放小额区块，就由分配器会受到free-list中。维护有16个free-list。各自管理大小分别为8，16，24，32，40，48，56，64，72，80，88，96，104，112，120，128bytes的小额区块。第二级分配器会自动将任何小区块内存需求量上调至8的倍数。

union obj{
    union obj* free_list_link;
    char client_data[1];
}

空间分配函数allocate()：

若区块大于128bytes，就调用第一级分配器
如区块小于128bytes，检查对应的free-list

若free-list之内有可用的区块，就直接用，如果没有可用区块，就上调至8的倍数。然后调用refill()，准备为free-list重新填充空间。

空间释放函数deallocate():

若区块大于128bytes，就调用第一级分配器
若区块小于128bytes，找出对应的free-list，将区块回收.

重新填充free-list的函数refill():

若free-list中没有可用区块时，会调用chunk_alloc从内存池中申请空间重新填充free-list。缺省申请20个新节点(新区块)，如果内存池空间不足，获得的节点数可能小于20.

chunk_alloc()从内存池中申请空间，根据end_free-start_free判断内存池中剩余的空间

剩余空间充足：直接调出20个区块返回给free-lis
如果剩余空间不足以提供20个区块，但足够供应至少1个区块，拨出这不足20个区块的空间
如果剩余空间连一个区块都无法供应，

利用malloc()从heap中分配内存
如果malloc()获取失败，chunk_alloc()就四处寻找有无”尚有未用且区块足够大“的free-list。找到了就挖出一块交出。
如果上一步仍未成功，那么就调用第一级分配器，第一级分配器有out-of-memory处理机制，或许有机会释放其它的内存拿来此处使用。如果可以，就成功，否则抛出bad_alloc异常

迭代器：

value type:指迭代器所指对象的类型
difference type：用以表示两个迭代器之间的距离
pointer:如果value type是T,那么pointer就是指向T的指针
reference:如果value type是T，那么reference就是T的引用
iterator category:迭代器的类型。

<STL源码剖析>配置器

猜你喜欢