空间配置器的标准接口：
1. allocator::value_type
2.
3. allocator::pointer
4.
5. allocator::const_pointer
6.
7. allocator::reference
8.
9. allocator::const_refrence
10.
11. allocator::size_type
12.
13. allocator::difference_type
14.
15. pointer allocator::allocate(size_type n,const void*=0)
16.
17. //配置空间，足以存储n个T对象，第二个参数是个提示。实现上可能会力利用它来增进区域性，或完全忽略之
18.
19. void allocator::deallocate(pointer p,size_type n)
20.
21. //归还先前配置的空间
22.
23. size_type allocator::max_size()const
24.
25. //返回可成功配置的最大量
26.
27. void allocator::construct(pointer p,const
28.
29. //等同于new((void*)p)T(x)
30.
31. void
32.
33. //等同于p->~T()
SGI空间配置器
SGI的配置器与众不同，其名称为alloc而非allocator，而且不接受任何参数
标准的写法：
vector<int ,std::allocator> iv;
SGI的写法：
vector<int ,std::alloc> iv;
SGI STL的每一个容器都已经指定其缺省的空间配置器为alloc。
SGI特殊的空间配置器，std::alloc
一般而言，我们习惯使用的C++内存配置操作和释放操作为：
class Foo{…};
Foo* pf=new Foo; //配置空间，构造对象
delete pf; //析构对象，释放内存
其中，new算式包含两个阶段：（1）调用::operator new 配置内存；（2）调用Foo::Foo()构造对象。delete算式类似。
为了精密分工，STL allocator将两个阶段操作区分开来。内存的配置操作由alloc::allocate()负责，内存释放操作由alloc::deallocate()负责；对象的构造操作由::construct()负责，对象的析构操作由::destroy()负责
配置器定于与<memory>中，SGI<memory>内包含以下两个文件：
#include <stl_alloc.h> //负责内存空间的配置与释放
#include <stl_construct.h> //负责对象内容的构造与析构
图1.SGI STL配置器相关函数的文件分布
构造与析构工具construct()和destroy()
两函数均被设计为全局函数。
其中，construct()接收一个指针p和一个初值value，该函数的用途是将初值设定到指针所指的空间上，C++中placement new算子可完成此任务
destroy()有两个版本，第一个版本接受一个指针，将该指针所指对象析构。第二个版本，接受一个范围。
空间的配置与释放std::alloc
考虑到小型区域块可能造成的内存破碎问题，SGI STL 设计了双层级配置器。第一级配置器直接使用malloc() 和free()，第二级配置器则视情况采用不同的策略：当配置区域大小超过128 bytes时，视之为”足够大”，便调用第一级配置器；当配置区域小于128 bytes时，视之为”过小”，为了降低额外的负担，便采用复杂的memory pool整理方式，而不再求助于第一级配置器。
其中__malloc_alloc_template就是第一级 配 置 器 ， __default_alloc_template 就是第二级配置器。再次注意，alloc并不接受任何template型别参数。
无论alloc被定义为第一级或第二级配置器，SGI 还为它再包装一个接口:simple_alloc。SGI STL 容器全部使用这个simple_alloc接口。
第二级配置器__default_alloc_template剖析
第二级配置器多了一些机制，避免太多的小额区块造成的内存碎片。小额区块带来的其实不仅仅是内存碎片，配置时的系统开销也是一大问题，系统开销永远无法避免，毕竟系统要靠这些空间管理内存，如下图所示，区块愈小，系统开销占据的比例就愈大，愈显得浪费。
次层配置(sub-allocation)：每次配置一大块内存，并维护对应之自由链表(free-list)，下次若再有相同大小的内存需求，就直接从free-list中拔出。如果客户端释还小额区块，就有配置器回收到free-list中。为了方便管理，SGI第二级配置器会主动将任何小额区块的内存需求量上调为8的倍数，并维护16个free-list，各自管理大小分别为，8, 16, 24, 32, 40, 48, 56, 64, 72,
80, 88, 96, 104, 112, 120, 128 bytes 的小额区块。。free-lists 的节点结构如㆘：
1. union obj {
2.
3. union obj * free_list_link;
4.
5. char client_data[1]; //The client sees this.
6.
7. };
注意，上述 obj 所用的是 union，由于 union 之故，从其第一字段观之，obj可被视为一个指标，指向相同形式的另㆒个 obj。从其第㆓字段观之，obj 可被视为一个指标，指向实际区块。一物二用的结果是，不会为了维护串行所必须的指针而造成内存的另㆒种浪费。
代码剖析 1、类模板声明：
enum {__ALIGN = 8}; // 最小区块大小
enum {__MAX_BYTES = 128}; // 最大区块大小
enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; // free-lists 个数
//第二级配置器。
u template <bool threads, int inst>
class __default_alloc_template {
private:
// ROUND_UP() 将bytes上调至8 的倍数。
Ø static size_t ROUND_UP(size_t bytes) {
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
/*~(__ALIGN - 1)得到后三位为0的位串
*(bytes) + __ALIGN-1利用四舍五入的相同的实现方法，实现”进8”,然后与使用&操作舍去不足*8的部分，例如：
*(18+7)& ~(__ALIGN - 1)---->(10010+00111)&(111000)-----> (1 1001)&(11000) ----->11000=24
*/
private:
Ø union obj { // free-lists 的节点构造
union obj * free_list_link;
char client_data[1]; /* The client sees this. */
};
private:
//注意：free_list类型为obj类型的指针，所以其将指向每一个free-list的首地址
Ø static obj * volatile free_list[__NFREELISTS]; // 16 个free-lists
//根据区块大小，决定使用第n 号free-list。n 从1 起算。
Ø static size_t FREELIST_INDEX(size_t bytes) {
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}
// 传回一个大小为n 的对象，并可能加入大小为n 的其它区块到free list.
Ø static void *refill(size_t n);
// 配置一大块空间，可容纳nobjs 个大小为"size" 的区块。
// 如果配置nobjs 个区块有所不便，nobjs 可能会降低。
Ø static char *chunk_alloc(size_t size, int &nobjs);
// Chunk allocation state.
Ø static char *start_free; // 记忆池起始位置。只在chunk_alloc()中变化
Ø static char *end_free; // 记忆池结束位置。只在chunk_alloc()中变化
Ø static size_t heap_size; //已分配堆的总大小
public:
Ø static void * allocate(size_t n) { /* 详述于后*/ }
Ø static void deallocate(void *p, size_t n) { /* 详述于后*/ }
Ø static void * reallocate(void *p, size_t old_sz, size_t new_sz);
};
// static data member 的定义与初值设定
template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::start_free = 0;
template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::end_free = 0;
template <bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;
template <bool threads, int inst>
__default_alloc_template<threads, inst>::obj * volatile
__default_alloc_template<threads, inst>::free_list[__NFREELISTS] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
代码剖析 2、空间配置函数allocate()的实现
// n must be > 0
static void * allocate(size_t n)
{
obj * volatile * my_free_list;
obj * result;
// 大于128 就呼叫第一级配置器
if (n > (size_t) __MAX_BYTES)
return(malloc_alloc::allocate(n));
}
// 寻找16 个free lists 中区块大小为8n的链表
my_free_list = free_list + FREELIST_INDEX(n);//从free lists中获取链表首位置
result = *my_free_list; //取得该链表第一区块的首地址，
if (result == 0) {// 没找到可用的free list，准备重新填充free list
void *r = refill(ROUND_UP(n));
return r;
}
// 调整free list，将该free list的首地址更新为第二区块的首地址
*my_free_list = result -> free_list_link;
return (result);
};
代码剖析 2、空间释放函数deallocate()的实现
//备注：区块可以直接释还的主要原因是：空间配置释放与对象构造析构的分离，在调用此函数之前对象已经析构，所以可以释还
// p 指向要释还的区块的指针
static void deallocate(void *p, size_t n)
{
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);
// 调整free list，回收区块
q -> free_list_link = *my_free_list; //将旧的第一区块的地址赋值给释还的区块
*my_free_list = q; //释还区块将首地址赋值给相应的free-list并成为该free-list新第一区块
}
代码剖析 3、重新填充函数free lists
allocate()中如果发现所需区块大小的free-list中没有区块可用，则会调用refill()为该free-list重新填充空间。所需内存来自memory pool(由chunk_alloc() 完成)。
// 传回㆒个大小为n 的对象，并且有时候会为适当的free list 增加节点.
// 假设n 已经适当上调至8 的倍数。
//注意：n为每个对象的大小
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，函数调用后nobjs将传回实际取得的区块个数。
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);/*my_free_list将获取到区块大小为8n的free-list首地址*/
//在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);
}
代码剖析 4、内存池(memory pool)的实现
从内存池中取空间给 free list 使用，是 chunk_alloc() 的工作：
// 假设 size 已经适当上调至 8 的倍数。
// 注意参数 nobjs 是 pass by reference。
template <bool threads, int inst>
char*
__default_alloc_template<threads, inst>::
chunk_alloc(size_t size, int& nobjs)
{
Ø //1.在剩余空间中寻找适当的内存
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);
Ø //2.找不到合适的内存，处理内存池中的残余零头
// 试着让内存池中的残余零头还有利用价值。
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;
}
Ø //3.从heap中寻找空间补充内存池
// 配置heap 空间，用来补充内存池。
start_free = (char *)malloc(bytes_to_get);
if (0 == start_free) {
// heap 空间不足，malloc() 失败。
int i;
obj * volatile * my_free_list, *p;
Ø /* 4.配置heap空间失败，尝试从区块比要求的请求区块大的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;
Ø //5.找到内存块，调整start_free和end_free指针，递归处理找到的内存补充free-list
start_free = (char *)p;
end_free = start_free + i;
// 递归呼叫自己，为了修正nobjs。
return(chunk_alloc(size, nobjs));
// 注意，因为2.任何残余零头终将被编入适当的free-list中备用。
}
}
Ø // 6.如果出现意外（山穷水尽，到处都没内存可用了）
end_free = 0;
// 呼叫第㆒级配置器，看看out-of-memory 机制能否尽点力
start_free = (char *)malloc_alloc::allocate(bytes_to_get);
// 这会导致掷出异常（exception），或内存不足的情况获得改善。
}
Ø /*对应3.配置heap成功，修改heap_size大小，end_free指针，递归调用处理内存，补充free-list*/
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
// 递归呼叫自己，为了修正nobjs。
return(chunk_alloc(size, nobjs));
}
}
Andy编辑于2011-03-05 15:23:41
