STL空间配置器源码及其分析
#ifndef _STLALLOC_H_
#define _STLALLOC_H_
#include <typeinfo>
#include <new> //placement new
#include <iostream>
#include <malloc.h>
//#include <>
#include <stdlib.h>
using namespace std;
#if 0 //为何如此定义？
# include <new>
# define __THROW_BAD_ALLOC_
#elif !defined(__THROW_BAD_ALLOC_)
# define __THROW_BAD_ALLOC_ cerr<< "out of memory !" << endl; exit(1);
#endif
template <int inst> //非型别参数，完全没有派上用场
class __malloc_alloc_template
{
private:
//处理内存不足函数:
static void *oom_malloc(size_t);
static void *oom_remalloc(void *,size_t);
static void (*__malloc_oom_handler)(); //void(*)() malloc_oom_handler 想当于定义了一个函数指针
public:
static void *allocate(size_t n)
{
void *result = malloc(n);//一级配置器直接使用malloc(),如果无法满足需求,则调用oom_malloc()(循环)
if(0== result) result = oom_malloc(n);
return result;
}
//一级配置器直接使用free
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_remalloc(p, new_sz);
return result;
}
//此做法类似于C++的set_new_handler处理机制，f代表客户可以自己定义内存不足的处理函数set_new_handler是一个函数，函数的参数为函数指针(void(*)())，返回值为函数指针(void(*)())
static void(*set_malloc_handler(void(*f)()))()
{
void(*old)() = __malloc_oom_handler; //用一个函数指针先保存先前的内存处理函数
__malloc_oom_handler = f; //让私有成员的数据指针指向f(传进来的函数名)即client自己定义的内存不足函数处理函数
return (old);
}
//此函数的作用：(1)函数参数为f 如果客户没有定义自己的处理函数，即此时系统默认的f == NULL;返回值为空，则在循环体中就会调用系统的默认的处理机制(__THROW_BAD_ALLOC_)
(2)此函数返回注册的前异常处理函数，以便前面的处理函数值后还有可能返回;
};
template <int inst>
void(*__malloc_alloc_template<inst>:: __malloc_oom_handler)() = 0;//内存不足处理函数的初值设置为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_oom_handler;//指针指向一个中间桥梁的函数指针(类的私有成员)
if(0 == my_malloc_handler) //即如果客户没有设置自己的内存不足处理函数，系统就会调用自身的处理函数
{
__THROW_BAD_ALLOC_;
}
(*my_malloc_handler)();//如果有，则执行内存客户自定义的内存不足处理函数
result = oom_malloc(n);
if(result) return result;
}
}
template<int inst>
void*__malloc_alloc_template<inst>::oom_remalloc(void *p , size_t n)
{
void(*my_malloc_handler)();
void *result;
for(;;)
{
my_malloc_handler = __malloc_oom_handler;
if(0 == my_malloc_handler)
{
__THROW_BAD_ALLOC_;
}
(*my_malloc_handler)();
result = oom_remalloc(p,n);
if(result) return result;
}
}
//**************************************************************
//**************************************************************
enum{__ALIGN = 8};//小型区块的上调边界(align 匹配，结盟)
enum{__MAX_BYTES = 128};//最大字节
enum{__NFREELISTS = __MAX_BYTES/__ALIGN};//free lists 的个数
//二级配置器无模板参数，且其类型没有作用
template<int inst>
class __default_alloc_template
{
private:
//将字节上调至8的倍数(round up 集成整数)
static size_t ROUND_UP(size_t bytes)
{
return (((bytes) + __ALIGN - 1) & ~(__ALIGN - 1));
}
private:
//*****************************************************************************************
//free lists 的构造节点
union obj
{
union obj *free_list_link;
char client_data[1];
};
//此设计极为巧妙，对空间的怜惜可见一斑，对空间的分配极为吝啬，结构体占四个字节，当申请到空间时，将申请到的一部分[刚开始(19个)最为自由链表，一个返回,给调用的对象用,剩余的20个作为内存池]用这种形式的节点指针来维护链表，此结构形式极其象柔性数组，相当于用联合体的结构形式,把一个数组一部分链接起来,当第二次还有对象要用此节点时,此时,相当于链表的Popfront先用一个临时指针指向第一块内存，然后链表头指向它的下一块空间，最后将此临时指针返回，供调用对象使用.
//****************************************************************************
private:
//16个自由链表
static obj *volatile free_list[__NFREELISTS];
//volatile 是一个指令关键字，确保本条指令不会因为不会被编译器的优化而省略，且要求每次直接读值
//****************************************************************************
//根据区块的大小定位使用第几号自由链表
static size_t FREELIST_INDEX(size_t bytes)
{
return (((bytes) + __ALIGN -1)/__ALIGN - 1);
}
//****************************************************************************
static void *refill(size_t n);
//返回大小为n 的区块，并可能加入大小为n 的其他区块到freelist.refill()重新填充自由链表，比如刚开始16个自由链表都为0,加入定位了5 个字节，则根据ROUND_UP()则上调至8个字节,然后根据定位函数FREELIST_INDEX()定位到0，定位到0号链表，但刚开始,0 号链表为空，此时要refill(),填充规则刚开始一个自由链表都没有u，则调用chunk_alloc() 函数此时默认申请的大小2 * size(8) * 20 + 一个变化的数(可以不用考虑)。== 320 bytes 将一个返回，19个链成自由链表，剩下的20个作为内存池,
//****************************************************************************
static char *chunk_alloc(size_t size, int& nobjs);
//配置一块大空间，可容纳nobjs个大小为“size”的区块，如果配置nobjs 个大小的区块有所不便，nobjs的大小可能会降低,注意此处是引用,上面函数出来后，可能会改变nobjs的实际大小。
//****************************************************************************
static char *start_free;
static char *end_free;
static size_t heap_size;
//块的分配状态：用start_freeend_free 表示内存池的空间剩余状况，两者都是指针，相当于一个指向数组的没有存数据的起始，一个指向末尾。heap_size 主要是负责refill()函数中开辟空间时的变化的基数，注意此处的三个指针都声明为静态的原因？
public:
static void *allocate(size_t n); //
static void deallocate(void *p, size_t n); //空间的释放
static void *reallocate(void *p, size_t old_size,size_t new_sz);//
};
//****************************************************************************
//以下是类中的静态数据成员的定义与初始值设置
template<int inst>
char*__default_alloc_template<inst>::start_free = 0;
template<int inst>
char*__default_alloc_template<inst>::end_free = 0;
template<int inst>
size_t __default_alloc_template<inst>::heap_size= 0;
template<int inst>
typename__default_alloc_template<inst>::obj *volatile //整行都是返回值，因为obj是在一个不同参数的返回值，所以要声明其解析符
__default_alloc_template<inst>::free_list[__NFREELISTS]=
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //初始16个自由链表，其内部的指向都为空
//****************************************************************************
template<int inst>
void*__default_alloc_template<inst>::allocate(size_t n) //此处n必须必须大于0
{
obj * volatile *my_free_list;
//cout << "size_t : " << n << endl;
obj *result; //定义此指针的目的是指向申请到的，要返回的空间，并将其返回如果申请的字节大于128字节，此时就调用一级空间配置器
if(n > (size_t)__MAX_BYTES)
{
return(__malloc_alloc_template<0>::allocate(n));
}
//指针指向16个链表中合适的一个
my_free_list = free_list + FREELIST_INDEX(n);//此时的my_free_list是二级指针,定位的是下标.
result = *my_free_list;
if(0 == result)//如果定位到的链表为空,则填充申请空间，挂载链表,返回申请到的空间
{
void * r = refill(ROUND_UP(n));
return r;
}
*my_free_list = result->free_list_link;//如果定位的链表有空间，此时重新Popfront第一和节点
return (result); //并返回。
}
//allocate()是二级空间配置器__default_malloc_template 的标准接口,此函数的作用是:首先先判断区块的大小，如果大于128则调用一级配置器，否则就检查对应对自由链表，如果自由链表有可用的区块，则就直接拿来用，如果没有区块，则将区块的大小上调至8的倍数，然后调用refill()，准备为free list重新填充。
//****************************************************************************
template<int inst>
//注意此处的n 是为二级空间配置器的释放所设计的，当大于128 bytes时，直接调用一级空间配置器的释放函数free(p),将对象释放掉，如果小于128 字节，则就不是‘释放’，而是先传入指针所指的对象,并且传入要‘释放’的块的大小。这样，最后释放的时候，其实是将传入的指针所指的块挂载到自由链表中。
void__default_alloc_template<inst>::deallocate(void *p ,size_t n)
{
//cout << "3" << endl;
obj *q = (obj*)p;
obj* volatile *my_free_list;
//cout << n << endl;
//如果大于128字节，就交给一级配置器处理
if(n > (size_t)__MAX_BYTES)
{
//cout << "error" << endl;
__malloc_alloc_template<0>::deallocate(p,n);
}
//否则先定位
my_free_list = free_list + FREELIST_INDEX(n);
//将对象的空间pushfront到自由链表中，因为二级空间配置器，并不是释放空间，而是将空间挂载到自由链表上.(后话：当有对象申请时，此时先定为链表所在的下标，然后将链表上的一块空间用一个临时指针指向然后从自有链表释放，返回给对象临时指针所指的内容.）
q->free_list_link = *my_free_list;
*my_free_list = q;
}
//*****************************************************************************
template<int inst>
void*__default_alloc_template<inst>::refill(size_t n)
{
int nobjs = 20; //默认取的20个新的节点区块，给自由链表填充
//调用chunk_alloc(),尝试取的nobjs个区块作为free list 的新节点
//此处注意nobjs 是引用传值
char *chunk = chunk_alloc(n,nobjs);
//cout << "nobjs = " << nobjs << endl;
obj * volatile *my_free_list; //所有函数中的这种定义都是为了定位自由链表的下标
obj *result; //所有的函数中这种定义都是为了给对象返回result指针所指的空间
obj * current_obj, *next_obj; //为了把申请的空间链成自由链表
//如果只获得一个区块，这个区块就分配给调用者使用,啥也不用做，自由链表没有新的节点
if(1 == nobjs)
{
return chunk;
}
//否则,大于等于1个区块,此时要调整自由链表，纳入新的节点
//(1)先定位：
my_free_list = free_list + FREELIST_INDEX(n);
//(2)让result指向申请的块的第一块内存位置，将其准备返还给客户端
result = (obj *)chunk;
//(3)引导除去第一块外chunk的空间,链成自由链表(注意：此处的空间是取自内存池)
*my_free_list = next_obj = (obj *)(chunk + n);
for(int 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<int inst>
char *
__default_alloc_template<inst>::chunk_alloc(size_tsize, 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; //因为要将total_bytes 的空间分配出去(给自由链表填充),所以要调整内存池的剩余空间，end_free指针指向一个中间桥梁的函数指针永远不会变.
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 = 0;
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;
//此free list 尚有未用的区块
if(0 != p)
{
//调整free lists 释放该区块
*my_free_list =p->free_list_link;
start_free = (char *)p;
end_free = start_free + i;
return (chunk_alloc(size,nobjs));
//任何残余的零头，终将被编入适当的free lists 中，备用。
}
}
end_free = 0; //如果出现意外?(到处都没能找到内存可用)
//调用一级配置器，看看out_of_memory机制能否尽力
start_free = (char*)__malloc_alloc_template<0>::allocate(bytes_to_get);
//这会抛出异常(exception),或内存不足的情况
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
//递归调用自己，为了修改nobjs
return (chunk_alloc(size,nobjs));
}
}
typedef __default_alloc_template<0>alloc;
#endif
//****************************************************************************
//如果之前定义了__USE_MALLOC这个标签，则就把一级空间配置器定义为alloc
#ifdef __USE_MALLOC
typedef __malloc_alloc_template<0>malloc_alloc;
typedef malloc_alloc alloc;
//如果之前没有定义标签，那么就把二级空间配置器定义为alloc
#else
typedef __default_alloc_template<0>alloc;
#endif
//我之前没有定义__USE_MALLOC 这个标签，所以我把二级空间配置器，定义为alloc接口空间分配器，
//SGI 的空间配置器也是这样做的，开放的是二级空间配置器，然后在最外层包装了一个接口
//simple_alloc
//*****************************************************************************
//SGI 全部使用simple_alloc这个接口：其内部的函数都全部转调用一级二级配置器的函数
template<typename T, typename 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)
{
//测试：
//cout << "typeid(T).name()" << typeid(T).name()<< endl; //要查看模板的类型必须包含<typeinfo>
Alloc::deallocate(p,sizeof(T));
}
};
//****************************************************************************