STL学习_SGI二级空间配置器源码剖析

//二级空间配置器 __defaule_alloc_template

如果感觉光看代码难以理解，可以看看上篇博客介绍了二级空间配置器是怎样进行内存分配的。

enum{__ALIGN = 8};//最小申请的空间的大小

enum{__MAX_BYTES = 128};//能最大申请的空间的大小

//SGI第二配置器有16个free_lists

enum{__NFREELISTS = __MAX_BYTES / __ALIGN};//free_lists的个数

template<bool threads, int inst>

class __default_alloc_template

{

private:

//将客户申请的空间的大小上调至8的倍数

static size_t ROUND_UP(size_t bytes)

{

return (((bytes) + __ALIGN-1)&~(__ALIGN - 1));

}

private:

//16个free_lists的节点结构

//union能够实现一物两用的效果，1.obj可被视为一个指针，指向相同形式的另一 //个obj。2.obj可被视为一个指针，指向实际区块。

union obj{

union obj * free_list_link;//指向下一个节点的指针

char client_data[1];//记录此时节点数据

};

private:

static obj * volatile free_list[__NFREELISTS];//16个free_lists

//计算客户申请的空间的大小在哪个free_lists自由链表

static size_t FREELIST_INDEX(size_t bytes)

{

return (((bytes) + __ALIGN-1)/ __ALIGN - 1);

}

static char *start_free;//内存池起始位置

static char *end_free;//内存池结束位置

static size_t heap_size;//附加量

private:

static void *refill(size_t n);

static char *chunk_alloc(size_t size, int &nobjs);

public:

//空间配置函数

static void *allocate(size_t n)

{

obj * volatile * my_free_list;

obj * result;

//客户申请的空间大于128采用一级空间配置器进行空间的申请

if(n > (size_t __MAX_BYTES){

return (malloc_alloc::allocate(n));

}

//my_free_list这个二级指针指向客户申请空间大小适合的自由链表free_lists

my_free_list = free_list + FREELIST_INDEX(n);

//*my_free_list这个指针指向的是相对应的还没有给客户端分配的自由链表的起始

//位置

result = *my_free_list;

//没有找到可用的free_list，准备查看有没有可用的内存池来填充自由链表

if(0 == result){

void *r = refill(ROUND_UP(n));

return r;

}

//找到可用的自由链表，调整自由链表，让*my_free_list这个指针指向还没有给客 //户分配的自由链表的起始位置，也就是result的下一个节点的位置

*my_free_list = result->free_list_link;

return result;

}

//空间释放函数

static void deallocate(void *p, size_t n)

{

obj *q = (obj *)p;

obj * volatile * my_free_list;

if(n > (size_t)__MAX_BYTES){

malloc_allloc::deallocate(p, n);

return;

}

//释放已经给客户分配出去的p空间，也就是让p空间重新连接到自由链表上

//也就是先让p空间的指针指向下个节点也就是自由链表的起始位置，然后让自由链 //表的起始位置重新指向p空间

my_free_list = free_list + FREELISTS_INDEX(n);

q->free_list_link = *my_free_list;

*my_free_list = q;

}

};

//对__default_alloc_template这个类内的数据成员的定义与初值设定

template<bool threads, int inst>

char *__default_alloc_template<tnreads, 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>::head_size = 0;

//这里的数据成员free_list,由于free_list的类型obj * volatile是模板类型声明的

//并且这个函数名也是模板类型内声明的，所以这里对free_list的定义与处值的设定

//用两个模板类__default_alloc_template<threads, inst>

template<bool threads, int inst>

__default_alloc_template<thread, inst>::obj * volatile

__default_alloc_template<threads, inst>::free_list[__NFREELISTA]=

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};

//重新填充函数，当发现自由链表没有可用区块了，就调用这个函数从内存池中找到空间

//重新填充自由链表

template<bool threads, int inst>

void *__default_alloc_template<threads, inst>::refill(size_t n)

{

int nobjs = 20;

char *chunk = chunk_alloc(n, nobjs);

obj * volatile * my_free_list;

obj * result;

obj *current_obj, *next_obj;

int i;

//如果只获得一个区块，把这个区块给客户，free_list没有可用的节点了

if(1 == nobjs){

return (chunk);

}

my_free_list = free_list + NFREELIST_INDEX
;

result = (obj *)chunk;//这一块准备返回给客户

//chunk指向的是新free_list的起始位置，这里让*my_free_list指向新配置的

//空间，取自内存池

*my_free_list = next_obj = (obj *)(chunk + n);

//将free_list的各个节点用指针串起来，从第一个开始，因为第零个区块

//要返回给客户

for(i = 1; ; ++i){

current_obj = next_obj;

next_obj = (obj *)((char *)next_obj + n);

if(nobjs - 1 == i){

//最后一个节点的指针指向NULL

current_obj->free_list_link = 0;

break;

}else{

current_obj->free_list_link = next_obj;

}

}

return (result);

}

//从内存池中取出空间给free_list使用

template<bool threads, int inst>

char *__defaule_alloc_template<threads, inst>::chunk_alloc(size_t size, int &nobjs)

{

char *result;

size_t total_bytes = size * nobjs;//需要给free_list分配的空间大小

size_t bytes_left = end_free - start_free;//内存池剩余空间大小

//内存池的空间足够满足需求量

if(bytes_left >= total_bytes){

result = start_free;//result得到新的free_list的起始位置

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

//内存池还有一些零头，先分配给适当的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;

}

//内存池一点零头都没有了，就配置heap空间

start_free = (char *)malloc(bytes_to_get);

//如果系统的heap空间不足，malloc()失败

if(0 == start_free){

int i;

obj * volatile * my_free_list, *p;

//遍历搜索看还有没有用的free_list吗，

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){

*my_free_list = p->free_list_link;

start_free = (char *)p;

end_free = start_free + i;

return chunk_alloc(size,nobjs);

}

}

//到处没有内存可用则调用一级空间配置器

end_free = 0;

start_free = (char *)malloc_alloc::allocate(bytes_to_get);

}

heap_size += bytes_to_get;

end_free = start_free + bytes_to_get;

//递归调用自己为了修正nobjs

return chunk_alloc(size,nobjs);

}

}