STL的空间配置器作为STL六大部件的重要组成部分,它总是隐藏在一切组件的背后.它主要负责动态空间的分配、释放等管理工作。整个STL的操作对象(所有的数值)都存放在容器之内,而容器一定需要配置空间以置放资料。而这就是空间配置器(allocator)的职责了.
一.SGI的空间配置器—std::alloc
STL allocator将内存分配/释放和对象构造/析构区分开来.内存配置操作由alloc::allocate()负责,内存释放由alloc::deallocate()负责;对象构造操作由::construct()负责,对象析构操作由::destroy()负责.
STL标准表格告诉我们,配置器定义于<memory>中，SGI<memory>内含两个文件:
#include <stl_alloc.h> //负责内存空间的配置与释放
#include <stl_construct.h> //负责对象内容的构造与析构
1.构造和析构基本工具:construct()和destroy()
#include <new.h> //欲使用placement new,需先包含此文件
template<class T1,class T2>
inline void construct(T1* p,const T2& value){
new (p) T1(value); //placement new;调用T1::T1(value);
}
//以下是destroy()第一版本,接受一个指针
template<class T>
inline void destroy(T* pointer){
pointer->~T();//调用dtor ~T()
}
template<class ForwardIterator>
inline void destroy(ForwardIterator first,ForwardIterator last){
__destroy(first,last,value_type(first));
}
//判断元素的数值型别(value type)是否有trivial destructor
template <class ForwardIterator,class T>
inline void destroy(ForwardIterator first,ForwardIterator last,T*){
typedef typename __type_trait<T>::has_trivial_destructor trivial_destructor;
__destroy_aux(first,last,trivial_destructor());
}
//如果元素的数值型别(value_type)有non-trivial destructor
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__false_type){
for(;first<last;first++) destroy(&*first);
}
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__true_type){}
inline void destroy(char*,char*){}
inline void destroy(wchar_t*,wchar_t*){}
2.空间的配置与释放
SGI是以malloc()和free()完成内存的配置与释放.考虑到小型区块所可能造成的内存破碎问题,SGI设计了双层级配置器。第一级配置器直接使用malloc()和free(),第二级配置器则视情况采用不同的策略:当配置区块超过128bytes时,视之为"足够大",便调用第一级配置器;当配置区块小于128bytes时,视之为"过小",为了降低额外负担，便采用memory pool整理方式,而不再求助于第一级配置器。
无论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(n!=0) Alloc::deallocate(p,n*sizeof(T));
}
static void deallocate(T* p){
Alloc::deallocate(p,sizeof(T));
}
};
其内部四个成员函数其实都是单纯的转调用,调用传递给配置器(可能是第一级也可能是第二级)的成员函数。SGI STL容器全部都是使用这个simple_alloc接口。
2.1 第一级配置器 __malloc_alloc_template剖析
//注意,无"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);
if(0==result) result=oom_malloc(n);
return result;
}
static void deallocate(void* p,size_t /*n*/){
free(p);
}
static void* reallocate(void* p,size_t old_sz,size_t new_sz){
void* result=realloc(p,new_sz);
if(0==result) oom_realloc(p,new_sz);
return result;
}
//以下仿真C++的set_new_handler()
static void (*set_malloc_handler(void (*f)()))(){
void (*old)()=__malloc_alloc_oom_handler;
__malloc_alloc_oom_handler=f;
return (old);
}
};
void (*__malloc_alloc_template<int>::__malloc_alloc_oom_handler)()=0;
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(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);
}
}
所谓c++ new handler机制是,当系统在内存配置需求无法被满足时，调用一个你指定的函数。也就是说,一旦::operator new无法完成任务,在丢出std::bad_alloc异常状态时,会先调用用户所指定的例程。
2.1 第二级配置器 __default_alloc_template剖析
SGI第二级配置器的做法是,如果区块足够大，超过128bytes时，就移交第一级配置器处理。当区块小于128bytes时,则以内存池(memory pool)管理：每次配置一大块内存，并维护对应之自由链表(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,128bytes的区块。
//free-lists的节点结构如下:
union obj{
union obj* free_list_link;
char client_data[1]; //The client sees this
};
第二级配置器的部分源码:
//free-lists的节点结构如下:
union obj{
union obj* free_list_link;
char client_data[1]; //The client sees this
};
enum {__ALIGN=8};//小型区块的上调边界
enum {__MAX_BYTES=128}; //小型区块的上限
enum {__NFREELISTS=__MAX_BYTES/__ALIGN}; //free-lists的个数
//以下是第二级配置器
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));
}
private:
union obj{ //free-lists的节点构造
union obj* free_list_link;
char client_data[1];
};
private:
//16个free-lists
static obj* volatile free_list[__NFREELISTS];
//以下函数根据区块大小,决定使用第n号free-lists.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"的区块
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;
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 memeber的定义与处置设定
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;
