SGI STL 空间配置器（allocator）源码剖析
空间配置器的作用
我们知道，stl中的数据都是放到容器中的，容器需要存储空间，空间配置器就是负责容器存储空间的分配、回收等一系列内存操作。
STL标准规范中描述的allocator模版类的必要声明：
1 <strong>Constructors</strong> 2 // Constructors used to create allocator objects. 3 allocator(); // Default constructor 4 allocator(const allocator<Type>& _Right); // Copy constructor 5 template<class Other> // Template copy constructor 6 allocator(const allocator<Other>& _Right); 7 8 <strong>Typedefs</strong> 9 const_pointer // A type that provides a constant pointer to the type of object managed by the allocator. 10 const_reference // A type that provides a constant reference to type of object managed by the allocator. 11 difference_type // A signed integral type that can represent the difference between values of pointers to the type of object managed by the allocator. 12 pointer // A type that provides a pointer to the type of object managed by the allocator. 13 reference // A type that provides a reference to the type of object managed by the allocator. 14 size_type // An unsigned integral type that can represent the length of any sequence that an object of template class allocator can allocate. 15 value_type // A type that is managed by the allocator. 16 17 <strong>Member Functions</strong> 18 // Finds the address of an object whose value is specified. 19 pointer (reference _Val) const; 20 const_pointer (const_reference _Val) const; 21 22 // Allocates a block of memory large enough to store at least some specified number of elements. 23 pointer allocate(size_type _Count, const void* _Hint); 24 25 // Constructs a specific type of object at a specified address that is initialized with a specified value. 26 void construct(pointer _Ptr, const Type& _Val); 27 28 // Frees a specified number of objects from storage beginning at a specified position. 29 void deallocate(pointer _Ptr, size_type _Count); 30 31 // Calls an objects destructor without deallocating the memory where the object was stored. 32 void destroy(pointer _Ptr); 33 34 // Returns the number of elements of type Type that could be allocated by an object of class allocator before the free memory is used up. 35 size_type max_size( ) const; 36 37 // A structure that enables an allocator for objects of one type to allocate storage for objects of another type. 38 template<class _Other> 39 struct rebind { 40 typedef allocator<_Other> other; 41 }; 42 43 <strong>Operators overload</strong> 44 template<class Other> 45 allocator<Type>& operator=(const allocator<Other>& _Right); // Assignment operator 46 47
SGI STL使用的空间配置器
SGI STL底层没有采用上述STL标准规范中的声明，它的配置器与众不同，其名称是alloc而非allocator，而且不接受任何参数。
SGI STL中的每种容器都已经指定其缺省的空间配置器alloc，我们在使用时很少需要自行指定配置器。
SGI STL空间配置器的设计哲学：
- 从堆中申请内存空间
- 考虑多线程状态
- 考虑内存不足时的应变措施
- 考虑过多“小型区块”可能造成的内存碎片问题
SGI STL空间配置器alloc的设计描述：
- 使用双层级配置器
- 第一级配置器(__malloc_alloc_template)直接使用malloc() 和 free()
- 第二级配置器(__default_alloc_template)视情况采用不同策略：当配置区块超过128byte时，视之为“足够大”，便调用第一级配置器；否则，视之为“过小”，为了提高效率（1.减少内存碎片；2.降低额外负担：直接使用malloc()申请内存时，系统会要多分配一些内存（内存头）用来管理所分配的内存空间），采用复杂的内存池（memory pool）技术（见下文详解），不再求助于第一级配置器
- SGI STL为了使配置器的接口能够符合STL的标准规范，提供了一个包装接口simple_alloc：
1 template<class T, class Alloc> 2 class simple_alloc { 3 public: 4 static T *allocate(size_t n) 5 { return 0 == n? 0 : (T*) Alloc::allocate(n * sizeof (T)); } 6 static T *allocate(void) 7 { return (T*) Alloc::allocate(sizeof (T)); } 8 static void deallocate(T *p, size_t n) 9 { if (0 != n) Alloc::deallocate(p, n * sizeof (T)); } 10 static void deallocate(T *p) 11 { Alloc::deallocate(p, sizeof (T)); } 12 };
第一级配置器__malloc_alloc_template源码剖析
1 <span style="font-size:10px;">// 基于malloc()的配置器.通常比第二级配置器（__default_alloc_template）慢. 2 // 通常是线程安全的，并且对存储空间的使用更加高效. 3 #ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG 4 # ifdef __DECLARE_GLOBALS_HERE 5 void (* __malloc_alloc_oom_handler)() = 0; // 内存不足处理函数指针 6 // g++ 2.7.2 does not handle static template data members. 7 # else 8 extern void (* __malloc_alloc_oom_handler)(); 9 # endif 10 #endif 11 12 template <int inst> // 没有模版型别参数，至于非型别参数inst没有用到 13 class __malloc_alloc_template { 14 private: // 用来处理内存不足的情况 15 static void *oom_malloc(size_t); 16 static void *oom_realloc(void *, size_t); 17 #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG 18 static void (* __malloc_alloc_oom_handler)(); 19 #endif 20 21 public: 22 23 static void * allocate(size_t n) 24 { 25 void *result = malloc(n); // 直接调用malloc() 26 if (0 == result) 27 result = oom_malloc(n); // 内存申请失败，调用内存不足处理函数 28 return result; 29 } 30 31 static void deallocate(void *p, size_t /* n */) 32 { 33 free(p); // 直接调用free() 34 } 35 36 static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz) 37 { 38 void * result = realloc(p, new_sz); // 直接使用realloc() 39 if (0 == result) 40 result = oom_realloc(p, new_sz); // 内存申请失败，调用内存不足处理函数 41 return result; 42 } 43 44 // 指定内存不足处理函数句柄 45 static void (* set_malloc_handler(void (*f)()))() 46 { 47 void (* old)() = __malloc_alloc_oom_handler; 48 __malloc_alloc_oom_handler = f; 49 return(old); 50 } 51 52 }; 53 54 #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG 55 template <int inst> 56 void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0; // 初值为0，需client设定 57 #endif 58 59 // 内存不足处理函数：malloc()申请内存失败 60 template <int inst> 61 void * __malloc_alloc_template<inst>::oom_malloc(size_t n) 62 { 63 void (* my_malloc_handler)(); 64 void *result; 65 66 for (;;) { // 不断尝试 67 my_malloc_handler = __malloc_alloc_oom_handler; 68 if (0 == my_malloc_handler) { 69 __THROW_BAD_ALLOC; } // client未设定处理函数，直接抛出异常 70 (*my_malloc_handler)(); // 调用内存不足处理函数 71 result = malloc(n); // 再次尝试申请内存 72 if (result) 73 return(result); // 申请成功 74 } 75 } 76 77 // 内存不足处理函数：realloc()申请内存失败（与oom_malloc()类似） 78 template <int inst> 79 void * __malloc_alloc_template<inst>::oom_realloc(void *p, size_t n) 80 { 81 void (* my_malloc_handler)(); 82 void *result; 83 84 for (;;) { 85 my_malloc_handler = __malloc_alloc_oom_handler; 86 if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; } 87 (*my_malloc_handler)(); 88 result = realloc(p, n); 89 if (result) return(result); 90 } 91 } 92 93 typedef __malloc_alloc_template<0> malloc_alloc; // inst直接被指定为0</span>
总结：
- 第一层配置器比较简单，直接调用相应的C函数
- 并实现出类似C++ new-handler机制，来处理内存不足的情况
第二级配置器__default_alloc_template源码剖析
1 // 多线程搞不懂，故去掉了线程相关代码，留待以后分析 2 template <bool threads, int inst> 3 class __default_alloc_template { 4 5 private: 6 // Really we should use static const int x = N 7 // instead of enum { x = N }, but few compilers accept the former. 8 // 唉，为了兼容性，考虑得太周到了 9 # ifndef __SUNPRO_CC 10 enum {__ALIGN = 8}; 11 enum {__MAX_BYTES = 128}; 12 enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; 13 # endif 14 // 内存对齐：将bytes上调至8的倍数 15 static size_t ROUND_UP(size_t bytes) { 16 return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1)); 17 } 18 __PRIVATE: 19 // free_list的节点构造 20 union obj { 21 union obj * free_list_link; 22 char client_data[1]; /* The client sees this. 这里没搞懂 */ 23 }; 24 private: 25 # ifdef __SUNPRO_CC 26 static obj * __VOLATILE free_list[]; 27 // Specifying a size results in duplicate def for 4.1 28 # else 29 static obj * __VOLATILE free_list[__NFREELISTS]; // free_list数组，16个元素 30 # endif 31 // 根据bytes大小获取free_list的数组下标，从0开始 32 static size_t FREELIST_INDEX(size_t bytes) { 33 return (((bytes) + __ALIGN-1)/__ALIGN - 1); 34 } 35 36 // Returns an object of size n, and optionally adds to size n free list. 37 // 返回一个大小为n的对象，并可能加入大小为n的其它区块到free list中 38 static void *refill(size_t n); 39 40 // Allocates a chunk for nobjs of size "size". nobjs may be reduced 41 // if it is inconvenient to allocate the requested number. 42 // 配置一块空间，可容纳nobjs个大小为"size"的区块 43 // 如果不能配置nobjs个区块，nobjs的大小可能会减少(按引用传递的) 44 static char *chunk_alloc(size_t size, int &nobjs); 45 46 // 内存池状态 47 static char *start_free; // 内存池起始位置。只在chunk_alloc()中变化 48 static char *end_free; // 内存池结束位置。只在chunk_alloc()中变化 49 static size_t heap_size; // 从堆中申请的内存大小 50 51 public: 52 53 /* n must be > 0 */ 54 static void * allocate(size_t n) 55 { 56 obj * __VOLATILE * my_free_list; 57 obj * __RESTRICT result; 58 59 if (n > (size_t) __MAX_BYTES) { 60 return(malloc_alloc::allocate(n)); // n大于128byte，直接调用第一级配置器 61 } 62 my_free_list = free_list + FREELIST_INDEX(n); // 从16个free_list中获取合适的一个 63 result = *my_free_list; 64 if (result == 0) { 65 void *r = refill(ROUND_UP(n)); // 没有可用的free_list，重新填充free_list 66 return r; 67 } 68 // 调整free_list：将已使用的内存区块从free_list中移除 69 *my_free_list = result -> free_list_link; 70 return (result); 71 }; 72 73 /* p may not be 0 */ 74 static void deallocate(void *p, size_t n) 75 { 76 obj *q = (obj *)p; 77 obj * __VOLATILE * my_free_list; 78 79 if (n > (size_t) __MAX_BYTES) { 80 malloc_alloc::deallocate(p, n); // n大于128byte，直接调用第一级配置器 81 return; 82 } 83 my_free_list = free_list + FREELIST_INDEX(n); // 从16个free_list中获取合适的一个 84 // 调整free_list: 将回收内存区块重新添加到free_list中 85 q -> free_list_link = *my_free_list; 86 *my_free_list = q; 87 } 88 89 static void * reallocate(void *p, size_t old_sz, size_t new_sz); 90 91 } ; 92 93 // static数据的定义与初值设定 94 template <bool threads, int inst> 95 char *__default_alloc_template<threads, inst>::start_free = 0; 96 97 template <bool threads, int inst> 98 char *__default_alloc_template<threads, inst>::end_free = 0; 99 100 template <bool threads, int inst> 101 size_t __default_alloc_template<threads, inst>::heap_size = 0; 102 103 template <bool threads, int inst> 104 __default_alloc_template<threads, inst>::obj * __VOLATILE 105 __default_alloc_template<threads, inst> ::free_list[ 106 # ifdef __SUNPRO_CC 107 __NFREELISTS 108 # else 109 __default_alloc_template<threads, inst>::__NFREELISTS 110 # endif 111 ] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; 112 // The 16 zeros are necessary to make version 4.1 of the SunPro 113 // compiler happy. Otherwise it appears to allocate too little 114 // space for the array. 115 116 117 118 /* We allocate memory in large chunks in order to avoid fragmenting */ 119 /* the malloc heap too much. */ 120 /* We assume that size is properly aligned. */ 121 /* We hold the allocation lock. */ 122 // 为了避免堆中有过多的内存碎片，我们每次申请一大块内存空间 123 // 我们假定这个空间大小是内存对齐的 124 template <bool threads, int inst> 125 char* 126 __default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs) 127 { 128 char * result; 129 size_t total_bytes = size * nobjs; 130 size_t bytes_left = end_free - start_free; // 内存池剩余空间大小 131 132 if (bytes_left >= total_bytes) { // 内存池剩余空间完全满足需求量 133 result = start_free; 134 start_free += total_bytes; 135 return(result); 136 } else if (bytes_left >= size) { // 内存池剩余空间满足至少一个区块 137 nobjs = bytes_left/size; // 调整nobjs的值 138 total_bytes = size * nobjs; 139 result = start_free; 140 start_free += total_bytes; 141 return(result); 142 } else { // 内存池剩余空间连一个区块都满足不了 143 // 计算需从堆中申请的内存块大小 144 size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4); 145 146 // 先把内存池剩余空间分配给合适的free_list 147 if (bytes_left > 0) { 148 obj * __VOLATILE * my_free_list = 149 free_list + FREELIST_INDEX(bytes_left); 150 151 ((obj *)start_free) -> free_list_link = *my_free_list; 152 *my_free_list = (obj *)start_free; 153 } 154 155 start_free = (char *)malloc(bytes_to_get); // 从堆中申请内存，补充内存池 156 if (0 == start_free) { // 申请内存失败 157 int i; 158 obj * __VOLATILE * my_free_list, *p; 159 // Try to make do with what we have. That can't 160 // hurt. We do not try smaller requests, since that tends 161 // to result in disaster on multi-process machines. 162 // 先尝试检查我们手上（free_list）拥有的东西。这不会造成伤害。 163 // 我们不打算检查比size更小的区块，因为那在多进程机器上容易导致灾难。 164 for (i = size; i <= __MAX_BYTES; i += __ALIGN) { 165 my_free_list = free_list + FREELIST_INDEX(i); 166 p = *my_free_list; 167 if (0 != p) { // 存在未用区块 168 // 释放该未用区块 169 *my_free_list = p -> free_list_link; 170 start_free = (char *)p; 171 end_free = start_free + i; 172 return(chunk_alloc(size, nobjs)); // 递归调用自己，重新分配 173 // Any leftover piece will eventually make it to the 174 // right free list. 175 // 任何内存池剩余空间终将被编入适当的free list 176 } 177 } 178 179 // 55，山穷水尽了 180 end_free = 0; 181 // 调用第一级配置器，看看内存不足处理函数能不能起作用 182 start_free = (char *)malloc_alloc::allocate(bytes_to_get); 183 // This should either throw an 184 // exception or remedy the situation. Thus we assume it 185 // succeeded. 186 // 要么抛出异常，要么内存不足的情况得以改善，我们假定它成功了 187 } 188 heap_size += bytes_to_get; 189 end_free = start_free + bytes_to_get; 190 return(chunk_alloc(size, nobjs)); // 递归调用自己，重新分配 191 } 192 } 193 194 195 /* Returns an object of size n, and optionally adds to size n free list.*/ 196 /* We assume that n is properly aligned. */ 197 /* We hold the allocation lock. */ 198 // 返回一个大小为n的指针对象，并且有可能会为适当的free list增加节点 199 // 假定n已经适当调整到8的倍数了 200 template <bool threads, int inst> 201 void* __default_alloc_template<threads, inst>::refill(size_t n) 202 { 203 int nobjs = 20; // 缺省取得20个新节点 204 char * chunk = chunk_alloc(n, nobjs); 205 obj * __VOLATILE * my_free_list; 206 obj * result; 207 obj * current_obj, * next_obj; 208 int i; 209 210 if (1 == nobjs) 211 return(chunk); // 只获得一个节点，直接返回 212 // 否则准备调整free list，纳入新节点 213 my_free_list = free_list + FREELIST_INDEX(n); // 找到合适的free list 214 215 /* Build free list in chunk */ 216 // 纳入新节点 217 result = (obj *)chunk; 218 *my_free_list = next_obj = (obj *)(chunk + n); 219 for (i = 1; ; i++) { 220 current_obj = next_obj; 221 next_obj = (obj *)((char *)next_obj + n); 222 if (nobjs - 1 == i) { 223 current_obj -> free_list_link = 0; 224 break; 225 } else { 226 current_obj -> free_list_link = next_obj; 227 } 228 } 229 return(result); 230 } 231 232 template <bool threads, int inst> 233 void* 234 __default_alloc_template<threads, inst>::reallocate(void *p, 235 size_t old_sz, 236 size_t new_sz) 237 { 238 void * result; 239 size_t copy_sz; 240 241 if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) { 242 return(realloc(p, new_sz)); // 疑问：这里怎么不直接调用第一级配置器里面的realloc 243 } 244 if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p); 245 result = allocate(new_sz); 246 copy_sz = new_sz > old_sz? old_sz : new_sz; 247 memcpy(result, p, copy_sz); 248 deallocate(p, old_sz); 249 return(result); 250 } 251 252 typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc; 253 typedef __default_alloc_template<false, 0> single_client_alloc;
总结：
- 第二层配置器的核心就是内存池
- SGI STL的内存池通过free_list数组来管理，数组中包含16个free list，每个free list节点大小依次从8、16、24递增到128byte
- 分配内存时（假定分配大小在128byte内），首先根据分配大小找到合适的free list，如果该free list中没有可用的节点，则调用refill()函数从内存池中取空间给该free list用，然后返回第一个节点的内存空间，并调整该free list
- refill()缺省取20个新节点(区块)，通过调用chunk_alloc()，然后根据取得新节点的实际个数，调整相应的free list（大于1）
- chunk_alloc()内部实现最为复杂，根据内存池剩余空间大小与需求量的关系，分为三种情况，具体看代码，不再赘述
- 顶
- 1
- 踩
