STL源码剖析之空间配置器Allocator
Object a = new Object（）；
delete a；
一般地，对象的构造过程包含两步：（1）调用运算符new进行空间分配；（2）调用构造函数构造对象内容。对象的析构函数也包含两步：（1）调用对象的析构函数；（2）调用运算符delete释放内存。
四、空间释放函数
五、重新填充空间
六、内存池
delete a；
一般地，对象的构造过程包含两步：（1）调用运算符new进行空间分配；（2）调用构造函数构造对象内容。对象的析构函数也包含两步：（1）调用对象的析构函数；（2）调用运算符delete释放内存。
STL中内存操作由alloc：allocate（）完成，它是对运算符new的封装，内存释放由alloc：deallocate（）完成，它是对运算符delete的封装，对象的构造函数由construct（）完成，对象的析构由destroy（）完成。
头文件：
#include<stl_alloc.h>//allocate（），deallocate（）
#include<stl_construct.h>//construct（）,destroy（）
一、构造与析构
源码如下：
//构造函数，接受两个参数
template <class _T1, class _T2>
inline void _Construct(_T1* __p, const _T2& __value) {
new ((void*) __p) _T1(__value); //调用_T1(value)
}
//构造函数，接受一个参数
template <class _T1>
inline void _Construct(_T1* __p) {
new ((void*) __p) _T1(); //调用_T1()
}
//Destroy第一个版本，传入一个指针
template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
__pointer->~_Tp();//调用~T（）
}
//如果用户不定义析构函数，系统默认调用自己的析构函数，则称trivial destructor，调用自定义的析构成为non-trivial destructor
//如果元素类型为non-trivial destructor,利用迭代器析构
template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
for ( ; __first != __last; ++__first)
destroy(&*__first);
}
//如果元素类型为trivial destructor,不做任何事
template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}
//判断元素类别是否有trivial destructor
template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
typedef typename __type_traits<_Tp>::has_trivial_destructor
_Trivial_destructor;
__destroy_aux(__first, __last, _Trivial_destructor());
}
//Destroy第二个版本，接受两个迭代器，根据元素类别，调用相应析构
template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
__destroy(__first, __last, __VALUE_TYPE(__first));
}
//destroy特化版，不做任何操作
inline void _Destroy(char*, char*) {}
inline void _Destroy(int*, int*) {}
inline void _Destroy(long*, long*) {}
inline void _Destroy(float*, float*) {}
inline void _Destroy(double*, double*) {}
#ifdef __STL_HAS_WCHAR_T
inline void _Destroy(wchar_t*, wchar_t*) {}
#endif /* __STL_HAS_WCHAR_T */
_Construct：主要是将value赋值给分配的指针空间。
_Destroy：（vision 1）参数为指针，直接调用析构函数。
（vision 2）参数为两个迭代器，根据对象的类型调用相应的析构函数，若为trivial destructor没有任何操作，若为non-trivial destructor则逐个析构掉[first,last)范围中的对象。主要是对效率的优化，防止范围过大，效率低下。
二、空间的申请和释放
第一配置器_malloc_alloc_template的剖析
template <int __inst>
class __malloc_alloc_template {
//oom : out of memory
private://定义处理内存不足的指针
static void* _S_oom_malloc(size_t);
static void* _S_oom_realloc(void*, size_t);
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
static void (* __malloc_alloc_oom_handler)();
#endif
public:
static void* allocate(size_t __n)
{
void* __result = malloc(__n);//直接调用malloc
if (0 == __result) __result = _S_oom_malloc(__n);//失败则交给处理函数
return __result;
}
static void deallocate(void* __p, size_t /* __n */)
{
free(__p);//直接调用free
}
static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
{
void* __result = realloc(__p, __new_sz);//直接调用relloc
if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);//失败交给处理函数
return __result;
}
//自定义自己的处理函数
static void (* __set_malloc_handler(void (*__f)()))()
{
void (* __old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = __f;
return(__old);
}
};
// malloc_alloc out-of-memory handling
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
template <int __inst>
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
#endif
template <int __inst>
void*
__malloc_alloc_template<__inst>::_S_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>::_S_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);
}
}
typedef __malloc_alloc_template<0> malloc_alloc;
template<class _Tp, class _Alloc>
class simple_alloc {
public:
static _Tp* allocate(size_t __n)
{ return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
static _Tp* allocate(void)
{ return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
static void deallocate(_Tp* __p, size_t __n)
{ if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
static void deallocate(_Tp* __p)
{ _Alloc::deallocate(__p, sizeof (_Tp)); }
};
第一级配置器利用malloc，free，realloc来进行内存配置，释放，再配置。如果malloc与relloc不成功则调用oom_malloc和oom_realloc进行内存处理。
第二级配置器_defualt_alloc_template的剖析#if defined(__SUNPRO_CC) || defined(__GNUC__)
// breaks if we make these template class members:
enum {_ALIGN = 8};//小区块上调边界
enum {_MAX_BYTES = 128};//小区块上界
enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN
#endif
template <bool threads, int inst>
class __default_alloc_template {
private:
static size_t
_S_round_up(size_t __bytes) //将__bytes上调8的倍数
{ return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }
__PRIVATE:
union _Obj {//free-list结点构造
union _Obj* _M_free_list_link;
char _M_client_data[1]; /* The client sees this. */
};
private:
# if defined(__SUNPRO_CC) || defined(__GNUC__) || defined(__HP_aCC)
static _Obj* __STL_VOLATILE _S_free_list[];
// Specifying a size results in duplicate def for 4.1
# else
static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS];
# endif
static size_t _S_freelist_index(size_t __bytes) {//根据区块大小决定使用第n号的free-list
return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
}
// 返回一个大小为n的对象，可能加入大小为n的其他区块到free-list
static void* _S_refill(size_t __n);
// 配置一大块内存，可容纳nobjs个大小为size的区块
// 如果配置nobjs个区块有所不便则nobjs会降低
static char* _S_chunk_alloc(size_t __size, int& __nobjs);
// 区块分配状态
static char* _S_start_free;//内存起始位置
static char* _S_end_free;//内存结束位置
static size_t _S_heap_size;//堆大小
第二级配置器处理避免了小额区块造成的内存碎片，处理方式为：如果内存过大（超过128字节）交个第一级配置器处理，小于128字节时交由内存池来处理。每次分配一大块内存时都要交由free-list，如果有大小相同的内存需求时就在free-list中申请，有小额内存释放是增加到free-list中。
三、空间配置函数
第二级配置器拥有一个接口allocate（），主要作用是判断内存是否超过128字节，超过交由第一级配置器处理，否则从free-list中提出。如果free-list没有可用内存块则调整 内存边界为8倍数，调用refill（）填充空间。
/* __n must be > 0 */
static void* allocate(size_t __n)
{
void* __ret = 0;
if (__n > (size_t) _MAX_BYTES) {//判断__n是否大于128字节
__ret = malloc_alloc::allocate(__n);//大于交由第一级配置器处理
}
else {//寻找free-list最适当的一个
_Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);
_Obj* __RESTRICT __result = *__my_free_list;
if (__result == 0)//没有找到free-list，调用refill填充
__ret = _S_refill(_S_round_up(__n));
else {
*__my_free_list = __result -> _M_free_list_link;//调整free-list
__ret = __result;
}
}
return __ret;
};
四、空间释放函数
第二级配置器的接口函数。注意作用是回收区块，大于128字节调用第一级配置器，小于128字节用free-list回收。
/* __p may not be 0 */
static void deallocate(void* __p, size_t __n)
{
if (__n > (size_t) _MAX_BYTES)
malloc_alloc::deallocate(__p, __n);//大于128字节调用第一级配置器
else {
_Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);//找出对于位置
_Obj* __q = (_Obj*)__p;
__q -> _M_free_list_link = *__my_free_list;//回收区块
*__my_free_list = __q;
}
}
五、重新填充空间
template <bool __threads, int __inst>
void*
__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
{
int __nobjs = 20;
char* __chunk = _S_chunk_alloc(__n, __nobjs);//获取nobjs个区块作为free-lisr的新节点
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __result;
_Obj* __current_obj;
_Obj* __next_obj;
int __i;
if (1 == __nobjs) return(__chunk);//如果只获取了一个区块直接返回给调用者
__my_free_list = _S_free_list + _S_freelist_index(__n);//否则加入到free-list中
/*在chunk空间内建立free-list */
__result = (_Obj*)__chunk;
*__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
for (__i = 1; ; __i++) {//将free-list各个节点串接起来
__current_obj = __next_obj;
__next_obj = (_Obj*)((char*)__next_obj + __n);
if (__nobjs - 1 == __i) {
__current_obj -> _M_free_list_link = 0;
break;
} else {
__current_obj -> _M_free_list_link = __next_obj;
}
}
return(__result);
}
六、内存池
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 =
_S_free_list + _S_freelist_index(__bytes_left);
//调整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);//配置堆空间，用来补充内存池
if (0 == _S_start_free) {//申请失败
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
// 搜索free-list中可用区块
for (__i = __size;
__i <= (size_t) _MAX_BYTES;
__i += (size_t) _ALIGN) {
__my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list;
if (0 != __p) {//有可用区块
*__my_free_list = __p -> _M_free_list_link;
_S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
return(_S_chunk_alloc(__size, __nobjs));
// 任何残余区块都已编入到free-liat中
}
}
_S_end_free = 0; // 防止出现意外（内存不足）
_S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);//调用第一级配置器
}
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
return(_S_chunk_alloc(__size, __nobjs));
}
}