STL学习笔记之空间配置器

最近看了看侯捷的《STL源码剖析》，打算看完之后写写笔记，毕竟很多东西看起来看懂了，却并不一定能够将其描述清楚，说到底还是没有彻底弄明白，最近博客也基本不怎么写了，所以还是决定写一写，这也算是写博客的乐趣之一吧。这一系列笔记，更主要是写给自己看的：）

1. 初探allocator

其实像我这样的一般人几乎接触不到allocator这种东西，因为这个模板参数是有默认值的，普通用户完全不需要和他打交道。但观察一下allocator这个东西的设计思路，还是可以学到不少东西。先从一个简单的allocator源代码看起：

#ifndef _JJALLOC_
#define _JJALLOC_

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>

namespace JJ
{
// 使用operator new分配空间
template<class T>
inline T* _allocate(ptrdiff_t size, T*)
{
std::set_new_handler(0);
T *tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
if (tmp == 0)
{
std::cerr << "out of memory" << std::endl;
exit(1);
}
return tmp;
}
// 使用operator delete回收空间
template<class T>
inline void _deallocate(T* buffer)
{
::operator delete(buffer);
}
// 在指定内存上构造一个对象
template<class T1, class T2>
inline void _construct(T1* p, const T2& value)
{
// placement new
new (p) T1(value);
}
// 析构一个对象
template<class T>
inline void _destroy(T* ptr)
{
ptr->~T();
}
// 遵循allocator的标准定义相关结构
template<class T>
class allocator
{
public:
typedef T           value_type;
typedef T*          pointer;
typedef const T*    const_pointer;
typedef T&          reference;
typedef const T&    const_reference;
typedef size_t      size_type;
typedef ptrdiff_t   difference_type;

template<class U>
struct rebind
{
typedef allocator<U> other;
};

pointer allocate(size_type n, const void* hint=0)
{
return _allocate((difference_type)n, (pointer)0);
}

void deallocate(pointer p, size_type n)
{
_deallocate(p);
}

void construct(pointer p, const T& value)
{
_construct(p, value);
}

void destroy(pointer p)
{
_destroy(p);
}

pointer address(reference x)
{
return (pointer)&x;
}

const_pointer const_address(const_reference x)
{
return (const_pointer)&x;
}

size_type max_size() const
{
return size_type(UINT_MAX/sizeof(T));
}
};
}

#endif

上面的代码之中的几个点：

1. set_new_handler

set_new_handler的函数原型如下：

typedef void (*new_handler)();
new_handler set_new_handler (new_handler new_p) throw();

使用set_new_handler可以设置一个函数new_p，当使用new/operator new分配内存失败时，new_p将被调用。new_p将尝试使得更多内存空间可用，以使得接下来的内存分配操作能够成功。如果new_p指向NULL（默认就是NULL），那么将会抛出bad_alloc异常，这也是为什么我们默认使用new失败的时候将会抛出bad_alloc异常的原因；

2. 几个new/delete操作

我们使用的new叫做new operator，包括两个步骤，一是调用operator new来分配指定大小的内存空间，然后调用构造函数；所以如果只是进行空间分配操作，那么使用operator new就可以了，就好比C的malloc函数；如果已经分配好了空间，想在上面构造一个对象，那么可以使用placement new，上面的_construct函数里面调用的就是placement new；

3. 如何使用这个allocator？

定义vector时有一个模板参数用于指定allocator，如下所示：

#include "jjalloc.h"
#include <vector>
#include <iostream>
using namespace std;

int main(int argc, char **argv)
{
int ia[5] = {0, 1, 2, 3, 4};
unsigned int i;
vector<int, JJ::allocator<int> > iv(ia, ia+5);
for (i = 0; i < iv.size(); ++i)
{
cout << iv[i] << " ";
}
cout << endl;

return 0;
}

2. 构造与析构

在stl_construct.h中定义了构造和析构的相关函数：

// 调用placement new，根据__value在__p上构造一个对象
template <class _T1, class _T2>
inline void _Construct(_T1* __p, const _T2& __value) {
new ((void*) __p) _T1(__value);
}

// 调用placement new在__p上构造一个对象，使用默认构造函数
template <class _T1>
inline void _Construct(_T1* __p) {
new ((void*) __p) _T1();
}

// 析构一个对象
template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
__pointer->~_Tp();
}

// 析构迭代器__first和__last之间的对象，实际上通过destroy函数，调用了对应的析构函数
template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
for ( ; __first != __last; ++__first)
destroy(&*__first);
}

// __destroy_aux重载函数，这里是对于trivial析构函数，不进行任何处理，提高效率
template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}

// 根据__type_traits萃取出类型_Tp的析构函数是否是trivial的，编译器根据类型自动选择对应的__destroy_aux
template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
typedef typename __type_traits<_Tp>::has_trivial_destructor
_Trivial_destructor;
__destroy_aux(__first, __last, _Trivial_destructor());
}

template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
__destroy(__first, __last, __VALUE_TYPE(__first));
}

inline void _Destroy(char*, char*) {}
inline void _Destroy(int*, int*) {}
inline void _Destroy(long*, long*) {}
inline void _Destroy(float*, float*) {}
inline void _Destroy(double*, double*) {}
#ifdef __STL_HAS_WCHAR_T
inline void _Destroy(wchar_t*, wchar_t*) {}
#endif /* __STL_HAS_WCHAR_T */

// --------------------------------------------------
// Old names from the HP STL.

template <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __value) {
_Construct(__p, __value);
}

template <class _T1>
inline void construct(_T1* __p) {
_Construct(__p);
}

template <class _Tp>
inline void destroy(_Tp* __pointer) {
_Destroy(__pointer);
}

template <class _ForwardIterator>
inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
_Destroy(__first, __last);
}

__STL_END_NAMESPACE

这里值得一提的主要是析构部分使用的一些技巧。首先解释一下所谓的trivial destructor，值得就是调用不调用都无所谓的析构函数，那么处于效率方面的考虑，在这样的情况下肯定选择什么都不做（如果进行十万百万次这样的函数调用，是不是就白白浪费了大好的时光了？）而且这里是在编译器就通过函数的重载来决定是否要调用析构函数。

具体是通过__type_traits来萃取出类型是否具有trivial destructor的，这里在后面的文章会提到这些细节。现在所要了解的就是通过__type_traits可以萃取出类型的destructor特性（trivial or non-trivial），然后通过函数重载来决定具体进行什么样的操作。

The implicitly-declared destructor for class T is trivial if all of the following is true:
The destructor is not virtual (that is, the base class destructor is not virtual)
All direct base classes have trivial destructors
All non-static data members of class type (or array of class type) have trivial destructors
A trivial destructor is a destructor that performs no action. Objects with trivial destructors
don't require a delete-expression and may be disposed of by simply deallocating their storage.
All data types compatible with the C language (POD types) are trivially destructible.

3. 两级空间配置器

SGI STL提供两级空间配置器，第一级空间配置器使用malloc/free函数，当分配的空间大小超过128 bytes的时候使用第一级空间配置器；第二级空间配置器使用了内存池技术，当分配的空间大小小雨128 bytes的时候，将使用第二级空间配置器。

大量分配小块的内存空间会带来问题：一是从运行库的堆管理器中取得的内存（比如通过malloc获得的内存），会有一部分空间用于存储管理信息，用于管理各个内存块，这样内存的使用率就降低了；二是过多的小块内存会带来内存碎片问题；采用合适的内存池技术可以避免这些问题。

SGI STL的第二级内存配置器维护了一个free-list数组，分别用于管理8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128 bytes的小额区块，free-list的节点结构如下：

union obj
{
union obj* free_list_link;
char client_data[1];
};

这里使用union结构，是为了节省空间，也就是说，当节点位于free-list时，通过free_list_link指向下一块内存，而当节点取出来分配给用户使用的时候，整个节点的内存空间对于用户而言都是可用的，这样在用户看来，就完全意识不到free_list_link的存在，可以使用整块的内存了。

在分配内存时，会将大小向上调整为8的倍数，因为free-list中的节点大小全是8的倍数。

enum {_ALIGN = 8};
enum {_MAX_BYTES = 128};
enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN
// 将待分配的空间大小向上调整为8的倍数
static size_t
_S_round_up(size_t __bytes)
{ return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }

__PRIVATE:
union _Obj {
union _Obj* _M_free_list_link;
char _M_client_data[1];    /* The client sees this.        */
};
private:
// 定义free_list数组
static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS];
// 根据空间大小取得free_list数组的对应下标
static  size_t _S_freelist_index(size_t __bytes) {
return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
}

空间的分配：就是从对应的free-list节点链表中取出一个节点返回给用户，当然，如果没有可用的节点的话就要通过refill来分配新的节点了，后面会有描述：

static void* allocate(size_t __n)
{
void* __ret = 0;
// 如果大于128 bytes，则使用第一级空间配置器
if (__n > (size_t) _MAX_BYTES) {
__ret = malloc_alloc::allocate(__n);
}
else {
// 通过大小取得free-list数组下标，随后取得对应节点的指针
// 相当于&_S_free_list[_S_freelist_index(__n)]
_Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);
_Obj* __RESTRICT __result = *__my_free_list;
// 如果没有可用的节点，则通过_S_refill分配新的节点
if (__result == 0)
__ret = _S_refill(_S_round_up(__n));
else {
// 将当前节点移除，并当做结果返回给用户使用
*__my_free_list = __result -> _M_free_list_link;
__ret = __result;
}
}

return __ret;
};

从free-list中摘取节点返回给用户使用的示意图如下：(配图来自《STL源码剖析》一书)



而空间的回收，则是把内存重新加入到free-list对应的节点链表上去。

那么，当对应的free-list链表中没有可用节点的时候，refill进行了怎样的操作呢？默认操作时通过_S_chunk_alloc从内存池中取得20个新的节点添加到free-list链表中，当然，内存池中的内存不够用也是会出现的情况之一，这时候能分多少就分多少节点，再万一内存池一个节点都提供不了了，那就内存池需要新增空间了，如果失败，再抛出bad_alloc异常。

template <bool __threads, int __inst>
void*
__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
{
int __nobjs = 20;
// 通过内存池分配内存，第二个参数为传引用方式
char* __chunk = _S_chunk_alloc(__n, __nobjs);
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __result;
_Obj* __current_obj;
_Obj* __next_obj;
int __i;
// 如果只分配了一个节点，那么直接返回给用户就是了
if (1 == __nobjs) return(__chunk);
// 如果分配了不止一个节点，那么多余的我们要放到free-list里面去
__my_free_list = _S_free_list + _S_freelist_index(__n);

/* Build free list in chunk */
__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) {
// 最后一个节点的_M_free_list_link指针指向NULL，并跳出循环
__current_obj -> _M_free_list_link = 0;
break;
} else {
__current_obj -> _M_free_list_link = __next_obj;
}
}
return(__result);
}

4. 内存池

通过_S_chunk_alloc，从内存池中分配空间给free-list：

template <bool __threads, int __inst>
char*
__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,
int& __nobjs)
{
char* __result;
// 需要分配的空间大小
size_t __total_bytes = __size * __nobjs;
// 内存池中剩余的空间大小
size_t __bytes_left = _S_end_free - _S_start_free;

// 如果剩余大小满足要求，那么直接操作对应的指针即可
if (__bytes_left >= __total_bytes) {
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
}
// 剩余大小不够，但是至少还能分配一个节点
else if (__bytes_left >= __size) {
// 能够分配的节点数
__nobjs = (int)(__bytes_left/__size);
__total_bytes = __size * __nobjs;
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
}
// 一个节点的空间都不够了
else {
// 新申请的空间为2倍大小
size_t __bytes_to_get =
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
// Try to make use of the left-over piece.
// 如果还有剩余的空间，加入对应的free-list节点的链表
if (__bytes_left > 0) {
_Obj* __STL_VOLATILE* __my_free_list =
_S_free_list + _S_freelist_index(__bytes_left);

((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
*__my_free_list = (_Obj*)_S_start_free;
}
// 分配新的空间
_S_start_free = (char*)malloc(__bytes_to_get);
// 如果操作失败
if (0 == _S_start_free) {
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
// Try to make do with what we have.  That can't
// hurt.  We do not try smaller requests, since that tends
// to result in disaster on multi-process machines.
// 看看free-list数组中，是否有更大尺寸的可用节点
for (__i = __size;
__i <= (size_t) _MAX_BYTES;
__i += (size_t) _ALIGN) {
__my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list;
// 如果有可用节点则摘一个下来给内存池使用
if (0 != __p) {
*__my_free_list = __p -> _M_free_list_link;
_S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
// 递归调用自身，修正__nobjs
return(_S_chunk_alloc(__size, __nobjs));
// Any leftover piece will eventually make it to the
// right free list.
}
}
// 如果没有可用节点，则只能指望第一级空间配置器了
_S_end_free = 0;	// In case of exception.
_S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
// This should either throw an
// exception or remedy the situation.  Thus we assume it
// succeeded.
}
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
// 递归调用自身，修正__nobjs
return(_S_chunk_alloc(__size, __nobjs));
}
}

_S_chunk_alloc的流程总结如下：

1. 内存池有足够大小的空间，则分配申请的空间；

2. 内存池没有足够大小的空间，但是至少还能分配一个节点的空间，则能分多少分多少；

3. 内存池一个节点都腾不出来了，向系统的heap申请2倍于要求大小的空间，在此之间，如果内存池剩余有空间，则放到free-list中去；

4. 如果向heap申请空间失败，那么只能看free-list中更大的节点是否有可用空间了，有则用之，同时递归调用自身修正__nobjs；

5. 如果free-list也没有可用节点了，那么转向第一级空间配置器申请空间；

6. 再不行，第一级空间配置器就要抛出bad_alloc异常了；

注意如果有需求的话，内存池中会不断的通过malloc申请新的内存，最后内存池所拥有的内存也会越来越大，当然最后进程结束的时候，这些内存都会由操作系统收回。

5. 内存基本处理工具

STL提供了五个全局函数用于处理空间，分别为：

1. construct 用于构造；

2. destroy 用于析构；

3. uninitialized_copy(first, last, result) 将[first,last)范围内的对象复制到result处；

4. uninitiated_fill(first, last, X) 将[first,last)范围内的内存用对象X的副本填充；

5. uninitiated_fill_n(first, n, X) 将first开始的n个连续的内存空间用X的副本填充；

前面提到对于destroy的实现，如果对象的析构函数是trivial的，那么什么都不用做，同样的，对于uninitialized_copy和uninitiated_fill / uninitiated_fill_n，如果对象时POD类型，那么可以直接通过复制内存的方式来实现，对于普通的POD类型，通过上层的copy函数来实现复制填充，对于char*/wchar_t*，则提供对应的特化版本，通过memmove实现（和memcpy相比，memmove支持重叠内存操作）；如果不是POD类型，那么就只能通过construct实现了。

关于POD类型：

可见，POD类类型就是指class、struct、union，且不具有用户定义的构造函数、析构函数、拷贝算子、赋值算子；不具有继承关系，
因此没有基类；不具有虚函数，所以就没有虚表；非静态数据成员没有私有或保护属性的、没有引用类型的、没有非POD类类型的
（即嵌套类都必须是POD）、没有指针到成员类型的（因为这个类型内含了this指针）。

简单的说直接的内存复制操作对POD类型没有影响，比如用memset进行初始化，但这对于非POD类型是不可行的，比如存在虚函数的情况下。

判断一个类型是否是POD类型，也是通过__type_traits萃取出来的。

// POD类型，通过高层的copy实现
template <class _InputIter, class _ForwardIter>
inline _ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
_ForwardIter __result,
__true_type)
{
return copy(__first, __last, __result);
}

// 非POD类型，通过调用_Construct进行构造对象
template <class _InputIter, class _ForwardIter>
_ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
_ForwardIter __result,
__false_type)
{
_ForwardIter __cur = __result;
__STL_TRY {
for ( ; __first != __last; ++__first, ++__cur)
_Construct(&*__cur, *__first);
return __cur;
}
__STL_UNWIND(_Destroy(__result, __cur));
}

// 中间函数，通过__type_traits<_Tp>::is_POD_type萃取出POD类型
template <class _InputIter, class _ForwardIter, class _Tp>
inline _ForwardIter
__uninitialized_copy(_InputIter __first, _InputIter __last,
_ForwardIter __result, _Tp*)
{
typedef typename __type_traits<_Tp>::is_POD_type _Is_POD;
return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
}

// 用户接口函数
template <class _InputIter, class _ForwardIter>
inline _ForwardIter
uninitialized_copy(_InputIter __first, _InputIter __last,
_ForwardIter __result)
{
return __uninitialized_copy(__first, __last, __result,
__VALUE_TYPE(__result));
}

// char* 特化版本
inline char* uninitialized_copy(const char* __first, const char* __last,
char* __result) {
memmove(__result, __first, __last - __first);
return __result + (__last - __first);
}

// wchar_t* 特化版本
inline wchar_t*
uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
wchar_t* __result)
{
memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
return __result + (__last - __first);
}

具体的实现方法的选择示意图如下：



uninitiated_copy实现版本选择

参考

std::set_new_handler http://www.cplusplus.com/reference/new/set_new_handler/

trivial destructor http://en.cppreference.com/w/cpp/language/destructor

POD http://zh.wikipedia.org/wiki/POD_(%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1)

原文链接：http://www.programlife.net/stl-allocator.html，作者：代码疯子