标签：
一、SGI 标准的空间配置器，std::allocator
SGI也定义了一个符合部分标准，名为allocator的配置器，但是它自己不使用，也不建议我们使用，主要原因是效率不佳。
它只是把C++的操作符::operator new和::operator delete做了一层简单的封装而已。
二、SGI 特殊的空间配置器，std::alloc
由于SGI 标准的空间配置器只是把C++的操作符::operator new和::operator delete做了一层简单的封装，没有考虑到任何效率上的强化。
所以 SGI 出现了一个特殊的空间配置器，供 STL标准模板库 使用。
通常，C++中用new操作符来分配内存都包括两个阶段：
（1）调用::operator new配置内存
（2）调用构造函数来构造对象内容
同理，delete操作也包括两个阶段：
（1）调用析构函数将对象析构
（2）调用::operator delete释放内存
为了精密分工，SGI STL allocator将两个阶段分开：
内存配置操作由alloc:allocate负责，内存释放由alloc:deallocate负责；对象构造操作由::contructor()负责，对象析构由::destroy()负责。
配置器定义在头文件<memory>中，它里面又包括两个文件：
#include <stl_alloc.h> // 负责内存空间的配置和器释放 #include <stl_construct.h> // 负责对象的构造和析构
STL 空间配置器：
STL 空间配置器解决的问题
1:内存碎片问题（外碎片）
内碎片，外碎片简介：
内碎片：操作系统在分配给申请者未被利用的部分。产生原因：内存对齐（效率高）；
外碎片：内存充足时但分配不出大块内存。产生原因：由于多次分配小块内存，将大块内存分割成小块；
2.频繁系统分配，释放小块内存，调用 malloc，delete 系统调用产生性能问题；
STL 空间配置器的实现机制：
双层级的配置器：
注：
当需要开辟的空间大于 128 bytes 时，视为“足够大”，调用一级配置器，直接调用 malloc，free；
当需要开辟的空间小于 128 bytes 时，视为“过小”，为了降低额外负担，调用二级空间配置器
一级空间配置器的剖析：
（set_new_handler 机制）
/***************************************************************************** 功能描述：一级空间配置器 类 /函数：template<int inst> class __MallocAllocTemplate; 简 介：直接调用 malloc/free，内存分配失败后调用句柄处理函数 *****************************************************************************/ typedef void(*ALLOC_OOM_FUN)(); //内存分配失败以后处理的句柄handler类型 template<int inst> class __MallocAllocTemplate { private: static ALLOC_OOM_FUN __sMallocAllocOomHandler; static void* OomMalloc(size_t n) //模仿 c++ 的 set_new_handler 机制 { ALLOC_OOM_FUN handler = __sMallocAllocOomHandler; void* result; for (;;) //一直循环，直到内存分配成功为止 { if (handler == 0) //检查是否设置处理的 handler { cout << "out of memory " << endl; exit(-1); } handler(); //调用客户自己的内存管理函数，释放内存 result = malloc(n); if (result) //分配成功 return result; } } static void* OomRealloc(void*p, size_t n) { ALLOC_OOM_FUN handler = __sMallocAllocOomHandler; void* result; for (;;) //一直循环，直到内存分配成功为止 { if (handler == 0) //检查是否设置处理的 handler { cout << "out of memory " << endl; exit(-1); } handler(); //调用客户自己的内存管理函数，释放内存 result = remalloc(n); if (result) //分配成功 return result; } } public: static void* Allocate(size_t n) //直接调用 malloc { void* result = malloc(n); return result == 0 ? OomMalloc(n) : result; } static void Deallocate(void* p) //直接 free { free(p); } static void *Reallocate(void*p,size_t new_sz) { void* result = realloc(p, new_sz); return result == 0 ? OomRealloc(p, new_sz) : result; } static void(*SetMallocHandler(void(*f)()))() //重新设置句柄处理函数 { ALLOC_OOM_FUN result = __sMallocAllocOomHandler; __sMallocAllocOomHandler = f; return result; } }; //初始化分配内存失败处理函数的句柄函数指针 template<int inst> ALLOC_OOM_FUN __MallocAllocTemplate<inst>::__sMallocAllocOomHandler = 0;
二级空间配置器：
template<bool threads, int inst> class __DefaultAllocTemplate { public: enum{ __ALIGN = 8 }; //排列基准值（也是排列间隔） enum{ __MAX_BYTES = 128 }; //最大值 enum{ __NFREELISTS = __MAX_BYTES / __ALIGN }; //排列链大小 static size_t ROUND_UP(size_t bytes) { return (bytes + __ALIGN - 1 & ~(__ALIGN - 1)); //内存与 8 对齐 } static size_t FREELIST_INDEX(size_t bytes) { return ((bytes + __ALIGN - 1) / __ALIGN - 1); //返回在自由链表中的下标 } union Obj { union Obj* _freeListLink; //指向下一个内存块的指针 char _clientData[1]; /* The client sees this.*/ }; static Obj* volatile _freeList[__NFREELISTS]; //自由链表 static char* _startFree; //内存池起始地址 static char* _endFree; //内存池结束地址 static size_t _heapSize; //内存池的容量 //从内存池中获取内存插入到自由链表中 static void* Refill(size_t n); //从内存池中分配内存 static char* ChunkAlloc(size_t size, int& nobjs); //用户调用申请内存函数 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); }; //初始化全局静态对象 //1.自由链表 template<bool threads, int inst> typename __DefaultAllocTemplate<threads, inst>::Obj* volatile __DefaultAllocTemplate<threads, inst>::_freeList[__DefaultAllocTemplate<threads, inst>::__NFREELISTS]; //2.内存池 template<bool threads, int inst> char* __DefaultAllocTemplate<threads, inst>::_startFree = 0; template<bool threads, int inst> char* __DefaultAllocTemplate<threads, inst>::_endFree = 0; template<bool threads, int inst> char* __DefaultAllocTemplate<threads, inst>::_heapSize = 0; //类中声明函数的定义 template<bool threads, int inst> void* __DefaultAllocTemplate<threads, inst>::Refill(size_t n) { int nobjs = 20; char* result = ChunkAlloc(n, nobjs); if (nobjs == 1) return result; Obj* cur = (Obj*)(result + n); size_t index = FREELIST_INDEX(n); _freeList[index] = cur; for (int i = 2; i < nobjs; ++i) //链表的头插 { cur->_freeListLink = i*n + result; cur = cur->_freeListLink; } cur->_freeListLink = NULL; return result; } template<bool threads, int inst> char* __DefaultAllocTemplate<threads, inst>::ChunkAlloc(size_t size, int&nobjs) { char* result; size_t bytesNeed = size*nobjs; size_t bytesHave = _endFree - _startFree; if (bytesHave >= bytesNeed) //内存池中所剩内存大于需要的内存 { result = _startFree; _startFree += bytesNeed; } else if (bytesHave >= size) //至少能满足一个 size 的分配 { result = _startFree; nobjs = bytesHave / size; _startFree += size*nobjs; } else //内存池中所剩空间不够一个 size { //清空内存池，准备往内存池中补充空间 Obj* cur = _startFree; size_t index = FREELIST_INDEX(bytesHave); cur->_freeListLink = _freelist[index]; _freelist[index] = cur; _startFree = NULL, _endFree = NULL; //重新向系统申请 bytesNeed*2 + _heapSize/16 size_t bytesToGet = bytesNeed * 2 + (_heapSize >> 4); _startFree = (char*)malloc(bytesToGet); if (_startFree == NULL) //向系统申请内存失败 { //先向自由链表上游中的大块内存链中寻找 for (int i = size; i <= __MAX_BYTES; i += __ALIGN) { Obj* head = _freeList[FREELIST_INDEX(size)]; if (head) { _startFree = (char*)head; _endFree = (char*)head + i; _freeList[FREELIST_INDEX(size)] = head->_freeListLink; return ChunkAlloc(size, nobjs); } } //链表中也没有了，实在无奈，调用一级配置器中的内存分配函数 _startFree = (char*)MallocAlloc::Allocate(byteToGet); } _heapSize += bytesToGet; _endFree = _startFree + bytesToGet; return ChunkAlloc(size, nobjs); //函数的复用 } return result; } template<bool threads, int inst> void* __DefaultAllocTemplate<threads, inst>::Allocate(size_t n) { void* result; if (n > __MAX_BYTES) result = MallocAlloc::Allocate(n); // //自由链表有，就直接取 //没有，就通过 Refill进行填充 // size_t index = FREELIST_INDEX(n); if (_freeList[index]) { result = _freeList[index]; _freelist[index] = ((Obj*)result)->_freeListLink; } else { result = Refill(ROUND_UP(n)); } return result; } template<bool threads, int inst> void __DefaultAllocTemplate<threads, inst>::Deallocate(void*p, size_t n) { if (n > __MAX_BYTES) MallocAlloc::Deallocate(p); //不大于 __MAX_BYTES ，将此空间插回自由链表 else { size_t index = FREELIST_INDEX(n); Obj* cur = (Obj*)p; cur->_freeListLink = _freeList[index]; _freeList[index] = cur; } } template<bool threads, int inst> void* __DefaultAllocTemplate<threads, inst>::Reallocate(void* p, size_t old_sz, size_t new_sz) { void* result; if (old_sz > (size_t)__MAX_BYTES && new_sz > (size_t)__MAX_BYTES) // return realloc(p, old_sz, new_sz); if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return p; result = Allocate(new_sz); size_t size = old_sz > new_sz ? old_sz : new_sz; meycpy(result, p, size); Deallocate(p, old_sz); return result; } typedef __DefaultAllocTemplate<false, 0> Alloc; #endif // __USE_MALLOC
STL 空间配置器的缺点：
1.有内碎片问题
2.内存池中的内存在程序结束前不能还给操作系统，被分割为小块的内存一直挂在自由链表下面，会使得内存的占用率过高。
学习ing，如果又发现哪有写的不对的地方请不吝赐教~~
标签：
原文地址：http://www.cnblogs.com/shihaochangeworld/p/5555693.html
