本篇将主要总结归纳《STL源码剖析》的空间配置器的相关STL实现。在此之前，我们也将总结归纳一些基本的C++知识和技法。
一、C++基础知识--3种new的方式
在C++中，包含3种new形式，分别是
- new / delete
- operator new / operator delete
- placement new
1. new, operator new, delete, operator delete
在C++中，我们所习惯的C++内存配置操作和释放操作是如下这样的：
class Foo{ ... };
Foo *pf = new Foo;
delete pf这里的new即为上述的第一种情况，也称new operator。他通常包含如下3个操作：
- new: 调用 ::operator new 分配内存 delete: 调用 Foo::~Foo()
- 调用 Foo::Foo()构造对象内容 调用 ::operator delete 释放内存
- 返回相应的指针
new operator 和 delete operaror 是对应在堆中内存的申请和释放，且二者无法被重载。
operator new/ operator delete 是可以根据operator+一样进行重载的。其工作的方式如下：
- 只分配所要求的空间，不调用对象的构造函数。当无法满足所要求分配空间时，则有 new_handler，则调用new_handler, 否执行bad_alloc(如果有抛出异常的请求)，否则返回0.
- 同时，重载时，返回类型必须是void* ,重载时，第一个参数必须是表达要求分配空间的大小，类型是size_t，重载可以带其他参数。
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
class Foo
{
public:
Foo() { std::cout << "constructor of Foo" << std::endl; }
~Foo() { std::cout << "destructor of Foo" << std::endl;}
// override operator new
void* operator new(size_t sz, string str)
{
std::cout << "operator new size "<< sz
<<" with string "<< str << std::endl;
// allocate memory
return ::operator new(sz);
}
// override operator delete
void operator delete(void* ptr)
{
std::cout<<"operator delete" << std::endl;
// delete memory
::operator delete(ptr);
}
};
int main()
{
// new operator
Foo *pFoo = new("Foo class") Foo;
delete pFoo;
return 0;
}
这里的 ::operator new 和 ::operator delete 对应于C语言就是 malloc和free，只进行内存分配，而且必须配套使用。
2. placement new
placement new 是重载operator new的一个标准的，全局的版本。函数原型如下：
void* operator new(size_t, void *p) throw() { return p; }char *buf= new char[sizeof(Foo)];
// 在已有的内存地址上调用构造函数。
Foo* pi = new(buf) Foo;
另外有三种方式进行提前分配缓存：
- 在堆上进行分配，也就是 char *buf = new char[sizeof(Foo)];
- 在栈上进行分配 char buf[N * sizeof(Foo)];
- 直接通过地址进行， void* buf = reinterpret_cast<void *(0xABDC);
二、STL空间配置器allocator
1. SGI特殊的空间配置器，std::alloc
正如上面new运算符包含2个操作过程，包括分配内存空间，释放内存。STL allocator将这两阶段区分开，内存配置由alloc::allocate()负责， 内存释放由alloc::deallocate()负责，对象构造由 ::contruct() 负责， 对象析构由 ::destroy() 负责。
2. 构造和析构基本工具： construct() 和 destroy()
上述的construct()接受一个指针p和一个初值value，该函数的用途就是将初值设定到所指的空间上，也就是上述所受的placement new。
同时上述利用value_type()获得所指迭代器所指对象的型别，再利用__type_traits<T>判断该型别的析构函数是不是trivial的。non trivial即至关重要，需要调用析构函数，进行释放，如果是trivial的，即如数值类别的，则不需要。这样的设定是为了能够提高效率。
#include <new.h> // 使用placemen new
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
//placement new, 调用T1::T1(value), p为已申请的内存缓存
new (p) T1(value);
}
// 以下为destroy()的第一版本，接受一个指针
template <class T>
inline void destroy(T* pointer){
// 这是placement new 的标准操作，先调用析构函数
pointer->~T();
}
// 以下是destroy() 的第二版本，接受两个迭代器，设法找出元素的数值型别
// 进而利用__type_traits<> 调用适当的操作
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last){
__destroy(first, last, value_type(first));
}
// 判断元素的数值型别(value_type)是否有trivial destructor,
template <class ForwardIterator, class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*)
{
typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
__destroy_aux(first, last, trivial_destructor);
}
// 如果元素的数值型别(value type)有nontrivial destructor, 就是需要显示调用析构函数
template<class ForwardIterator>
inline void
__destroy_auxx(ForwardIterator first, ForwardIterator last, __false_type){
for(; first < last; ++ first)
destroy(&*first);
}
// 如果元素的数值型别(value type)有trivial destructor, 比如数值类型
template<class ForwardIterator>
inline void __destroy_auxx(ForwardIterator, ForwardIterator, __true_type){}
// 以下是destroy() 对第二版本针对迭代器为char* 和 wchar_t* 的特化版本
inline void destroy(char*, char*)()
inline void destroy(wchar_t*, wchar_t*)()3. 空间的配置和释放 std::alloc
对象构造前的空间配置和对象析构后的空间释放，由<stl_alloc.h>负责，主要考虑以下几个准则
- 向system heap 要求空间
- 考虑多线程（multi_thread）状态
- 考虑内存不足时的应变措施
- 考虑过多“小型区块”可能造成的内存碎片（fragment）的问题。 --> 二级配置器
SGI STL以malloc()和free()完成内存的配置和释放。
正如上面的准则4，SGI采用双层级配置器，第一级配置器直接使用malloc和free，用来配置大于128byte的区域块；第二级配置器采用memory pool管理方式来配置小的区域块。其中区域块利用free_list来进行管理8,16,24, ..., 128等共16个等级的小额区域块。
一二级配置器军采用以下接口进行包装以符合STL规格：
template<class T, class Alloc> class simple_alloc { public: static T* allocate(size_t n) { return n == 0 ? 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) { Alloc::deallocate(p, sizeof(T)); } };
3.1 第一级配置器__malloc_alloc_template
第一级配置器以malloc(), free(), realloc()等C函数执行实际的内存配置，释放，重配置等操作，并实现了类似C++ new_handler的机制。因为不是用C++的::operator new来分配内存的。这里的new handler机制，就是如果::operator new 无法完成任务，在丢出std::bad_alloc异常状态之前，会先调用客户端制定的处理历程。 其中，第一级配置器还分成两种情况，一是如果内存足够，直接调用allocate, deallocate, 和 reallocate，对应malloc, free, 和realloc。 当内存不足时，也就是out of memory, 就调用相应的oom_malloc(), oom_realloc()。
3.2 第二级配置器 __default_alloc_template
第二级配置器是为了避免太多小额区块造成的内存碎片而存在的。当区块大于128byte时，交给第一级配置器，否则，则以内存池（memory pool）管理，交给第二级配置器，又称次层配置（sub_allocation），其用一个自由链表free_list进行维护。配置器除了负责配置，也负责回收，同时也会将所有申请的小额区块主动上调到8的倍数，比如30 bytes->32 bytes。维护16个free_list分别管理16个不同区块，分别是8 bytes, 16 bytes, ..., 128 bytes，方便分配和回收。
这里维护free_list的节点数据结构如下：
union obj { union obj* free_list_link; char client_data[1]; };
<STL源码剖析>上说，此结构一物二用的结果是，不会为了维护链表所必须的指针而造成一种内存浪费。上述用到了
柔性数组
的概念。这里的前4字节用来存储指向的地址。这里的一物二用，是指，client_data指向的是当前首地址，同时也可以直接通过obj.client_data获取内容。而free_list_link本身可以看做一个指针，指向一个obj。需要注意的是，client_data里的值可以是0或者1。其长度大小由客户端设定。以下给出一个示例代码：
运行结果如下：#include <iostream> #include <string> #include <cstring> #include <algorithm> using namespace std; struct Bar { int bar; char client_data[0]; }; Bar *pObj; int main() { char str1[] = "hello world"; pObj = (Bar*)malloc(sizeof(Bar) + strlen(str1) + 1); if(NULL != pObj) { pObj->bar = 1; strcpy(pObj->client_data, str1); } cout << "pObj: " << pObj->bar << " " << pObj->client_data << endl; free(pObj); return 0; }
回到正文。
以下是第二级配置器的实现源码：
enum {__ALIGN = 8}; //小型区块的上调边界
enum {__MAX_BYTES = 128}; //小型区块的上界
enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; //free-list个数
template <bool threads, int inst>
class __default_alloc_template {
private:
/*将bytes上调至8的倍数
用二进制理解,byte整除align时尾部为0，结果仍为byte；否则尾部肯定有1存在，加上
align - 1之后定会导致第i位(2^i = align)的进位,再进行&操作即可得到8的倍数
*/
static size_t ROUND_UP(size_t bytes) {
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
private:
union obj { //free-list的节点
union obj * free_list_link;
char client_data[1]; /* The client sees this. */
};
private:
//16个free-lists
static obj * __VOLATILE free_list[__NFREELISTS];
//根据区块大小，找到合适的free-list，返回其下标(从0起算)
static size_t FREELIST_INDEX(size_t bytes) {
return (((bytes) + __ALIGN-1)/__ALIGN - 1);
}
//返回一个大小为n的对象，并可能编入大小为n的区块到相应的free-list
static void *refill(size_t n);
//配置一大块空间，可容纳nobjs个大小为“size”的区块
//如果配置nobjs个区块有所不便，nobjs可能会降低
static char *chunk_alloc(size_t size, int &nobjs);
//Chunk allocation state
static char *start_free;
static char *end_free;
static size_t heap_size;
public:
static void * allocate(size_t n);
static void * deallocatr(void *p, size_t n);
static void * reallocate(void *p, size_t old_sz, size_t new_sz);
};
//以下是static data member的定义与初值设定
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>
__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, };
以下是 空间配置函数allocate()的实现：
//n must be > 0 static void * allocate(size_t n) { obj * __VOLATILE * my_free_list; obj * __RESTRICT result; //大于128就调用第一级配置器 if (n > (size_t) __MAX_BYTES) { return(malloc_alloc::allocate(n)); } //寻找16个free-lists中适当的一个 my_free_list = free_list + FREELIST_INDEX(n); result = *my_free_list; if (result == 0) { //没找到可用的free-list，准备重新填充free-list void *r = refill(ROUND_UP(n)); return r; } //调整free-list，指向拨出区块的下一个区块 *my_free_list = result -> free_list_link; return (result); };
相应的示意如下：
空间释放函数deallocate()
首先判断区块大小，大于128就调用第一级配置器，否则就找出相应的free_list，将区块回收。// p不可以是0 static void deallocate(void *p, size_t n) { obj *q = (obj *)p; obj * volatile * my_free_list; // 大于128就调用第一级配置器 if(n > (size_t) __MAX_BYTES) { malloc_alloc::deallocate(p, n); return; } //寻找对应的free list my_free_list = free_list + FREELIST_INDEX(n); // 调整free list, 回收分块。 q->free_list_link = *my_free_list; *my_free_list = q; }
重新填充free lists refill()函数
当free_list中没有了可用区块时，为free list重新填充空间，新的空间从内存池（由 chunk_alloc()完成）。//返回一个大小为n的对象，并且有时候会适当的free-list增加节点 //假设n已经适当上调至8的倍数 template <bool threads, int inst> void* __default_alloc_template<threads, inst>::refill(size_t n) { int nobjs = 20; //尝试获得nobjs个区块作为free-list的新节点 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); //否则调整free-list 纳入新节点 my_free_list = free_list + FREELIST_INDEX(n); //在chunk这段连续内存内建立free-list result = (obj *)chunk; //这一块准备返回给客户端 //将free-list指向新配置的连续内存空间 //allocate中my_free-list为0才进入本函数，故无需存储现在的*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); //每一个区块大小为n if (nobjs - 1 == i) { //最后一块 current_obj -> free_list_link = 0; break; } else { current_obj -> free_list_link = next_obj; } } return(result); }内存池（memory pool）中的chunk_alloc()
此函数用于给予free_list分配区块。注意，新加量的大小是原来的两倍，并再加上一个随着配置次数增加的越来越大的附加量。并且其中的nodjs采用pass by reference的形式，是因为参数将被修改为实际被分配的区域块大小。chunk_alloc取空间的原则如下：尽量从内存池中取，内存池不够了，才使用free-list中的可用区块。
//size此时已适当上调至8的倍数 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; //8的倍数 size_t bytes_left = end_free - start_free; //8的倍数 if (bytes_left >= total_bytes) { //情况1 //内存池剩余空间完全满足需求量 result = start_free; start_free += total_bytes; return(result); } else if (bytes_left >= size) { //情况2 //虽不足以完全满足，但足够供应一个(含)以上的区块 //从start_free开始一共total_bytes分配出去，其中前size个bytes给客户端，剩余的给free-list 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); //找到大小相同区块所在的free-list ((obj *)start_free) -> free_list_link = *my_free_list; //将内存池剩余空间编入free-list中 *my_free_list = (obj *)start_free; } //此时内存池的空间已用完 //配置heap空间，用来补充内存池 start_free = (char *)malloc(bytes_to_get); if (0 == start_free) { //heap空间不足，malloc失败 int i; obj * __VOLATILE * my_free_list, *p; //转而从free-lists中找寻可用的区块(其大小够用) for (i = size; i <= __MAX_BYTES; i += __ALIGN) { my_free_list = free_list + FREELIST_INDEX(i); p = *my_free_list; if (0 != p) { //free-list尚有可用区块 //调整free-list以释出可用区块 *my_free_list = p -> free_list_link; start_free = (char *)p; //将改区块归还到内存池 end_free = start_free + i; //再次从内存池中索要连续空间来满足客户端需求 return(chunk_alloc(size, nobjs)); //由于此时i >= size,故此次只会进入情况1/2 } } end_free = 0; //没有可用区块归还到内存池，内存池仍为空 //调用第一级配置器，看out-of-memory机制是否能改善 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)); } }
参考文献：
- 侯捷， STL源码剖析 华中科技大学出版社
- ww32cc的博客 http://blog.youkuaiyun.com/ww32zz/article/details/48343689
- 梦中乐园 柔性数组 http://www.cppblog.com/Dream5/articles/148386.html
- 阿凡卢 C++中的new， operator new 和 placement new http://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html
1113
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
