SGI_STL_空间配置器

一般而言，我们习惯C++内存申请操作和释放操作如下：

class Foo{};

Foo * pf = new Foo; //1.申请空间2.调用构造函数

delete pf; //1.析构函数2.释放空间

但是为了精确分工，STL Allocator这两个阶段分开来。PS：以下代码不讨论多线程情况

内存申请：alloc::allocate()负责。

内存释放：alloc::deallocate()负责。

对象构造：全局 ::construct()负责。

对象析构：全局 ::destroy()负责。



1.<stl_construct.h> 对象构造和析构关键代码

【::construct()和::destroy()被设计为全局函数。::destory()有2个版本，第一个版本接受一个指针，调用该析构函数即可，第二个版本考虑到大范围的对象析构可能无关痛痒(trivial destructor),使用value_type()获得迭代器所指对象的型别，再利用__tyep_traits<T>判断trivial？不做：调用第一个版本】

#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(value);
}

// 以下是destroy() 第一版本，接受一个对象指针。
template <class T>
inline void destroy(T* pointer)
{
pointer->~T();    // 析构
}

// 以下是destroy() 第二版本，接受两个迭代器，此函数找出元素得数值类型
// 利用__type_traits<> 采用适当措施
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_traits<T>::has_trivial_destructor trivial_destructor;
__destroy_aux(first, last, trivial_destructor());
}

// 如果对象的型別（value type）有non-trivial(要紧的) destructor
//循环调用destroy一个版本
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type)
{
for ( ; first < last; ++first)
destroy(&*first);
}

// 如果对象的型別（value type）有trivial(无关紧要的) destructor
template <class ForwardIterator>
inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type)
{
//不处理
}

// 以下是destroy() 第二版本針對迭代器為char* 和wchar_t* 的特化版
inline void destroy(char*, char*) {}
inline void destroy(wchar_t*, wchar_t*) {}

2.<stl_alloc.h> 空间的申请和释放

【C++内存申请基本操作：::operator new(),内存释放基本操作：::operator delete()。SGI用malloc和free这2个C函数代替完成内存的申请和释放。考虑到内存碎片问题，SGI设计了两级配置器，第一级直接使用malloc和free，包括了内存不足处理机制，需要调用者自己提供。第二级判断配置区超过128字节，调用第一级配置器。小于128字节，采用内存池管理】





2.1 配置器接口

//简单的转调用，可能第一级或者第二级配置器

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));
}
};

2.2 vector简单使用例子

template<class T, class Alloc>
class vector
{
protected:
typedef simple_alloc<value_type,Alloc> data_allocator;

void deallocate()
{
if(...)
data_allocator::deallocate(start,end_of_storage - start);
}
};

2.3 第一级配置器

【SGI第一级配置器的allocate和realloc都是在调用C函数malloc和realloc不成功后，改调用oom_malloc和oom_realloc，后两者都有内循环，不断调用你指定的内存不足处理函数】

// Malloc-based allocator.  Typically slower than default alloc below.
// Typically thread-safe and more storage efficient.
#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

//inst没排上用场
template <int 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)
{
//第一级直接用malloc;
void *result = malloc(n);
//malloc内存不足补救函数
if (0 == result)
result = oom_malloc(n);
return result;
}

static void deallocate(void *p, size_t /* n */)
{
//直接free
free(p);
}

static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz)
{
//直接使用realloc 下面为补救函数
void * result = realloc(p, new_sz);
if (0 == result)
result = oom_realloc(p, new_sz);
return result;
}

static void (* set_malloc_handler(void (*f)()))()
{
//指定你的out-of-memory处理函数
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>
//你的out-of-memory处理函数初始为
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;
#endif

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(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);
}
}

2.4 第二级配置器

【每次先申请一大块内存作为内存池，并且维护16条链表，分别从8-16-24-32……-128字节(配置器会主动将当前内存申请提升到8的倍数)，链表负责配置出去(配置出去时链表不再指向)和回收回来(回收回来时链表重新指向)，当链表空间不足时向内存池申请。】

2.4.1 链表节点结构

//利用union的性质使得链表既是指针又是实际区块
union obj
{
union obj * free_list_link;
char client_data[1];       //柔性数组
};

2.4.2 配置器类内代码

enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
#endif

template <bool threads, int inst>
class __default_alloc_template {

private:
//扩展到__ALIGN的倍数也即是的倍数
static size_t ROUND_UP(size_t bytes)
{
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
private:
union obj
{
union obj * free_list_link;
char client_data[1];    /* The client sees this.        */
};
private:
//16条链表
static obj *  free_list[__NFREELISTS];

//根据申请的大小快速找到所属链表
static  size_t FREELIST_INDEX(size_t bytes)
{
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}

//向内存池申请n大小的区间n为的倍数
static void *refill(size_t n);

//内存池成处理申请函数一般为一次性配置nobjs个size大小的块nobjs默认为
//不足时,nobjs返回不定数目
static char *chunk_alloc(size_t size, int &nobjs);

//内存池起始位置只在chunk_alloc变化
static char *start_free;
//内存池结束位置只在chunk_alloc变化
static char *end_free;
//内存池heap_size
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);

} ;

2.4.3 allocate()实现

/* 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));
}

//找到链表中的所属链表
my_free_list = free_list + FREELIST_INDEX(n);

result = *my_free_list;
//链表没有可用的块调用refill申请
if (result == 0)
{
void *r = refill(ROUND_UP(n));
return r;
}
//调整链表不再指向这块被使用的块
*my_free_list = result -> free_list_link;
return (result);
};

2.4.4 deallocate()实现

/* 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);
return;
}
//找到所属链表
my_free_list = free_list + FREELIST_INDEX(n);

//调整链表回收区块
q -> free_list_link = *my_free_list;
//链表重新指向回收块
*my_free_list = q;

}

2.4.5 refill()实现

void* __default_alloc_template<threads, inst>::refill(size_t n)
{
//默认申请块数
int nobjs = 20;
//nobjs为传引用
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);

//不止一块找到所属链表
my_free_list = free_list + FREELIST_INDEX(n);

//对新的区块建链表
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);   //返回给申请者
}

2.4.6 内存池chunk_alloc()实现

_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
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);

//余额大于把这些零头凑到链表里去
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;
}
//申请heap空间，补充内存池
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.

//以下搜索适当的链表
//适当是指"尚有未用区块的链表"
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.
}
}
//没办法没内存用了
end_free = 0;    // In case of exception.
//调用第一级配置器看看out-of-memory机制能否出点力
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+=
heap_size += bytes_to_get;
//结束位置重新界定
end_free = start_free + bytes_to_get;
return(chunk_alloc(size, nobjs));
}
}