理解了一下stl的空间配置器，发现一个比较好的学习方法，跟着代码自己也跟着写一遍，顺便加些注释，可以更加帮助自己理解。
如new,delete一般，分为两个步骤，1，配置空间，2，构造对象（1，析构对象，2，释放空间）
一。构造和析构的基本工具（construct，destroy）
1，construct(构造)
template<class T1,class T2>
inline void construct(T1 * p,const T2 & value){
new (p) T1(value); //在T1类型的p处用T2类型的value进行初始化
}
2,destroy（析构）
析构有两个版本
1，第一个版本，接收一个对象指针，调用其析构函数
//1template<class T>
inline void destroy(T * pointer){
pointer->~T();
}
2，第二个版本，接受一个迭代器区间
//2template<class ForwardIterator>
inline void destroy(ForwardIterator first,ForwardIterator last){
_destroy(first,last,value_type(first));
}
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());
}
//2.1
template<class ForwardIterator>
inline void _destroy_aux(ForwardIterator first,ForwardIterator last,__false_type){
for(;first < last ;first++)
destroy(&*first);
}
//2.2
template<class ForwardIterator>
inline void _destroy_aux(ForwardIterator first,ForwardIterator last,__true_type){
// trival type : do nothing
}
判断元素的数值型别是否是trivial destructor,不重要的类型，如果依次对每个做析构，很浪费效率，所以对于其不重要的类型，就用不着做什么了，do nothing
为了针对原生指针（char * ,wchar_t*两种）还有其特化版本，同样此也是不重要(trivial)的类型,不用做什么了
//3 特化
inline void destroy(char * ,char * ){}
//4 特化
inline void destroy(wchar_t * ,wchar_t *){}
二。空间的配置和释放
空间的配置和释放分为两级，第一级配置器仅是对于malloc和free的封装，并没有对效率的强化。因此有了第二级配置器，用了内存池的思想，提高了效率
1，第一级配置器
#if 0
#include <new>
#define __THROW_BAD_ALLOC throw bad_alloc
#elif !define(__THROW_BAD_ALLOC)
#include <iostream.h>
#define __THROW_BAD_ALLOC cerr<<"out of memory"<<endl;exit(1);
#endif
template<class inst>
class __malloc_alloc_template{
private:
//oom : out of memory ,these funcs to handle oom
static void * oom_malloc(size_t);
static void * oom_realloc(void * ,size_t);
static void (* __malloc_alloc_oom_handler)(); //在oom_xxx中调用处理malloc失败的情况
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){
free(p);
}
static void * reallocate(void * p,size_t ,size_t new_sz){
void * result = realloc(p,new_sz);
if( 0 == result)
result = oom_realloc(p,new_sz);
return result;
}
static void (* set_malloc_handler(void (*f)()))(){ //配置内存失败时会调用oom_XXX，其中调用f处理例程，此处可自己设置处理例程
void (*old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return old;
}
};
template<int inst>
void (*__malloc_alloc_template<inst>::__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(void * p ,size_t n){
void (* __my_realloc_handle)();
void * result;
for(;;){
__my_realloc_handle = __malloc_alloc_oom_handler;
if(0 == __my_realloc_handle){__THROW_BAD_ALLOC}
(*__my_realloc_handle)();
result = realloc(p,n);
if(result) return result;
}
}
typedef __malloc_alloc_template<0> malloc_allloc;
2,第二级配置器
主要过程：如果分配的区块够大，大于128bytes,就移交给第一级配置器处理，当区块小于128bytes时，以内存池管理，每次配置一大块内存，并维护对应之自由链表。下次再有相同大小的内存需求，直接从内存池中在取出即可。
二级配置器主动将所需内存调整至8的倍数。二级配置器内维护16个链表，各自管理8,16,24，。。。128大小的内存块。
1.对应的free list有可用的区块，直接拿过来用。
2.如果没有可用的区块，调用函数refill()为free list重新填充空间。
refill的工作：从内存池中取得内存，并依次分割成相应大小的块交给相应的链表维护，默认再取得20个区块，但实际情况还要在chunk_alloc中判断，可能不能完全取到20个区块。
在refill中调用chunk_alloc取得空间；
chunk_alloc中分为三种情况，
1.内存池中的内存容量完全够需求
2.内存池剩余空间不能完全满足需求，但足够供应一个以上的区块
3.连一个区块都不能获得
3.1.先将剩余的一些小空间交于其他的链表管理，省的浪费
3.2.从heap中分配空间补充内存量，补充内存池。
3.3.补充内存池之后，调整start_free,end_free,递归调用chunk_alloc来继续分配空间。
enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
template<bool threads,int inst>
class __default_alloc_template{
private:
static size_t ROUND_UP(size_t bytes){ //调整至8的倍数
return ((bytes + __ALIGN -1) & ~(__ALIGN-1));
}
private:
union obj{
union obj * free_list_link;
char client_data[1];
};
private:
static obj * volatile free_list[__NFREELISTS];
static size_t FREELIST_INDEX(size_t bytes){ //决定使用第几号free_list
return (bytes + __ALIGN -1)/__ALIGN - 1;
}
//返回一个大小为n的对象，并可能将此加入到free_list中
static void * refill(size_t n);
//配置空间，内存池
static char * chunk_alloc(size_t size,int & nobjs);
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 oldsz,size_t newsz);
};
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[__NFREELISTS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
//1 首先判断区块大小，若大于128调用第一级配置器
//2 小于128，从free_list中取(取之前是对调整后的区块进行取)，有则取，没有则将区块调整至8的倍数，调用refill填充空间
template<bool threads,int inst>
void * __default_alloc_template<threads,inst>::allocate(size_t n){
obj * volatile * my_free_list;
obj * result;
if( n > (size_t)__MAX_BYTES)
return (malloc_allloc::allocate(n));
my_free_list = free_list+FREELIST_INDEX(n);
result = * my_free_list;
if(result == 0){ //例：当内存池中96bytes的区块取光后，就refill重新建立
void * r = refill(ROUND_UP(n);
return r;
}
*my_free_list = result->free_list_link;
return result;
}
template<bool threads,int inst>
void __default_alloc_template<threads,inst>::deallocate(void * p,size_t n){
obj * q = (obj *) p;
obj * volatile * my_free_list;
if(n > __MAX_BYTES){
malloc_allloc::deallocate(p,n);
return;
}
my_free_list = free_list+FREELIST_INDEX(n);
q->free_list_link = *my_free_list;
*my_free_list = q;
}
template<bool threads,int inst>
void * __default_alloc_template<threads,inst>::refill(size_t n){
int nobjs = 20;
char * chunk = chunk_alloc(n,nobjs); //默认申请20个块
obj * volatile * my_free_list;
obj * result;
obj * current_obj,*nextobj;
int i;
if(1 == nobjs)
return chunk;
my_free_list = free_list + FREELIST_INDEX(n);
result = (obj * )chunk; //等待返回给需求者
* my_free_list = nextobj = (obj * )(chunk + n);
for(i = 1;;i++){
current_obj = nextobj;
nextobj = (obj * )((char *)nextobj+n); //不断进行分割
if(nobjs - 1 == i){ //分割结束
current_obj->free_link_list = 0;
break;
}
else
current_obj->free_link_list = nextobj;
}
return result;
}
template<bool threads,int inst>
char * __default_alloc_template::chunk_alloc(size_t size,int & nobjs){
char * result;
size_t total_bytes = size * nobjs;
size_t bytesleft = end_free - start_free;
//1内存池剩余空间完全满足需求量
if(bytesleft >= total_bytes){
result = start_free;
start_free+=total_bytes; //提供区块后，调整start_free
return result;
}
//2 不能完全满足需求量，但能供应一个及以上
else if(bytesleft >= size){
nobjs = bytesleft/size;
total_bytes = size*nobjs;
result = start_free;
start_free+=total_bytes;
return result;
}
//3 连一个也不能提供
else{
size_t bytes_to_get = 2*total_bytes + ROUND_UP(heap_size>>4);
if(bytesleft > 0){ //将剩余的一小点空间配给别的list
obj * volatile * my_free_list = free_list+FREELIST_INDEX(bytesleft);
((obj*)start_free)->free_list_link = *my_free_list;
*my_free_list = (obj *)start_free; //如果不是跟
}
start_free = (char *)malloc_allloc(bytes_to_get);
if(0 == start_free){
int i;
obj * volatile * my_free_list,*p;
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;
//递归调用自己，为了修正nobjs
return chunk_alloc(size,nobjs); //调整了start_free和end_free了，就再次进行分配，至少能分到一个区块了
}
}
end_free = 0;
start_free = (char * )malloc_allloc::allocate(bytes_to_get);
}
heap_size += bytes_to_get;
end_free = start_free+bytes_to_get;
return chunk_alloc(size,nobjs); //调整了start_free和end_free了，就再次进行分配，至少能分到一个区块了
}
}
时间： 2024-10-11 20:11:58