考虑到小型区块所可能造成的内存破碎问题，SGI 设计了双层级配置器，第一级配置器参见博文 http://blog.csdn.net/wenqian1991/article/details/19566499。这里则学习第二级配置器，第二级配置器的设计思想为：
- 如果配置区块超过128 bytes，则移交给第一级配置器处理；
- 如果配置区块小于128 bytes，则采用内存池管理（memory pool）。每次配置一大块内存，则维护对应的自由链表（free-list），下次若再有相同大小的内存需求，就直接从 free-list 中拨出（没有就继续配置内存，具体后面讲述），如果客端释换小额区块，就有配置器回收到 free-list 中。
需要说明的是：本系列引用的STL源码版本为 v3.3，对比版本 v2.03 风格上有了些许变化，但设计思想还是不变的。
/* part of stl source code v3.3 */
enum { _ALIGN = 8 }; //小型区块的上调边界
enum { _MAX_BYTES = 128 }; //小型区块的上限
enum { _NFREELISTS = 16 }; // _MAX_BYTES/_ALIGN //free-list 编号数
//配置内存后，维护对应内存块的空闲链表节点结构
union _Obj {
union _Obj* _M_free_list_link; //空闲链表
char _M_client_data[1]; /* The client sees this. 用户使用的*/
};union _Obj 中的 _M_client_data 是C/C++中常见的变长数组实现方式（如果编译器支持 0 长度的数组，还可以声明为 _M_client_data[0] 达到更节省的目的），所以 union _Obj 的大小就是一个指针大小（_M_free_list_link 指针的大小）。union 实现一物二用，这个free-list 有两个作用：一个是指向下一块空白内存（当存在于 free-list 中时），一个就是供用户使用的一块内存（不存在于 free-list）。
回顾第二级配置器的设计思想的第 2 点，内存空间的分配大致是这样的：配置器分配空间时，先从 free-list 中拨出，如果有，就直接拨出，该需求大小的区块位于 free-list 对应编号的第一位置，然后从该链表中拨出，这样该区块就不位于 free-list 中对应编号内，第一位置向后移动指向，仅此一区块(刚已经拨出去)，则指向 0 ，表示 free-list 中没有该大小的区块；如果没有则需要向 free-list 填补区块，继而转向内存块分配函数，然后分配所需大小的新区块(一次性缺省分配20个，不够就分配小于20的，至少一个)，分配成功后，第一个区块直接划给客端，然后后面的（如果有）就填进 free-list，这样下次再有相同大小的内存需求时，可直接从 free-list 中拨出，如果一个区块都分配不出，就转向调用第一级配置器里的内存分配异常处理例程。 配置器还可以回收释放的内存，释还的小额内存区块划进 free-list 中（其实是关联到 free-list 对应编号区域）。
SGI 缺省的 free-list 中都是0值，也就是说该链表中没有可用的小额区块，因为不可能 SGI STL 一开始就自动的给你分配出来（它知道你要多少呀）。
/*源码看上去相当绕口，这里精简下*/
template <bool __threads, int __inst>
__default_alloc_template<__threads, __inst>::_Obj* volatile
__default_alloc_template<__threads, __inst> ::_S_free_list[_NFREELISTS] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; //一一对应大小为 8,16 ... 128 bytes 大小的区块下面我们跟踪源码，来看看其内部是如何来实现这种机制的。
/*将 __bytes 上调至最邻近的 8 的倍数*/
static size_t
_S_round_up(size_t __bytes)
{
return (((__bytes)+(size_t)_ALIGN - 1) & ~((size_t)_ALIGN - 1));
}
/*返回 __bytes 大小的小额区块位于 free-list 中的编号*/
static size_t _S_freelist_index(size_t __bytes) {
return (((__bytes)+(size_t)_ALIGN - 1) / (size_t)_ALIGN - 1);
}static void* allocate(size_t __n) //分配大小为 __n 的区块
{
void* __ret = 0;
if (__n > (size_t)_MAX_BYTES) {
__ret = malloc_alloc::allocate(__n); //大于128 bytes 就调用第一级配置器
}
else { //__n 大小区块对应的位置：free-lists 首地址 + __n 位于free-lists 中的编号
_Obj* __STL_VOLATILE* __my_free_list //这里是二级指针，便于调整 free-lists
= _S_free_list + _S_freelist_index(__n);
# ifndef _NOTHREADS
_Lock __lock_instance;
# endif
_Obj* __RESTRICT __result = *__my_free_list; //将对应位置的区块拨出(第一个)
if (__result == 0) //如果 free-lists 中没有对应大小的区块
__ret = _S_refill(_S_round_up(__n)); //调用 _S_refill()
else {
*__my_free_list = __result->_M_free_list_link;//这个结构有点类似链式哈希表结构，这里是指向下一块空闲内存块
//二级指针调整 free-lists，拨出去的区块就不属于该链表了
__ret = __result;
}
}
return __ret;
};
如果 free-list 中没有对应大小的区块，就转去调用 _S_refill()。
template <bool __threads, int __inst>
void* //重新填充__n大小的区块进 free-list
__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
{
int __nobjs = 20; //缺省取得 20 个新区块
char* __chunk = _S_chunk_alloc(__n, __nobjs); //调用_S_chunk_alloc()
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __result;
_Obj* __current_obj;
_Obj* __next_obj;
int __i;
/*如果只获得一个新区块，直接划给用户，free-list 仍然无新节点*/
if (1 == __nobjs) return(__chunk);
__my_free_list = _S_free_list + _S_freelist_index(__n);
__result = (_Obj*)__chunk; //这一块返回给客端(分配出来的第一块)
*__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
/*接下来的区块(拨出去了__n大小给用户)填补进 free-list*/
for (__i = 1;; __i++) {
__current_obj = __next_obj;
__next_obj = (_Obj*)((char*)__next_obj + __n);
/*将分配的连续大块"分割"成__n bytes大小的区块*/
if (__nobjs - 1 == __i) { //如果新区块填补完毕
__current_obj->_M_free_list_link = 0; //free-list 最后位置指向0
break;
}
else {//把_M_free_list_link当做链表的 next 指针理解
__current_obj->_M_free_list_link = __next_obj; //将各节点串联起来填进空闲链表
}
}
return(__result);
}这个函数的具体实现思想为：
1、内存池剩余空间完全满足 20 个区块的需求量，则直接取出对应大小的空间；2、内存池剩余空间不能完全满足 20 个区块的需求量，但可以提供一个及以上的区块，
则取出能够满足需求区块的最大个数的空间；
3、内存池剩余空间不能满足一个需求区块的大小，则进行以下处理：
1. 首先判池中是否存在残余零头的内存空间，如果有则进行回收，将其划入 free-list 中的适当位置；
2. 然后向 system heap 申请空间，补充内存池。
2.1 若 heap 空间充足，则空间分配成功；
2.2 若 heap 空间不足，出现 malloc() 调用失败。
则搜寻适当的 free-list （适当是指 “尚有未有区块，且区块较大” 的 free-list ），
即搜寻 free-list 大于等于需求块的区块，将其编入内存池，然后递归调用 _S_chunk_alloc()
函数从内存池中取空间重复上述过程。如果很不幸，free-list 中没有合适的内存空间可用了，
这时候则调用第一级配置器，利用 out-of-memory 机制尝试解决内存不足问题，
结果要么内存不足的情况获得改善，要么抛出 bad_alloc 异常。
接下来直接看源码：
static char* _S_start_free; //内存池起始位置
static char* _S_end_free; //内存池末端位置
static size_t _S_heap_size; //堆空间容量
template <bool __threads, int __inst>
char*
__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,
int& __nobjs)
{
char* __result;
size_t __total_bytes = __size * __nobjs; //需要内存的总额大小
size_t __bytes_left = _S_end_free - _S_start_free; //内存池中还剩余多少可用内存
if (__bytes_left >= __total_bytes) { //剩余可用量大于需求量，直接划分出去
__result = _S_start_free; //内存池的首地址
_S_start_free += __total_bytes; //调整内存池位置
return(__result);
}
//内存池剩余空间不能完全满足需求，但至少可供应一个及以上的区块
else if (__bytes_left >= __size) {
__nobjs = (int)(__bytes_left / __size); //调整划分个数，划分出去最大量
__total_bytes = __size * __nobjs; //同上
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
}
else { //内存池剩余空间连一个区块都无法提供
size_t __bytes_to_get =//配置大小为总需求量的两倍再加上一个随配置次数逐渐增加的附加量
2 * __total_bytes + _S_round_up(_S_heap_size >> 4); /
if (__bytes_left > 0) { //充分利用内存池中的剩余空间
_Obj* __STL_VOLATILE* __my_free_list = //剩余空间寻找适当的free-list
_S_free_list + _S_freelist_index(__bytes_left);
//调整 free-list，将内存池中残余空间编入 free-list 对应位置中
((_Obj*)_S_start_free)->_M_free_list_link = *__my_free_list;
*__my_free_list = (_Obj*)_S_start_free;
}
_S_start_free = (char*)malloc(__bytes_to_get); //配置heap空间，用来补充内存池
if (0 == _S_start_free) { //system heap 空间不足，分配失败
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
for (__i = __size; //起始大小为需求区块大小
__i <= (size_t)_MAX_BYTES;
__i += (size_t)_ALIGN) { //以 8 为步长搜寻整个 free-list
__my_free_list = _S_free_list + _S_freelist_index(__i); //找到 __i大小区块在free-list 中的位置
__p = *__my_free_list;
if (0 != __p) { //如果 free-list 中该区块未使用
*__my_free_list = __p->_M_free_list_link; //调整 free-list，释放第一位置块
_S_start_free = (char*)__p; //编入内存池
_S_end_free = _S_start_free + __i;
return(_S_chunk_alloc(__size, __nobjs)); //递归调用
/*该for循环的作用就是从 free-list 中划出大于需求区块(单个）的未用空间区块到内存池，然后再从内存池中取出。
由于从大于__size 的区块开始搜寻，所以如果 free-list 中搜寻到，那么只需动用该搜寻区块的第一位置区块即可，
最后取出的空间也可能是单个区块，也可能是多个区块(取决于 free-list 未用区块的最小区块(大于__size)的大小)*/
}
}
_S_end_free = 0; //表示到处无内存可用，for循环中free-list没有搜寻到适当的未用空间
_S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get); //调用第一级配置器
/*要么内存不足的问题获得改善，要么抛出 bad_alloc 异常*/
}
_S_heap_size += __bytes_to_get; //调用第一级配置器后，内存不足问题获得改善，调整堆空间
_S_end_free = _S_start_free + __bytes_to_get; //编入内存池
return(_S_chunk_alloc(__size, __nobjs)); //重新调用 _S_chunk_alloc()
}
}内存池实际操练结果如下图：
如上图，加入程序一开始，客端就调用 _S_chunk_alloc(32, 20)，于是 malloc() 配置 40 个 32 bytes 区块，其中第 1 个返回给客端，另 19 个交给 _S_free_list [3] 维护，余 20 个留给内存池。接下来客端调用 _S_chunk_alloc(64, 20)，此时 _S_free_list [7] 是空的，必须向内存池要求空间，内存池只够供应 (32 * 20) / 64 = 10 个 64 bytes 区块，就把这 10 个区块返回，第 1 个交给客端，余 9 个由 _S_free_list [7] 维护，此时内存池全空，接下来再调用 _S_chunk_alloc(96, 20)，此时 _S_free_list [11] 空空如也，必须向内存池要求支持，而内存池此时也是空的，于是以 malloc() 配置 40 + n（附加量）个 96 bytes 区块，其中第 1 个交出，另 19 个交给 _S_free_list [11] 维护，余 20 + n 个区块留给内存池……
如果到最后，整个 system heap 空间都不够了，malloc() 分配失败，_S_chunk_alloc() 就四处寻找有无 “尚有未用区块，且足够大” 的 free-list。找到了就挖一块交出，找不到就调用第一级配置器，第一级其实也是调用 malloc() 来配置内存，但它有 out-of-memory 处理机制，或许有机会释放其它的内存拿来此处使用。如果可以，就成功，否则发出 bad_alloc 异常。
配置器自然也有释放空间的能力，这里再学习空间释放函数 deallocate()
/*空间释放后被编入 free-list*/
static void deallocate(void* __p, size_t __n)
{
if (__n > (size_t)_MAX_BYTES) //大于 128 就调用第一级配置器
malloc_alloc::deallocate(__p, __n);
else {
_Obj* __STL_VOLATILE* __my_free_list //定位到对应的 free-list
= _S_free_list + _S_freelist_index(__n);
_Obj* __q = (_Obj*)__p;
# ifndef _NOTHREADS
_Lock __lock_instance;
# endif
__q->_M_free_list_link = *__my_free_list; //调整 free-list 回收区块
*__my_free_list = __q; //回收的区块是挂接到free-list 对应区块的第一位置，而不是添加到尾端
}
}
参考资料：《STL 源码剖析》
1810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
