STL——空间的配置和释放std::alloc（第一级配置器和第二级配置器）

1 空间的配置和释放，std::alloc

对象构造前的空间配置和对象析构后的空间释放，由<stl_alloc.h>负责，SGI对此的设计哲学如下：

• 向system heap要求空间
• 考虑多线程状态
• 考虑内存不足时的应变措施
• 考虑过多“小型区块”可能造成的内存碎片问题

C++的内存配置基本操作是::operator new(),内存释放基本操作是::operator delete().这两个全局函数相当于C的malloc()和free()函数。是的，正是如此，SGI正是以malloc()和free()完成内存的配置和释放。

考虑到小型区别所可能造成的内存碎片问题。SGI设计了双层配置器，第一级配置器直接使用malloc()和free()，第二级配置器则视情况采用不同的策略；当配置区块超过128bytes时，视之为“足够大”，便调用第一级配置器；当配置区块小于128bytes时，视之为“过小”，为了降低额外负担，便采用复杂的memory pool整理方式，而不再求助于第一级配置器。整个设计究竟是开放第一级配置器或是同时开放第二级配置器，取决于_USE_MALLOC是否被定义：

# ifdef __USE_MALLOC
...
typedef __malloc_alloc_template<0> malloc_alloc; <span style="font-family:KaiTi_GB2312;">//令 alloc为第一级配置器</span>
typedef malloc_alloc alloc;
# else
...
//令 alloc 为第二级配置器
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
#endif /* ! __USE_MALLOC */

其中__malloc_alloc_template就是第一级配置器，__default_alloc_template就是第二级配置器。

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

其内部四个成员函数其实都是弹单纯的转调用，调用传递给配置器（可能是第一级也可能是第二级）的成员函数。

一、二级配置器的关系如下：

图 第一级配置器和第二级配置器

第一级和第二级配置器的包装接口和运用方式如下：

2 第一级配置器__malloc_alloc_template剖析

首先我们观察第一级配置器：

#if 0
#   include <new>
#   define  __THROW_BAD_ALLOC throw bad_alloc
#elif !defined(__THROW_BAD_ALLOC)
#   include <iostream.h>
#   define  __THROW_BAD_ALLOC cerr << "out of memory" << endl; exit()
#endif 

// malloc-based allocator. 通常比稍后介绍的 default alloc 速度慢，
//一般而言是 thread-safe，并且对于空间的运用比较高效（efficient）。
//以下是第一级配置器。
//注意，无「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);
static void (* __malloc_alloc_oom_handler)(); 

public: 

static void * allocate(size_t n)
{
    void  *result =malloc(n);//第一级配置器直接使用 malloc()
    // 以下，无法满足需求时，改用 oom_malloc()
    if ( == 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);//第一级配置器直接使用 rea
    // 以下，无法满足需求时，改用 oom_realloc()
    if ( == result) result = oom_realloc(p, new_sz);
    return  result;
} 

//以下模拟 C++的 set_new_handler(). 换句话说，你可以透过它，
//指定你自己的 out-of-memory handler
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
//初值为 0。有待客端设定。
template <int inst>
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = ; 

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  (  ==  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  (  ==  my_malloc_handler)  {  __THROW_BAD_ALLOC; }
        (*my_malloc_handler)();//呼叫处理例程，企图释放内存。
        result = realloc(p, n);//再次尝试配置内存。
        if  (result)  return(result);
    }
} 

//注意，以下直接将参数 inst指定为 0。
typedef __malloc_alloc_template<> malloc_alloc;
 

第一级配置器直接使用malloc(),free(),realloc()等C函数执行实际的内存配置、释放、重配置操作，并实现出类似C++ new handler机制。它有独特的out-of-memory内存处理机制：在抛出std::bad_alloc异常之前，调用内存不足处理例程尝试释放空间，如果用户没有定义相应的内存不足处理例程，那么还是会抛出异常。

所谓C++ new handler机制是，你可以要求系统在内存配置要求无法被满足时，调用一个你所指定的函数。换句话说，一旦::operator new无法完成任务，在丢出std::bad_alloc异常状态之前，会先调用由客户端指定的处理例程，该处理例程通常即被称为new-handler。new-handler解决内存不足的做饭有特定的模式。

请注意，SGI第一级配置器的allocate()和realloc()都是在调用malloc()和realloc()不成功后，该调用oom_malloc()和oom_realloc()。后两者都有内循环，不断调用“内存不足处理例程”，期望在某次调用之后，获得足够的内存而圆满完成任务。但如果“内存不足处理例程”并未被客户端设定，oom_malloc()和oom_realloc()便老实不客气地调用__THROW_BAD_ALLOC，丢出bad_alloc异常信息，或利用exit(1)硬生生中止程序。

记住，设计“内存不足处理例程”是客端的责任，设定“内存不足处理例程”也是客端的责任。

3 第二级配置器__default_alloc_template剖析

本文讲解SGI STL空间配置器的第二级配置器。

相比第一级配置器，第二级配置器多了一些机制，避免小额区块造成内存的碎片。不仅仅是碎片的问题，配置时的额外负担也是一个大问题。因为区块越小，额外负担所占的比例就越大。

额外负担是指动态分配内存块的时候，位于其头部的额外信息，包括记录内存块大小的信息以及内存保护区（判断是否越界）。要想了解详细信息，请参考MSVC或者其他malloc实现。

SGI STL第二级配置器具体实现思想

如下：

1. 如果要分配的区块大于128bytes，则移交给第一级配置器处理。
2. 如果要分配的区块小于128bytes，则以内存池管理（memory pool），又称之次层配置（sub-allocation）：每次配置一大块内存，并维护对应的*链表（free-list）。下次若有相同大小的内存需求，则直接从free-list中取。如果有小额区块被释放，则由配置器回收到free-list中——是的，别忘了，配置器除了负责配置，也负责回收。

下面详细节介绍内存池管理技术。

在第二级配置器中，小额区块内存需求大小都被上调至8的倍数，比如需要分配的大小是30bytes，就自动调整为32bytes。系统中总共维护16个free-lists，各自管理大小为8,16，...，128bytes的小额区块。

为了维护链表，需要额外的指针，为了避免造成另外一种额外的负担，这里采用了一种技术：用union表示链表节点结构：

  union obj {
        union obj * free_list_link;//指向下一个节点
        char client_data[1];    /* The client sees this. */
  };

union能够实现一物二用的效果，当节点所指的内存块是空闲块时，obj被视为一个指针，指向另一个节点。当节点已被分配时，被视为一个指针，指向实际区块。

下面是第二级配置器的部分实现内容：

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

以下是第二级配置器总体实现代码概览：

template <bool threads, int inst>
class __default_alloc_template {

private:
  // 實際上我們應該使用 static const int x = N
  // 來取代 enum { x = N }, 但目前支援該性質的編譯器還不多。
# ifndef __SUNPRO_CC
    enum {__ALIGN = };
    enum {__MAX_BYTES = };
    enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
# endif
  static size_t ROUND_UP(size_t bytes) {
        return (((bytes) + __ALIGN-) & ~(__ALIGN - ));
  }
__PRIVATE:
  union obj {
        union obj * free_list_link;
        char client_data[];    /* The client sees this. */
  };
private:
# ifdef __SUNPRO_CC
    static obj * __VOLATILE free_list[];
        // Specifying a size results in duplicate def for 4.1
# else
    static obj * __VOLATILE free_list[__NFREELISTS];
# endif
  static  size_t FREELIST_INDEX(size_t bytes) {
        return (((bytes) + __ALIGN-)/__ALIGN - );
  }

  // Returns an object of size n, and optionally adds to size n free list.
  static void *refill(size_t n);
  // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
  // if it is inconvenient to allocate the requested number.
  static char *chunk_alloc(size_t size, int &nobjs);

  // Chunk allocation state.
  static char *start_free;
  static char *end_free;
  static size_t heap_size;

 /* n must be > 0      */
  static void * allocate(size_t n){...}

 /* p may not be 0 */
  static void deallocate(void *p, size_t n){...}
 static void * reallocate(void *p, size_t old_sz, size_t new_sz);

template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::start_free = ;//内存池起始位置

template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::end_free = ;//内存池结束位置

template <bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = ;
template <bool threads, int inst>
__default_alloc_template<threads, inst>::obj * __VOLATILE
__default_alloc_template<threads, inst> ::free_list[
# ifdef __SUNPRO_CC
    __NFREELISTS
# else
    __default_alloc_template<threads, inst>::__NFREELISTS
# endif
] = {, , , , , , , , , , , , , , , , };

空间配置函数allocate()

具体实现如下：

1. 要分配的区块小于128bytes，调用第一级配置器。
2. 否则，向对应的free-list寻求帮助。

• 对应的free list有可用的区块，直接拿过来用。
• 如果没有可用的区块，调用函数refill()为free list重新填充空间。

代码如下：

 /* 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 == ) {
        void *r = refill(ROUND_UP(n));
        return r;
    }
    *my_free_list = result -> free_list_link;
    return (result);
  };

这里需要注意的是，每次都是从对应的free list的头部取出可用的内存块。
图示如下：

refill()-为free list填充空间

当发现对应的free list没有可用的空闲区块时，就需要调用此函数重新填充空间。新的空间将取自于内存池（将经由chunk_alloc()完成）。缺省取得20个新节点（新区块），但万一内存池空间不足，获得的节点数（区块数）可能小于20，内存池的管理后面会讲到。

/* Returns an object of size n, and optionally adds to size n free list.*/
/* We assume that n is properly aligned.                                */
/* We hold the allocation lock.                                         */
template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
    int nobjs = ;
    //调用chunk_alloc()，尝试取得nobjs个区块作为free list的新节点，注意参数nobjs是pass by reference
    char * chunk = chunk_alloc(n, nobjs);
    obj * __VOLATILE * my_free_list;
    obj * result;
    obj * current_obj, * next_obj;
    int i;

    if ( == 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 = ; ; i++) {//将各节点串接起来（注意，索引为0的返回给客端使用）
        current_obj = next_obj;
        next_obj = (obj *)((char *)next_obj + n);
        if (nobjs -  == i) {
            current_obj -> free_list_link = ;
            break;
        } else {
            current_obj -> free_list_link = next_obj;
        }
      }
    return(result);
}

chunk_alloc-从内存池中取空间供free list使用

具体实现思想如下：

1. 内存池剩余空间完全满足20个区块的需求量，则直接取出对应大小的空间。
2. 内存池剩余空间不能完全满足20个区块的需求量，但是足够供应一个及一个以上的区块，则取出能够满足条件的区块个数的空间。
3. 内存池剩余空间不能满足一个区块的大小，则

• 首先判断内存池中是否有残余零头内存空间，如果有则进行回收，将其编入free list。
• 然后向heap申请空间，补充内存池。
  • heap空间满足，空间分配成功。
  • heap空间不足，malloc()调用失败。则
    • 搜寻适当的free list（适当的是指：尚有未用区块，并且区块足够大），调整以进行释放，将其编入内存池。然后递归调用chunk_alloc函数从内存池取空间供free list。
    • 搜寻free list释放空间也未能解决问题，这时候调用第一级配置器，利用out-of-memory机制尝试解决内存不足问题。如果可以就成功，否则排除bad_alloc异常。

源代码如下：

缺省状况下取得20个新区块，但是如果内存池空间不够，取得的节点数就有可能小于20.下面是SGI STL中的源代码：

/* We allocate memory in large chunks in order to avoid fragmenting     */
/* the malloc heap too much.                                            */
/* We assume that size is properly aligned.                             */
/* We hold the allocation lock.                                         */
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 =  * total_bytes + ROUND_UP(heap_size >> );//注意此处申请的空间的大小
        // Try to make use of the left-over piece.
        if (bytes_left > ) {
            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 ( == start_free) {
            int i;
            obj * __VOLATILE * my_free_list, *p;
            // Try to make do with what we have.  That can't
            // hurt.  We do not try smaller requests, since that tends
            // to result in disaster on multi-process machines.
            for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
                my_free_list = free_list + FREELIST_INDEX(i);
                p = *my_free_list;
                if ( != p) {
                    *my_free_list = p -> free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    return(chunk_alloc(size, nobjs));
                    // Any leftover piece will eventually make it to the
                    // right free list.
                }
            }
        end_free = ;    // In case of exception.
            start_free = (char *)malloc_alloc::allocate(bytes_to_get);
            // This should either throw an
            // exception or remedy the situation.  Thus we assume it
            // succeeded.
        }
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        return(chunk_alloc(size, nobjs));
    }
}

上述的chunk_alloc()函数以end_free-start_free来判断内存池的水量，如果水量充足，就直接调用20个区块返回给free list。如果水量不足以提供20个区块，但还足够供应一个以上的区块，就拔出这不足20个区块的空间出去。这时候其pass by reference的nobjs参数将被修改为实际能够供应的区块数。如果内存池连一个区块空间都无法供应，对客端显然无法交代，此时便需利用malloc()从heap中配置内存，为内存池注入活水以应付需求。新水量的大小为需求量的两倍，再加上一个随着配置次数增加而愈来愈大的附加量。

举个例子，假设程序一开始，客端就调用chunk_alloc(32,20),于是 malloc()配置40个32bytes区块，其中第1个交出，另19个交给free_list[3]维护，余20个留给内存池。接下来客端调用chunk_alloc(64,20)，此时free_list[7]也空空如也，必须向内存池要求支持。内存池只够供应(32*20)/64=10个bytes区块，就把这10个区块返回，第一个交给客端，余9个由free_list[7]维护。此时内存池全空。接下来再调用chunk_alloc(96,20)，此时free_list[11]也空空如也，必须向内存池要求支持，而内存池此时也是空的，于是以malloc()配置40+n（附加量）个96bytes区块，其中交出1个，令19个交个free_list[11]维护，余20+n（附加量）个区块留给内存池。

万一山穷水尽，整个system heap空间都不够了（以至于无法为内存池注入源头活水），malloc()行动失败，chunk_alloc()就四处寻找有无“尚有未用区域，且区块够大”之free lists。找到了就挖一块交出，找不到就调用第一级配置器，第一级配置器其实就是使用malloc()来配置内存，但它有out-of-memory处理机制，或许有机会释放其他的内存拿来此处使用，如果可以，就成功，否则发出bad_alloc异常。

以上便是整个第二级配置器的设计。

回想一些那个提供配置器标准接口的simple_alloc：

template<class T, class Alloc>
class simple_alloc{
    ...
};

SGI容器通常以这种方式来使用配置器：
template<class T,class Alloc=alloc> //缺省使用alloc配置器
class vector{
public:
    typedef T value_type;
    ...
protected:
    //专属之空间配置器，每次配置一个元素大小
    typedef simple_alloc<value_type,Alloc> data_allocator;
    ...
};

　　其中第二个tmplate参数所使用的缺省参数alloc，可以是第一级配置器也可以是第二级配置器。不过，SGI STL已经把它设为第二级配置器。

deallocate()-空间释放函数

1. 如果需要回收的区块大于128bytes，则调用第一级配置器。
2. 如果需要回收的区块小于128bytes，找到对应的free -list，将区块回收。注意是将区块放入free -list的头部。

SGI STL源代码：

 /* 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
  }