SGI的空间配置器allocator只是简单的new和delete的一层包装，没有提供效率的强化。
而一般C++内存配置和释放操作如下：
class Foo { ... }
Foo *pf = new Foo;
delete pf;
new算式：1）使用new配置内存，2）使用Foo构造对象
delelte算式： 1）使用~Foo()将对象析构 ，2）使用delete释放内存
STL allocator 将这两阶段操作区分开来。内存配置操作由 alloc::allocate() 负责，内存释放操作由 alloc::deallocate() 负责；对象构造操作由 ::construct() 负责，对象析构操作由 ::destroy() 负责。
如下图是STL allocator的构造：
| <stl_constuct.h> //全局函数：constrcut(),destory()负责对象的构造和析构
<memory>----- |<stl_alloc.h> // 一、二级配置器（alloc）
|<stl_uninitialized.h> //全局函数：un_initialized_copy()、un_initialized_fill()、un_initialized_fill_n() 复制填充大块内存数据
//这些函数会考虑效率，最差用constrcut()，最佳时用memmove()直接进行内存移动
一、<stl_constuct.h>
constrcut()
template<class T1,class T2>
inline void construct(T1*p,const T2&value )
{
new (p) T1(value);
}
destory()
template<class T>//版本一
inline void destroy(T* pointer)
{
pointer->~T();
}
template<class ForwardIterator,class T>//版本二
inline void destroy(ForwardIterator first,ForwardIterator last,T*)
{
typedef typename _type_traits<T>::has_trivial_destructor tivial_destructor();
_destory_aux(first,last,trivial_destructor);
}
版本二会根据数值型别判断，如果是_true_type就什么也不做， _false_type会循环每个对象依次调用版本一的destroy
二、<stl_alloc.h>
SGI对此的设计哲学如下：
1. 向 system heap 要求空间。
2. 考虑多线程（multi-threads）状态。
3. 考虑内存不足时的应变措施。
4. 考虑过多“小型区块”可能造成的内存碎片（fragment）问题。
为了处理小型区块可能造成的内存碎块，SGI设计两层配置器，如下：
第一级： （大于128bytes） 第二级
template <int inst> template<bool threads,int inst>
class _malloc_alloc_template{..} class _default_alloc_template{..};
其中： 其中：
1、allocate()直接使用malloc() 1、维护16个 free lists,负责16种小型区块的次配置能力
deallocate()直接使用free() 内存池(memory pool)以malloc配置而得，内存不足转第一级配置器
2、模拟C++的set_new_handler()处理内存不足 2、需求区块大于128bytes，转第一级配置器
由于第一级，第二级只是以128bytes判断，所以需要用simple_alloc接口进行封装，使得由bytes转为元素大小。
下面看看第一级配置器的内存不足处理
template <int inst>
class __malloc_alloc_template {
private://处理内存不足函数
static void *oom_malloc(size_t);
static void *oom_realloc(void *, size_t);
static void (* __malloc_alloc_oom_handler)();
static void (* set_malloc_handler(void (*f)()))()
{
void (* old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return(old);
}
}
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);
}
}
第二级配置器：
当区块小于128bytes，每次配置一大块内存，并维护其对应的自由链表，配置器负责分配与回收。
free-lists节点结构:
为了尽最大可能减少内存的使用, 这里使用一个union ,如果使用第一个成员, 则指向另一个相同的union obj ,如果使用第二个成员, 则指向实际的内存区域 ,这样就实现了链表结点只使用一个指针的大小空间, 却能同时做索引和指向内存区域!!!!!
union obj {
union obj * free_list_link;
char client_data[1]; /* The client sees this. */
};
第二级配置器中主要有
ROUND_UP(x):负责将输入的字节数上调至8的倍数,如下：
(x+7)&~7 // +7是上升一个8的倍数，然后~7是清除/8的余数
allocate(): 首先判断区块大小，大于128就调用第一级，小于128时就检查 free list， free list里有可用的区块就直接用，若没有就将区块大小上升至8的倍数，然后用refill()为 free list重新填充空间。如下：
static void * allocate(size_t n)
{
obj * __VOLATILE * my_free_list;
obj * __RESTRICT result;
// 大于128 就调用第一级配置器
if (n > (size_t) __MAX_BYTES) {
return(malloc_alloc::allocate(n));
}
// 寻找 16 个free lists中适当的一个
my_free_list = free_list + FREELIST_INDEX(n);
#ifndef _NOTHREADS
/*REFERENCED*/
lock lock_instance;
#endif
result = *my_free_list;
if (result == 0) {
// 没找到可用的 free list，准备重新填充 free list
void *r = refill(ROUND_UP(n));
return r;
}
// 调整 free list
*my_free_list = result -> free_list_link;
return (result);
};
my_free_list = free_list + FREELIST_INDEX(n); //my_free_list会定位到数组16个元素的某一个（里面存的是对应链表头的地址） result = *my_free_list; //result 是一个指针，会指向对应的链表头 deallocate(): 首先判断区块大小，大余128就调用第一级配置器，小于128就找相应的freelist，将区块回收
static void deallocate(void *p, size_t n) //p是待回收的内存地址，n是对应freelist 要回收的地方
{
obj *q = (obj *)p;
obj * __VOLATILE * my_free_list;
// 大于 128 就调用第一级配置器
if (n > (size_t) __MAX_BYTES) {
malloc_alloc::deallocate(p, n);
return;
}
// 寻找对应的 free list
my_free_list = free_list + FREELIST_INDEX(n);
// acquire lock
#ifndef _NOTHREADS
/*REFERENCED*/
lock lock_instance;
#endif /* _NOTHREADS */
// 调整 free list，回收区块
q -> free_list_link = *my_free_list;
*my_free_list = q; //把这段待放的内存块插入链表头
// lock is released here
}
refill()：发现freelist没有可用空间时，从内存池（chunk_alloc（）完成），缺省取20，内存池不足时，可能小于20.
// 返回一个大小为 n 的对象，并且有时候会为适当的 free list 增加节点
// 假设 n 已经适当上调至 8 的倍数
/* We hold the allocation lock. */
template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
int nobjs = 20;
// 调用 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;
// 如果只获得一个区块，这个区块就分配给调用者用，free list无新节点
if (1 == nobjs) return(chunk);
// 否则准备调整 free list，纳入新节点
my_free_list = free_list + FREELIST_INDEX(n);
// 以下在 chunk 空间内建立 free list
result = (obj *)chunk; // 这一块准备返回给客户端
// 以下导引 free list 指向新配置的空间(取自内存池)
*my_free_list = next_obj = (obj *)(chunk + n);
// 以下将 free list的各节点串接起来
for (i = 1; ; i++) { // 从 1 开始，因为第 0 个将返回给客端
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():是从内存池取内存给freelist的。如果有足够块数就直接返回，不足时就返回整数块数。如果连一块都不足时，首先考虑将内存池剩余空间编入freelist，然后向堆栈申请空间，连堆栈都没有空间时，再回freelist里找没用到且区块够大的，最后还不行才抛异常。
// 假设 size 已经适当上调至 8 的倍数
// 注意参数 nobjs 是 pass by reference
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 = 2 * total_bytes + ROUND_UP(heap_size >> 4);
// 以下试着让内存池中的残余零头还有利用价值(零头也应该是 8 的倍数)
if (bytes_left > 0) {
// 内存池内还有一些零头，先配给适当的free list
// 首先寻找适当的 free list
obj * __VOLATILE * my_free_list =
free_list + FREELIST_INDEX(bytes_left);
// 调整 free list，将内存池中的残余空间编入
((obj *)start_free) -> free_list_link = *my_free_list;
*my_free_list = (obj *)start_free;
}
// 配置 heap 空间，用来补充内存池
start_free = (char *)malloc(bytes_to_get);
if (0 == start_free) {
// heap空间不足，malloc()失败
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.
// 试着检视我们手上拥有的东西。这不会造成伤害。我们不打算尝试配置
// 较小的区块，因为那在多进程(multi-process)机器上容易导致灾难
// 以下搜寻适当的 free list
// 所谓适当是指"尚有未用区块，且区块够大"之 free list
for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
my_free_list = free_list + FREELIST_INDEX(i);
p = *my_free_list;
if (0 != p) { // free list内尚有未用区块
// 调整free list以释出未用区块
*my_free_list = p -> free_list_link;
start_free = (char *)p;
end_free = start_free + i;
// 递归调用自己，为了修正 nobjs
return(chunk_alloc(size, nobjs));
// 注意，任何残余零头终将被编入适当的free-list中备用
}
}
end_free = 0; // 如果出现意外，到处都没内存可用
// 调用第一级配置器，看看 out-of-memory 机制能否尽点力
start_free = (char *)malloc_alloc::allocate(bytes_to_get);
// 这会导致抛出异常(exception)，或内存不足的情况获得改善
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
// 递归调用自己，为了修正 nobjs
return(chunk_alloc(size, nobjs));
}
}