什么是空间配置器
- 空间配置器，顾名思义就是为各个容器高效的管理空间(空间的申请与回收)的，在默默地工作。虽然在常规使用STL时，可能用不到它，但站在学习研究的角度，学习它的实现原理对我们有很大的帮助。
为什么需要空间配置器
-
我模拟实现vector、list、map、unordered_map等容器时，所有需要空间的地方都是通过new申请的，虽然代码可以正常运行，但是有以下不足之处：
-
空间申请与释放需要用户自己管理，容易造成内存泄漏
频繁向系统申请小块内存块，容易造成内存碎片
频繁向系统申请小块内存，影响程序运行效率
直接使用malloc与new进行申请，每块空间前有额外空间浪费
申请空间失败怎么应对
代码结构比较混乱，代码复用率不高
未考虑线程安全问题 -
因此需要设计一块高效的内存管理机制
SGI-STL空间配置器实现原理
- 以上提到的几点不足之处，最主要还是：频繁向系统申请小块内存造成的。那什么才算是小块内存？SGI-STL 以128作为小块内存与大块内存的分界线，将空间配置器其分为两级结构，一级空间配置器处理大块内存，二级空间配置器处理小块内存。
一级空间配置器
- 下面我来一步一步的根据我的理解写的源码。
#pragma once
#include<cstdlib> //为了malloc、free
#include<iostream>
#define __THROW_BAD_ALLOC std::cerr<<"out of memory"<< std::endl; exit(1)
class OneSpce
{
private:
//以下是函数指针，所代表的函数将用来处理内存不足的情况
//oom：out of memory
static void *Oom_Malloc(size_t);
static void *Oom_Realloc(void *, size_t);
static void(*__malloc_alloc_oom_handler)();
public:
// 对malloc的封装
static void * Allocate(size_t n)
{
// 申请空间成功，直接返回，失败交由oom_malloc处理
void *result = malloc(n); //一级空间配置器直接使用 malloc()
//无法满足需求时，改用 oom_malloc()
if (0 == result)
result = Oom_Malloc(n);
return result;
}
// 对free的封装
static void Deallocate(void *p, size_t /* n */) //这个size_t完全可以不要，但是为了统一接口，加上了这个size_t
{
free(p); //一级空间配置器直接使用 free()
}
// 对realloc的封装---该函数基本不用
static void * Reallocate(void *p, size_t /* old_sz */, size_t new_sz)
{
void * result = realloc(p, new_sz);
//无法满足需求时，改用oom_realloc()
if (0 == result)
result = Oom_Realloc(p, new_sz);
return result;
}
// 模拟set_new_handle
// 该函数的参数为函数指针，返回值类型也为函数指针
// void (* set_malloc_handler( void (*f)() ) )()
typedef void(*PFUNC)();
static PFUNC set_malloc_handler(PFUNC f)
//static void(*set_malloc_handler(void(*f)()))()
{
void(*old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return(old);
}
};
void(*OneSpce::__malloc_alloc_oom_handler)() = 0; //如果没有设置的话，在下面的函数就只能会抛异常
// malloc申请空间失败时代用该函数
void * OneSpce::Oom_Malloc(size_t n)
{
void(*my_malloc_handler)();
void *result;
for (;;) //不断的尝试释放、配置、再释放、在配置
{
// 检测用户是否设置空间不足应对措施，如果没有设置，抛异常，模式new的方式
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);
}
}
// 类似oom_malloc
void* OneSpce::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);
}
}
- 第一级配置器用malloc()、free()、realloc()等C函数执行实际的内存配置、释放、重配置等操作，并实现C++ new-handler的机制。当然，他不能直接使用C++ new-handler机制，因为他并非使用 ::operator new 来配置内存。
- 所谓C++ new handler 机制就是，你可以要求系统在内存配置需求无法被满足的时候，调用一个你指定的函数，也就是说，一旦 ::operator new 无法完成任务，在丢出异常之前，会先调用客户端指定的处理例程。该处理例程通常被称为 new-hanler。
- 注意：SGI第一级配置器的 Allocate() 和 realloc() 都是在调用malloc() 和 realloc() 不成功后，改调用 oom_malloc() 和 oom_realloc()。后两者都有内循环，不断调用“内存不足处理例程”，期望在某次调用之后，获得足够的内存而圆满的完成任务。但如果“内存不足处理例程”并未被客户端设定，oom_malloc() 和 oom_realloc() 便抛出异常，使用exit(1)终止程序。
- 但是我感觉，将“内存不足处理例程”交给客户端去设定。有点考验程序员。
二级空间配置器
- 二级空间配置器多了一些机制，避免太多小额内存区块造成的内存的碎片。因为小额内存区块带来的其实不仅仅是内存碎片，配置时的额外负担也是一个大问题。额外负担永远也无法避免，毕竟要靠多出来的空间来管理内存。如下图所示，区块愿小，额外负担所占的比例就愿大，就愿浪费空间。
- SGI 二级空间配置器的做法。如果内存块够大，超过128字节时，就移交给一级空间配置器。当区块小于128字节时，则就已内存池来管理。
- 大概是这样配置的吧，每次配置一大块空间，并维护对应之自由链表，下次若有相同大小的内存需求，就直接从free_lists 中拔出。如果客户端释放小额区块，就由配置器回收到 free_lists 中。当然，配置器除了负责配置，也负责回收。为了方便管理，SGI 二级配置器就会主动将任何小额区块的内存需求量上调到8的整数倍。（比如说，用户想要30字节，那么就给用户32字节），并且维护16个free_lists，各自管理大小分别为8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128 bytes 的小额区块。
- 二级空间配置器专门负责处理小于128字节的小块内存。如何才能提升小块内存的申请与释放的方式呢？SGI-STL 采用了内存池的技术来提高申请空间的速度以及减少额外空间的浪费，采用哈希桶的方式来提高用户获取空间的速度与高效管理。
- 内存池就是：先申请一块比较大的内存块已做备用，当需要内存时，直接到内存池中去要，当内存池中空间不够时，再向内存中去取，当用户不用时，直接还回内存池即可。避免了频繁向系统申请小块内存所造成的效率低、内存碎片以及额外浪费的问题。
- 二级空间配置器源代码
class __default_alloc_template
{
private:
enum {__ALIGN = 8}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
enum {__MAX_BYTES = 128}; // 大小内存块的分界线
enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; // 采用哈希桶保存小块内存时所需桶的个数
// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
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:
static obj * free_list[__NFREELISTS];
// 哈希函数，根据用户提供字节数找到对应的桶号
static size_t FREELIST_INDEX(size_t bytes)
{
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}
// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
static char *start_free;
static char *end_free;
// 用来记录该空间配置器已经想系统索要了多少的内存块
static size_t heap_size;
// ...
} ;
char* TwoSpace::start_free = 0;
char* TwoSpace::end_free = 0;
size_t TwoSpace::heap_size = 0;
TwoSpace::obj* TwoSpace::free_list[__NFREELISTS] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
- 上面的代码中，一些地方我需要说一下。
union obj
{
union obj * free_list_link;
char client_data[1]; /* The client sees this. */
};
- 大家都知道二级空间配置器中是以哈希桶的方式，维护的是链表，那么想要维护链表，肯定每个节点就需要额外的指针（指向下一个节点），这又是一个负担，所以我们看上面的代码。上面的 obj 使用的是union。由于 union 之故，从其第一字段观之，obj可以被视为一个指针，指向相同形式的下一个obj指针。从第二字段观之，obj可以视为一个指针，指向实际区块。这样的话，不会为了维护链表所必须的指针所浪费空间。
空间配置函数和空间释放函数
- 空间配置函数allocate() 首先判断区块大小，大于128bytes 就调用一级空间配置器，小于128bytes就检查对应的free_list。如果free_list 之内有可用的区块，就直接拿来用，如果没有可用的区块，就将区块上调至8倍数边界，然后调用refill(),准备为free_list重新填充空间。
static void * Allocate(size_t n)
{
obj * volatile * my_free_list;
obj * result;
//restrict 它只可以用于限定和约束指针，并表明指针是访问一个数据对象的唯一且初始的方式.即它告诉编译器，
//所有修改该指针所指向内存中内容的操作都必须通过该指针来修改,而不能通过其它途径(其它变量或指针)来修改
// 检测用户所需空间释放超过128(即是否为小块内存)
if (n > (size_t)__MAX_BYTES)
{
// 不是小块内存交由一级空间配置器处理
return (OneSpce::Allocate(n));
}
// 根据用户所需字节找到对应的桶号
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
// 如果该桶中没有内存块时，向该桶中补充空间
if (result == 0)
{
// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
void *r = refill(ROUND_UP(n));
return r;
}
// 维护桶中剩余内存块的链式关系
*my_free_list = result->free_list_link;
return (result);
}
- 空间释放函数，大于128bytes 就调用第一级配置器，小于128bytes 就找出对应的free_list，将区间回收。
// 函数功能：用户将空间归还给空间配置器
// 参数：p空间首地址 n空间总大小
static void Deallocate(void *p, size_t n)
{
obj *q = (obj *)p;
obj ** my_free_list;
// 如果空间不是小块内存，交给一级空间配置器回收
if (n > (size_t)__MAX_BYTES)
{
OneSpce::Deallocate(p, n);
return;
}
// 找到对应的哈希桶，将内存挂在哈希桶中
my_free_list = free_list + FREELIST_INDEX(n);
q->free_list_link = *my_free_list;
*my_free_list = q;
}
重新填充 free list
- 前面说过allocate() 。当发现 free list 中没有可用区块了时，就调用refill() ,准备为free_list 重新填充空间，新的空间将取自内存池（通过chunk_alloc完成）。缺省取得20个新节点，但是万一内存池空间不足，获得的节点数（区块数）可能小于20。
// 函数功能：向哈希桶中补充空间
// 参数n：小块内存字节数
// 返回值：首个小块内存的首地址
static void* refill(size_t n)
{
// 一次性向内存池索要20个n字节的小块内存
int nobjs = 20;
char * chunk = chunk_alloc(n, nobjs);
obj ** 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);
}
内存池
- 从内存池中取空间给free list 使用，是 chunk_alloc() 的工作。
static char* chunk_alloc(size_t size, int& nobjs)
{
// 计算nobjs个size字节内存块的总大小以及内存池中剩余空间总大小
char * result;
size_t total_bytes = size * nobjs;
size_t bytes_left = end_free - start_free;
// 如果内存池可以提供total_bytes字节，返回
if (bytes_left >= total_bytes)
{
result = start_free;
start_free += total_bytes;
return(result);
}
else if (bytes_left >= size)
{
// nobjs块无法提供，但是至少可以提供1块size字节内存块，提供后返回
nobjs = bytes_left / size;
total_bytes = size * nobjs;
result = start_free;
start_free += total_bytes;
return(result);
}
else
{
// 内存池空间不足，连一块小块村内都不能提供
// 向系统堆求助，往内存池中补充空间
// 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
// 如果内存池有剩余空间(该空间一定是8的整数倍)，将该空间挂到对应哈希桶中
if (bytes_left > 0)
{
// 找对用哈希桶，将剩余空间挂在其上
obj ** 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 ** 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;
return(chunk_alloc(size, nobjs));
}
}
// 山穷水尽，只能向一级空间配置器求助
// 注意：此处一定要将end_free置空，因为一级空间配置器一旦抛异常就会出问题
end_free = 0;
start_free = (char*)OneSpce::Allocate(bytes_to_get);
}
// 通过系统堆向内存池补充空间成功，更新信息并继续分配
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
return(chunk_alloc(size, nobjs));
}
}
- 上面chunk_alloc()函数以 end_free - start_free 来判断内存池中空间剩余。如果水量充足，就直接调用20个区块返回给 free list 。如果水量不足以提供20个区块，但还是能够供应一个以上的区块。就拔出这不足20个区块的空间出去。这时候其nobjs 参数将被修改为实际能够供应的区块数。如果内存池连一个区块空间都无法提供，对客户端显然没有办法交代。此时便使用malloc()从heap中配置内存，为内存池注入新的水应付需求。新水量的大小为需求量的两倍，再加上一个随着配置次数增加而越来越大的附加量。
- 向内存池注入新水的算法是：
// 向系统堆求助，往内存池中补充空间
// 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
- 那么我们描述一下这个过程，程序一开始，客户端假定调用 chunk_alloc（32,20），于是malloc() 配置40个32bytes区块。其中第一个交出，另外的19个交给free_list[3] 维护，余下的20个留给内存池。接下来客户端调用chunk_alloc（64,20），此时 free_list[7] 空空如也，必须向内存寻求支持。内存池只够供应（32*20）/64=10个bytes区块。就把这10个区块返回，第一个交给客户端，其余的9个交给free_list[7] 维护。此时内存池全空。接下来在调用chunk_alloc(96,20)，此时free_list[11] 空空如也，必须向内存池要求支持，而内存池也是空的，于是以malloc()配置40+n（这个n是1）个96bytes区块，其中第一个交出，另外的19个free_list[11]维护，余下的20+n个区块留给内存池。
- 但是万一山穷水尽，整个system_heap 空间都不够了，malloc()行动失败，chunk_alloc()就四处寻找有无“尚有未用区块，且区块足够大”之free lists。找到了就挖一块交出来，找不到就调用第一级配置器。第一级配置器其实也是使用malloc()来配置内存，但它有out-of-memory 处理机制，或许有机会释放其他内存拿到此处来使用。如果可以，就成功，否则就抛出bad_alloc异常。
空间配置器的默认选择
- SGI-STL默认使用一级还是二级空间配置器，通过USE_MALLOC宏进行控制（但是我们可以轻易的测出来，SGI STL 并未定义 __USE_MALLOC）：
#ifdef __USE_MALLOC
typedef __malloc_alloc_template<0> malloc_alloc;
typedef malloc_alloc alloc; //令alloc 为一级配置器
#else
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
#endif // !__USE_MALLOC
-
在SGI_STL中该宏没有定义，因此：默认情况下SGI_STL使用二级空间配置器
-
我自己封装的空间配置器源码地址：https://github.com/zhangyi-13572252156/STL-/tree/master
-
接下来我会写空间配置器和各个容器的结合。敬请大家指点。
扫一扫
2696
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
