C++动态内存分配---两级allocator设计与实现(二)

引言

前文 提到allocator类将new操作符内存的分配与对象的构造或delete操作符对象的析构和内存的释放分为两个阶段。内存的分配拟和释放分别由::allocate()和::deallocate()负责;对象的构造和析构分别由 ::construct()和::destroy()负责。本文参考《STL源码剖析》和SGI STL实现，分析allocator类中的构造与析构。

destroy函数和construct函数的实现

construct函数很简单，只是利用placement new调用对象的构造函数。而destory函数就稍微复杂一些，利用了type_traits编程技巧，判断迭代器所指元素类型中是否有non-trivial 析构函数，如果没有则直接结束，否则依次调用析构函数。这样处理的话，万一需要对很大范围的对象执行析构函数，但是析构函数都是无关痛痒的(trivial)则没有必要一次次调用析构函数，这样能大大提高效率。

#include<new>
#include<iostream>
#include<type_traits>
template<class T1,class T2>
inline void construct(T1 *p, const T2& value){
new (p)T1(value); //placement new;call T1::T1(value);
}

//destroy第一个版本，接受一个指针
template<class T>
inline void destroy(T* pointer){
pointer->~T();
}

//第二个版本接受两个迭代器，释放一个范围的内存，利用type_traits<>根据不同类型求得最适当的措施
template<class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last){
__destroy(first, last, std::_Val_type(first));
}

template<class ForwardIterator,class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*){
__destroy_aux(first, last, std::has_trivial_destructor<T>());
}

template<class ForwardIterator>
inline void __destroy_aux(ForwardIterator first, ForwardIterator last, std::false_type){
std::cout << "in false_type" << std::endl;
for (; first < last; ++first)
destroy(&(*first));
}

template<class ForwardIterator>
inline void __destroy_aux(ForwardIterator first, ForwardIterator last, std::true_type){
std::cout << "in true_type" << std::endl;
}

SGI STL的实现

SGI STL是STL的经典实现之一，那么SGI是如何考虑allocator的设计呢？

1. 从heap申请空间

2. 考虑多线程

3. 考虑内存不足

4. 考虑内存碎片

为了简化问题，我们不考虑多线程的情况。

剩下的三个问题中，申请内存可以采用malloc和free库函数，内存不足也在其中相应的考虑。而内存碎片则需要更精细的考虑。

内存碎片

当程序同时处理一系列内存需求，其中包括大块内存，小块内存，大小混合内存分配和释放时，有可能有大量的小块内存持续的分配和释放。这样很容易产生内存碎片，也就是说请求一个相对较大的内存时，空闲内存总和足够分配，但是不能分配一个连续的大块内存。

为了解决内存碎片的问题，SGI 设计了两级allocator:

当请求内存较大(大于128bytes)时,采用第一级allocator

小于128bytes时，采用第二级allocator，采用内存池的方法管理小内存

为了符合STL标准，SGI还定义了simple_alloc接口,无论采用第一级还是第二级allocator都能满足标准:

template<class T, class Alloc>
class simple_alloc{
public:
static T*allocate(size_t n){
return 0 == n ? 0 : (T*)Alloc::allocate(n*sizeof(T));
}
static T*allocate(){
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){
if (0 != n) Alloc::deallocate(p, sizeof(T));
}

};

第一级和第二级allocator的实现

第一级和第二级allocator主要区别在于处理不同大小的内存申请。内存申请大于128bytes时，第一级allocator直接调用malloc和free函数，并模拟C++的set_new_handler函数处理内存不足的情况。

第二级allocator则复杂很多，具体实现包括：

维护16个自由链表，负责16种不同大小的内存空间分配。

自由链表的内存由内存池分配，而内存池则由malloc函数分配内存

如果内存不足或请求内存大于128bytes则转调第一级allocator

具体代码如下所示，第二级allocator用内存池管理已分配但未使用的内存，当客户端请求内存时，首先查询free-list中是否有适当大小的内存块，如果有直接分配该内存块并将该内存块从freelist中移除。如果freelist没有匹配大小的可用内存块，则调用chunk_alloc()函数向内存池申请内存。chunk_alloc函数根据情况，处理申请请求：

默认分配20个用户索取区块大小的内存块，将其中一个返回给客户，剩余19个加入合适的free-list中

如果内存池中内存不足以分配20个区块(根据end_free和start_free可以查看内存池“水位”)，那么就分配内存池剩余内存可以分配的最大区块数，比如剩余100bytes，请求内存块大小为32bytes，则分配3个区块

如果内存池中剩余内存连一个区块都不能分配了，那么就向heap申请内存，但是需要把残余的内存分配到相应的freelist中，比如客户申请32bytes内存，但是内存池只剩下20bytes，那么就将这20bytes加入free-list管理16bytes的list中，这样只会产生4bytes的内存碎片

如果向heap申请内存失败，就只能检查free-list中是否有更大的区块能够分配给当前申请，注意这里需要递归调用chunk_alloc函数确保nobjs的正确。

最后，如果free-list中没有足够大可分配的内存，只能调用一级allocator查看是否能通过它的out-of-memory机制释放内存，或者从一级allocator中抛出异常。

enum {__NOBJS = 20};//每次填充freelist的节点数
enum {__ALIGN = 8};// 小型区块的上调边界
enum {__MAX_BYTES = 128};//小型区块的上限
enum {__NFREELISTS = __MAX_BYTES / __ALIGN};//free-lists 的个数
template<bool threads,int inst>
class __default_alloc_template{
private:
static size_t ROUND_UP(size_t bytes){
return (((bytes)+__ALIGN - 1) &~(__ALIGN - 1));
}
private:

union obj{
obj *free_list_link;
char client_data[1];
};
private:
static obj * volatile free_list[__NFREELISTS];
static size_t FREELIST_INDEX(size_t bytes){
return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
}
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 old_sz, size_t new_sz);

};
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>
typename __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 };

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_alloc::allocate(n));
//寻找free-lists中适当的一个list
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
if ( 0 == result){//如果没有可用的free-list则重新填充free-list
void *r = refill(ROUND_UP(n));
return r;
}
//将free-list的首个块取出，调整至下一个块
*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 > (size_t)__MAX_BYTES){
malloc_alloc::deallocate(p, n);
return;
}
my_free_list = free_list + FREELIST_INDEX(n);
//将释放的内存加入到free-list的首部
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 = __NOBJS;
char *chunk = chunk_alloc(n, nobjs);
obj * volatile *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);
//下面从1开始(第0块返回给调用者)将节点串联形成链表
for (i = 1;; ++i){
current_obj = next_obj;
if (nobjs - 1 == i){ //list尾部的link指向0
current_obj->free_list_link = 0;
break;
}
current_obj->free_list_link = next_obj = ((obj *)(next_obj) + n);
}

}

//size已经ROUND_UP
//nobjs传递引用,因为有可能修改它的值
template<bool threads, int inst>
char*  __default_alloc_template<threads, inst>::chunk_alloc(size_t size, int &nobjs){
char * result;
size_t total_bytes = size * nobjs;
size_t bytes_left = end_free - start_free;
//内存池剩余内存满足申请内存要求,返回start_free并调整内存池水位
if (bytes_left >= total_bytes){
result = start_free;
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;
}
start_free = (char*)malloc(bytes_to_get);
//heap 空间不足
if (0 == start_free){
int i;
obj * volatile *my_free_list, *p;
//搜索比当前需求的size更大的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;
//递归调用根据i的大小修正nobjs
return (chunk_alloc(size, nobjs));
}

}

//如果free-list中没有足够大的可用区块,尝试第一级allocator能够起作用，不过第一级也采用了malloc库函数
//但是第一级allocator设置了内存不足的处理程序，有可能释放一些内存或抛出异常
end_free = 0;
start_free = (char *)malloc_alloc::allocate(bytes_to_get);
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
return (chunk_alloc(size, nobjs));

}
}

小结

根据SGI STL实现了两级allocator管理内存分配，第一级处理大于128bytes的申请，第二级则采用free-list + 内存池处理小于128bytes的申请。