STL之空间配置器

最近在看侯捷老师写的STL源码剖析，想通过看优秀的代码来提高自己的编程水平。

首先STL提供了六大组件，彼此可以套用使用。

借助一张从书上截的图来表明：



Container通过Allocator来获取数据存储空间

Algorithms通过迭代器来获取Container的内容，Functors可以协助Algorithms完成不同策略变化

Adapter可以修饰或者套接Functor由此可见在STL中空间配置器是非常重要的。

简单分析下为什么需要使用空间配置器？

使用空间配置器的原因就是为了解决外碎片



而且我们在使用STL容器的时候，比如vector我们可能需要不断的去申请内存，频繁的申请小块内存效率是非常低的。而STL是非常重视效率的，因此就有了空间配置器来解决这个问题。

STL空间配置器的框架设计





首先设计一级空间配置器

它使用了 __malloc_alloc_template一个模板类来实现一级空间配置器的功能，在这里我可以根据STL给出的简单的模拟实现它，通过这种方式来了解它到底是如何实现的。

typedef void(*HANDLE_FUNC)();//HANDLE_FUNC代表一个函数指针
template <int inst>
class __Malloc_Alloc_Template
{
public:
//static void(*set_malloc_handler(void(*f)()))()源码给出的形式,返回值和参数类型都是函数指针
static HANDLE_FUNC SetMallocHandler(HANDLE_FUNC f)//既然在OOM_MALLOC里使用了句柄，那么就要设置
{
HANDLE_FUNC old = _handle;
_handle = f;
return old;
}//用户来设置句柄，但是不建议，容易陷入死循环
static void* OOM_Malloc(size_t size)
{
while (1)
{
if (_handle == 0)
{
throw bad_alloc();
}
_handle();//如果设置了句柄，那么就会一直循环，直到申请到了，才会退出
void *ret = malloc(size);
if (ret)
{
return ret;
}
}
}
static void* Allocate(size_t size)//直接调用malloc
{
void*ret = malloc(size);
if (ret == 0)//表示一级空间配置器调用malloc没有申请到内存
{
ret = OOM_Malloc(size);//失败了并没有直接返回，而是继续调用OOM_MALLOC
}
}
static void Deallocate(void* p, size_t n)//释放一级空间配置器申请的内存
{
free(p);
}
private:
static HANDLE_FUNC _handle;
};

上述就是简单的一级空间配置器的设计，当然STL设计的还有realloc在这里我只是简单的模拟实现以下，没有写realloc;

二级空间配置器的设计相较于一级空间配置器的实际就复杂一些



他申请内存并不是直接先问系统索要见下图的过程：



小细节：

template <bool threads, int inst>
class __DefaultAlloceTemplate
{
public:
static  size_t FREELIST_INDEX(size_t bytes)//计算这n个字节对应的自由链表的下标
{
return (((bytes)+__ALIGN - 1) / __ALIGN - 1);//STL非常注重效率
}
static size_t  ROUND_UP(size_t bytes)
{
return ((bytes)+__ALIGN - 1)&(~(__ALIGN - 1));//变成8的倍数
}
static char* Chunk(size_t n, size_t &nobjs)
{
//__TRACE_DEBUG("到memory pool期望取%u个%u bytes对象\n", nobjs, n);
size_t total_bytes = n*nobjs;//向内存池索要的总字节数，分三种情况
size_t left_bytes = _endfree - _startfree;//内存池中剩余的字节数
if (total_bytes <= left_bytes)//说明一次就可以直接从内存池中拿到n*nobjs个字节
{
//__TRACE_DEBUG("memory pool拥有足够%u个对象的内存\n", nobjs)
char *ret = _startfree;
_startfree += total_bytes;
return ret;
}
else if (left_bytes>n)//说明内存池中不足n*njobs个字节，但是足够n个
{
//__TRACE_DEBUG("memory pool只有%u个对象的内存\n", nobjs);
nobjs = left_bytes/n; //实际能申请nobjs个
total_bytes = n*nobjs;
char *ret = _startfree;
_startfree += total_bytes;
return ret;
}
else//说明内存池中连n个都不够
{
//__TRACE_DEBUG("memory pool连一个%ubytes的对象都没有\n", n);
if (left_bytes > 0)//说明内存池中还有剩余的虽然不足n个字节，必须先处理掉，才能给内存池重新分配空间
{
size_t index = FREELIST_INDEX(left_bytes);
((Obj*)(_startfree))->free_list_link = _freeList[index];
_freeList[index] = (Obj*)_startfree;
}
//说明要为狭义内存池分配空间了
size_t byteToGets = total_bytes * 2 + ROUND_UP(_heapsize >> 4);
//__TRACE_DEBUG("到系统申请%u bytes给memory pool\n", byteToGets);
_startfree = (char*)malloc(byteToGets);
if (_startfree == NULL)//说明内存已经吃紧，到更大的自由链表中去获取空间
{
//__TRACE_DEBUG("到系统申请内存失败\n", n);
for (size_t i = FREELIST_INDEX(n); i < __NFREELISTS; ++i)
{
if (_freeList[i])
{
Obj*ret = _freeList[i];
_freeList[i] = ret->free_list_link;
_startfree = (char*)ret;
_endfree = _startfree + (i + 1)*__ALIGN;
return Chunk(n, nobjs);
}
}
//如果还是没有分配到内存，也不要灰心，继续调用一级空间配置器
_startfree = (char*)__Malloc_Alloc_Template<0>::Allocate(byteToGets);
}
//说明一定分配内存成功了
_heapsize = _heapsize + byteToGets;
_endfree = _startfree + byteToGets;
return Chunk(n, nobjs);
}
}
static void* Allocate(size_t n)
{
if (n > __MAX_BYTES)
{
return __Malloc_Alloc_Template<0>::Allocate(n);
}
//__TRACE_DEBUG("调用二级空间配置器申请%u bytes\n", n);
size_t index = FREELIST_INDEX(n);//计算在自由链表下对应的下标
if (_freeList[index])//说明自由链表不空
{
//__TRACE_DEBUG("在自由链表第%d个位置取一个对象\n", index);
Obj *ret = _freeList[index];
_freeList[index] = ret->free_list_link;
return ret;
}
//说明自由链表对应的位置没有存储空间，此时我们需要去问内存池索要；
else
{
return Refill(ROUND_UP(n));
}
}
static char* Refill(size_t n)//实际上返回我们需要的，并且将剩余的挂在相应的自由链表下面
{
size_t nobjs = 20;
char *ret=Chunk(n, nobjs);//真正向内存池索要数据
//__TRACE_DEBUG("到memory pool申请到%u个对象，一个返回使用，剩余挂到自由链表下面\n", nobjs);
if (nobjs == 1)
{
return ret;
}
else
{
size_t index = FREELIST_INDEX(n);
_freeList[index] = (Obj*)(ret+n);
Obj*cur = _freeList[index];
for (size_t i = 2; i < nobjs; ++i)
{
Obj*next =(Obj*)((char*)cur+n);
cur->free_list_link = next;
cur = next;
}
cur->free_list_link = NULL;
return ret;
}
}
static void Deallocate(void* ptr, size_t n)
{
if (n > __MAX_BYTES)
{
__Malloc_Alloc_Template<0>::Deallocate(ptr, n);
}
else//并没有真正的释放，而是挂在了自由链表下面
{
size_t  index = FREELIST_INDEX(n);
//__TRACE_DEBUG("将释放的对象挂到freeList[%u]\n", index);
((Obj*)ptr)->free_list_link = _freeList[index];
_freeList[index] = (Obj*)ptr;
}
}
private:
enum { __ALIGN = 8 };
enum { __MAX_BYTES = 128 };
enum { __NFREELISTS = __MAX_BYTES / __ALIGN };
union Obj {
union Obj * free_list_link;
char client_data[1];    /* The client sees this.        */
};//管理自由链表

//狭义内存池
static Obj*_freeList[__NFREELISTS];
static char*_startfree;
static char*_endfree;
static size_t _heapsize;
};