空间配置器，听起来高大上，那它到底是什么东西呢？

1.什么是空间配置器？

空间配置器是STL源码中实现的一个小灶，用来应对STL容器频繁申请小块内存空间的问题。他算是一个小型的内存池，以提升STL容器在空间申请方面的效率

2.了解空间配置器

STL以128个字节为分界线，将空间配置器分为了一级和二级

2.1 一级

一级空间配置器中，allocate/deallocate函数实际上就是对malloc/free做了一个简单的封装

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 /* n */)
{
    free(p);
}

//这个函数是malloc失败的时候才会调用的
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);
    }
}

当malloc失败的时候，一级空间配置器会抛异常

2.2 二级

在二级空间配置器中，会先判断带申请空间大小是否大于128个字节，如果超过了，则会去调用一级空间配置器

# ifndef __SUNPRO_CC
enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
# endif  
/* n must be > 0      */
static void * allocate(size_t n)
{
    obj * __VOLATILE * my_free_list;
    obj * __RESTRICT result;

    if (n > (size_t) __MAX_BYTES) {
        return(malloc_alloc::allocate(n));
    }
    my_free_list = free_list + FREELIST_INDEX(n);
    // Acquire the lock here with a constructor call.
    // This ensures that it is released in exit or during stack
    // unwinding.
    #       ifndef _NOTHREADS
    /*REFERENCED*/
    lock lock_instance;
    #       endif
    result = *my_free_list;
    if (result == 0) {
        void *r = refill(ROUND_UP(n));
        return r;
    }
    *my_free_list = result -> free_list_link;
    return (result);
};

/* p may not be 0 */
static void 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);
    // acquire lock
    #       ifndef _NOTHREADS
    /*REFERENCED*/
    lock lock_instance;
    #       endif /* _NOTHREADS */
    q -> free_list_link = *my_free_list;
    *my_free_list = q;
    // lock is released here
}

二级空间配置器中，主要的几个成员变量如下

static obj * __VOLATILE free_list[__NFREELISTS]; //哈希桶
// Chunk allocation state.
static char *start_free;
static char *end_free;
static size_t heap_size;

这里是一个内存池+ 一个哈希桶,内存池的长度为heap_size

哈希桶以8字节对齐，分为了16个桶。最开始的时候，free_list哈希桶是空的

当我们需要小于128个字节空间的时候（以16字节为例），二级空间配置器会直接去上面的内存池当中申请20个16字节的空间，链接到16字节对应的哈希桶的位置（1号桶）

在下面的refill函数中可以看到这一点

template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
    int nobjs = 20;//一次性申请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);

    /* Build free list in chunk */
      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);
}

8字节对齐的妙处

假设我们的list单个节点需要12个字节，set单个字节需要16个字节

当list需要空间的时候，二级空间配置器也会去申请16个字节的空间，而不会去申请12个字节。这时候，当list将用完的空间还回来之后，就能拿过去给set用了！

关于哈希桶的特殊处理

当我们用完了申请的空间，准备“释放”的时候，二级空间配置器会将释放回来的空间插入进哈希桶（头插）

这里有一个特殊处理，当用完的空间，或者说是刚申请的空间插入进哈希桶的时候，二及空间配置器会将其强转为一个obj类型，这个类型的前4/8个字节会用来存放一个指针，指向下一个空间，以此构成链表

union obj {
    union obj * free_list_link;
    char client_data[1];    /* The client sees this.        */
};

当我们再次需要这部分大小的空间的时候，只需要将哈希桶头指针的指向直接修改，就能链接上下一个空间，并将之前头指针指向的空间拿去用

用的时候也不用管之前在此处存放的指针，毕竟下一次放回来的时候，二级空间配置器会来处理它的

内存池空间不够用了咋办？

之前提到了，二级空间配置器里面有一个小内存池。要是这个内存池用完了，要咋整呢？

二级空间配置器想出来了一种很骚的做法：

假设当前我们需要24字节的空间
对应的桶下面没有空间给我们用
内存池也用光了
但是48字节的桶下面还有空间可以用
直接把这个空间拿过来，拆成两个24链接到24的桶下面！

这样便有效提高了空间利用率，也避免了realloc造成的时间消耗。

当然，要是桶里面也没有多余空间了，那就只能老老实实去扩容了

只能大的拆小的，小的空间不连续无法组成大的

//二级空间配置器里面的reallocate封装
template <bool threads, int inst>
void*
__default_alloc_template<threads, inst>::reallocate(void *p,
                                                    size_t old_sz,
                                                    size_t new_sz)
{
    void * result;
    size_t copy_sz;

    if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) {
        return(realloc(p, new_sz));
    }
    if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p);
    result = allocate(new_sz);
    copy_sz = new_sz > old_sz? old_sz : new_sz;
    memcpy(result, p, copy_sz);
    deallocate(p, old_sz);
    return(result);
}

2.3 关于单例的说明

在同一个进程里面，空间配置器只会有一个

但STL库中的空间配置器并没有把自己设计成单例类，而是用了一个间接的做法

static obj * __VOLATILE free_list[__NFREELISTS]; //哈希桶
// Chunk allocation state.
static char *start_free;
static char *end_free;
static size_t heap_size;

那就是所有成员变量都是static静态的

我们知道，在类和对象中，静态成员变量是属于整个类的，所以它也是一种单例模式！

2.4 空间配置器的优点

空间配置器的时间复杂度是O(1)，申请空间的效率很高
空间配置器能解决频繁申请空间导致的内存碎片问题

当我们使用STL容器频繁申请小块空间（比如list）就容易导致堆区中有非常多的小块空间被使用，而无法申请一个大的空间

空间配置器提前申请了一个大块空间再私下管理，可以有效解决这个问题

内存外碎片/内碎片

外碎片：多次申请小块空间造成。有足够内存，但是不连续，无法申请大块内存
内碎片：list只需要12个字节，而空间配置器因为内存对齐而给了它16个字节，浪费了4个字节造成的内存碎片

3.容器和空间配置器

之前学习stl容器的时候，就在定义中看到过这里的alloc默认模板参数

这里默认传的便是stl库中的二级空间配置器

只要你自己写的空间配置器符合stl的接口需求，你便可以将自己的空间配置器传入此处让容器使用！

typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;

在list中，alloc又被封装了一层，用来处理节点申请的问题

template <class T, class Alloc = alloc>
class list {
protected:
  typedef void* void_pointer;
  typedef __list_node<T> list_node;
  typedef simple_alloc<list_node, Alloc> list_node_allocator;

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

随后，当创建节点、销毁节点的时候，list就会调用封装好的simple_alloc来处理空间

link_type get_node() { return list_node_allocator::allocate(); }
void put_node(link_type p) { list_node_allocator::deallocate(p); } 
link_type create_node(const T& x) {
    link_type p = get_node();
    __STL_TRY {
      construct(&p->data, x);//调用节点的构造函数
    }
    __STL_UNWIND(put_node(p));
    return p;
  }
  void destroy_node(link_type p) {
    destroy(&p->data);//调用节点的析构函数
    put_node(p);
  }

construct通过定位new显式调用节点的构造函数
destroy通过指针来调用析构函数

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

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

在stl_tree.h中可以看到库里面的红黑树也对空间配置器进行了类似的封装

template <class Key, class Value, class KeyOfValue, class Compare,
          class Alloc = alloc>
class rb_tree {
protected:
  typedef void* void_pointer;
  typedef __rb_tree_node_base* base_ptr;
  typedef __rb_tree_node<Value> rb_tree_node;
  typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator;
  typedef __rb_tree_color_type color_type;