SGI STL 空间配置器（allocator）源码剖析
空间配置器的作用
我们知道，stl中的数据都是放到容器中的，容器需要存储空间，空间配置器就是负责容器存储空间的分配、回收等一系列内存操作。
STL标准规范中描述的allocator模版类的必要声明：
Constructors
// Constructors used to create allocator objects.
allocator(); // Default constructor
allocator(const allocator<Type>& _Right); // Copy constructor
template<class Other> // Template copy constructor
allocator(const allocator<Other>& _Right);
Typedefs
const_pointer // A type that provides a constant pointer to the type of object managed by the allocator.
const_reference // A type that provides a constant reference to type of object managed by the allocator.
difference_type // A signed integral type that can represent the difference between values of pointers to the type of object managed by the allocator.
pointer // A type that provides a pointer to the type of object managed by the allocator.
reference // A type that provides a reference to the type of object managed by the allocator.
size_type // An unsigned integral type that can represent the length of any sequence that an object of template class allocator can allocate.
value_type // A type that is managed by the allocator.
Member Functions
// Finds the address of an object whose value is specified.
pointer (reference _Val) const;
const_pointer (const_reference _Val) const;
// Allocates a block of memory large enough to store at least some specified number of elements.
pointer allocate(size_type _Count, const void* _Hint);
// Constructs a specific type of object at a specified address that is initialized with a specified value.
void construct(pointer _Ptr, const Type& _Val);
// Frees a specified number of objects from storage beginning at a specified position.
void deallocate(pointer _Ptr, size_type _Count);
// Calls an objects destructor without deallocating the memory where the object was stored.
void destroy(pointer _Ptr);
// Returns the number of elements of type Type that could be allocated by an object of class allocator before the free memory is used up.
size_type max_size( ) const;
// A structure that enables an allocator for objects of one type to allocate storage for objects of another type.
template<class _Other>
struct rebind {
typedef allocator<_Other> other;
};
Operators overload
template<class Other>
allocator<Type>& operator=(const allocator<Other>& _Right); // Assignment operator
SGI STL使用的空间配置器
SGI STL底层没有采用上述STL标准规范中的声明，它的配置器与众不同，其名称是alloc而非allocator，而且不接受任何参数。
SGI STL中的每种容器都已经指定其缺省的空间配置器alloc，我们在使用时很少需要自行指定配置器。
SGI STL空间配置器的设计哲学：
- 从堆中申请内存空间
- 考虑多线程状态
- 考虑内存不足时的应变措施
- 考虑过多“小型区块”可能造成的内存碎片问题
SGI STL空间配置器alloc的设计描述：
- 使用双层级配置器
- 第一级配置器(__malloc_alloc_template)直接使用malloc() 和 free()
- 第二级配置器(__default_alloc_template)视情况采用不同策略：当配置区块超过128byte时，视之为“足够大”，便调用第一级配置器；否则，视之为“过小”，为了提高效率（1.减少内存碎片；2.降低额外负担：直接使用malloc()申请内存时，系统会要多分配一些内存（内存头）用来管理所分配的内存空间），采用复杂的内存池（memory pool）技术（见下文详解），不再求助于第一级配置器
- SGI STL为了使配置器的接口能够符合STL的标准规范，提供了一个包装接口simple_alloc：
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 (0 != n) Alloc::deallocate(p, n * sizeof (T)); }
static void deallocate(T *p)
{ Alloc::deallocate(p, sizeof (T)); }
};
第一级配置器__malloc_alloc_template源码剖析
// 基于malloc()的配置器.通常比第二级配置器（__default_alloc_template）慢.
// 通常是线程安全的，并且对存储空间的使用更加高效.
#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
# ifdef __DECLARE_GLOBALS_HERE
void (* __malloc_alloc_oom_handler)() = 0; // 内存不足处理函数指针
// g++ 2.7.2 does not handle static template data members.
# else
extern void (* __malloc_alloc_oom_handler)();
# endif
#endif
template <int inst> // 没有模版型别参数，至于非型别参数inst没有用到
class __malloc_alloc_template {
private: // 用来处理内存不足的情况
static void *oom_malloc(size_t);
static void *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 = 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); // 直接使用realloc()
if (0 == result)
result = 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);
}
};
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
template <int inst>
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0; // 初值为0，需client设定
#endif
// 内存不足处理函数：malloc()申请内存失败
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; } // client未设定处理函数，直接抛出异常
(*my_malloc_handler)(); // 调用内存不足处理函数
result = malloc(n); // 再次尝试申请内存
if (result)
return(result); // 申请成功
}
}
// 内存不足处理函数：realloc()申请内存失败（与oom_malloc()类似）
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);
}
}
typedef __malloc_alloc_template<0> malloc_alloc; // inst直接被指定为0总结：
- 第一层配置器比较简单，直接调用相应的C函数
- 并实现出类似C++ new-handler机制，来处理内存不足的情况
// 多线程搞不懂，故去掉了线程相关代码，留待以后分析
template <bool threads, int inst>
class __default_alloc_template {
private:
// Really we should use static const int x = N
// instead of enum { x = N }, but few compilers accept the former.
// 唉，为了兼容性，考虑得太周到了
# ifndef __SUNPRO_CC
enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
# endif
// 内存对齐：将bytes上调至8的倍数
static size_t ROUND_UP(size_t bytes) {
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
__PRIVATE:
// free_list的节点构造
union obj {
union obj * free_list_link;
char client_data[1]; /* The client sees this. 这里没搞懂 */
};
private:
# ifdef __SUNPRO_CC
static obj * __VOLATILE free_list[];
// Specifying a size results in duplicate def for 4.1
# else
static obj * __VOLATILE free_list[__NFREELISTS]; // free_list数组，16个元素
# endif
// 根据bytes大小获取free_list的数组下标，从0开始
static size_t FREELIST_INDEX(size_t bytes) {
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}
// Returns an object of size n, and optionally adds to size n free list.
// 返回一个大小为n的对象，并可能加入大小为n的其它区块到free list中
static void *refill(size_t n);
// Allocates a chunk for nobjs of size "size". nobjs may be reduced
// if it is inconvenient to allocate the requested number.
// 配置一块空间，可容纳nobjs个大小为"size"的区块
// 如果不能配置nobjs个区块，nobjs的大小可能会减少(按引用传递的)
static char *chunk_alloc(size_t size, int &nobjs);
// 内存池状态
static char *start_free; // 内存池起始位置。只在chunk_alloc()中变化
static char *end_free; // 内存池结束位置。只在chunk_alloc()中变化
static size_t heap_size; // 从堆中申请的内存大小
public:
/* n must be > 0 */
static void * allocate(size_t n)
{
obj * __VOLATILE * my_free_list;
obj * __RESTRICT result;
if (n > (size_t) __MAX_BYTES) {
return(malloc_alloc::allocate(n)); // n大于128byte，直接调用第一级配置器
}
my_free_list = free_list + FREELIST_INDEX(n); // 从16个free_list中获取合适的一个
result = *my_free_list;
if (result == 0) {
void *r = refill(ROUND_UP(n)); // 没有可用的free_list，重新填充free_list
return r;
}
// 调整free_list：将已使用的内存区块从free_list中移除
*my_free_list = result -> free_list_link;
return (result);
};
/* p may not be 0 */
static void deallocate(void *p, size_t n)
{
obj *q = (obj *)p;
obj * __VOLATILE * my_free_list;
if (n > (size_t) __MAX_BYTES) {
malloc_alloc::deallocate(p, n); // n大于128byte，直接调用第一级配置器
return;
}
my_free_list = free_list + FREELIST_INDEX(n); // 从16个free_list中获取合适的一个
// 调整free_list: 将回收内存区块重新添加到free_list中
q -> free_list_link = *my_free_list;
*my_free_list = q;
}
static void * reallocate(void *p, size_t old_sz, size_t new_sz);
} ;
// static数据的定义与初值设定
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[
# ifdef __SUNPRO_CC
__NFREELISTS
# else
__default_alloc_template<threads, inst>::__NFREELISTS
# endif
] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
// The 16 zeros are necessary to make version 4.1 of the SunPro
// compiler happy. Otherwise it appears to allocate too little
// space for the array.
/* We allocate memory in large chunks in order to avoid fragmenting */
/* the malloc heap too much. */
/* We assume that size is properly aligned. */
/* We hold the allocation lock. */
// 为了避免堆中有过多的内存碎片，我们每次申请一大块内存空间
// 我们假定这个空间大小是内存对齐的
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; // 调整nobjs的值
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);
// 先把内存池剩余空间分配给合适的free_list
if (bytes_left > 0) {
obj * __VOLATILE * my_free_list =
free_list + FREELIST_INDEX(bytes_left);
((obj *)start_free) -> free_list_link = *my_free_list;
*my_free_list = (obj *)start_free;
}
start_free = (char *)malloc(bytes_to_get); // 从堆中申请内存，补充内存池
if (0 == start_free) { // 申请内存失败
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.
// 先尝试检查我们手上（free_list）拥有的东西。这不会造成伤害。
// 我们不打算检查比size更小的区块，因为那在多进程机器上容易导致灾难。
for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
my_free_list = free_list + FREELIST_INDEX(i);
p = *my_free_list;
if (0 != p) { // 存在未用区块
// 释放该未用区块
*my_free_list = p -> free_list_link;
start_free = (char *)p;
end_free = start_free + i;
return(chunk_alloc(size, nobjs)); // 递归调用自己，重新分配
// Any leftover piece will eventually make it to the
// right free list.
// 任何内存池剩余空间终将被编入适当的free list
}
}
// 55，山穷水尽了
end_free = 0;
// 调用第一级配置器，看看内存不足处理函数能不能起作用
start_free = (char *)malloc_alloc::allocate(bytes_to_get);
// This should either throw an
// exception or remedy the situation. Thus we assume it
// succeeded.
// 要么抛出异常，要么内存不足的情况得以改善，我们假定它成功了
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
return(chunk_alloc(size, nobjs)); // 递归调用自己，重新分配
}
}
/* Returns an object of size n, and optionally adds to size n free list.*/
/* We assume that n is properly aligned. */
/* We hold the allocation lock. */
// 返回一个大小为n的指针对象，并且有可能会为适当的free list增加节点
// 假定n已经适当调整到8的倍数了
template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
int nobjs = 20; // 缺省取得20个新节点
char * chunk = chunk_alloc(n, nobjs);
obj * __VOLATILE * my_free_list;
obj * result;
obj * current_obj, * next_obj;
int i;
if (1 == nobjs)
return(chunk); // 只获得一个节点，直接返回
// 否则准备调整free list，纳入新节点
my_free_list = free_list + FREELIST_INDEX(n); // 找到合适的free list
/* Build free list in chunk */
// 纳入新节点
result = (obj *)chunk;
*my_free_list = next_obj = (obj *)(chunk + n);
for (i = 1; ; i++) {
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);
}
template <bool threads, int inst>
void*
__default_alloc_template<threads, inst>::reallocate(void *p,
size_t old_sz,
size_t new_sz)
{
void * result;
size_t copy_sz;
if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) {
return(realloc(p, new_sz)); // 疑问：这里怎么不直接调用第一级配置器里面的realloc
}
if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p);
result = allocate(new_sz);
copy_sz = new_sz > old_sz? old_sz : new_sz;
memcpy(result, p, copy_sz);
deallocate(p, old_sz);
return(result);
}
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;
总结：
- 第二层配置器的核心就是内存池
- SGI STL的内存池通过free_list数组来管理，数组中包含16个free list，每个free list节点大小依次从8、16、24递增到128byte
- 分配内存时（假定分配大小在128byte内），首先根据分配大小找到合适的free list，如果该free list中没有可用的节点，则调用refill()函数从内存池中取空间给该free list用，然后返回第一个节点的内存空间，并调整该free list
- refill()缺省取20个新节点(区块)，通过调用chunk_alloc()，然后根据取得新节点的实际个数，调整相应的free list（大于1）
- chunk_alloc()内部实现最为复杂，根据内存池剩余空间大小与需求量的关系，分为三种情况，具体看代码，不再赘述