STL源码剖析(空间配置器)

 1 class base_alloc {
 2 public:
 3     // 只是对malloc/free的简单封装
 4     static void* allocate(size_t n)
 5     {
 6         void* res = malloc(n);
 7         if (0 == res) res = oom_malloc(n);
 8         return res;
 9     }
10     static void* reallocate(void* p, size_t new_sz)
11     {
12         void* res = realloc(p, new_sz);
13         if (0 == res) res = oom_realloc(p, new_sz);
14         return res;
15     }
16     static void deallocate(void* p)
17     {
18         free(p);
19     }
20     // 用来设置内存不足时的处理函数 该函数参数跟返回值都是一个函数指针
21     // 一般会抛出异常/尝试回收内存
22     static void(*set_handler(void(*f)()))()
23     {
24         void(*old)() = _oom_handler;
25         _oom_handler = f;
26         return old;
27     }
28 private:
29     // 用来处理内存不足的情况
30     static void* oom_malloc(size_t n)
31     {
32         void(*my_handler)();
33         void* res;
34 
35         for (;;)
36         {
37             my_handler = _oom_handler;
38             if (0 == my_handler) { return NULL; }
39             (*my_handler)();
40             if (res = malloc(n)) return res;
41         }
42     }
43     // 用来处理内存不足的情况
44     static void* oom_realloc(void* p, size_t n)
45     {
46         void(*my_handler)();
47         void* res;
48 
49         for (;;)
50         {
51             my_handler = _oom_handler;
52             if (0 == my_handler) { return NULL; }
53             (*my_handler)();
54             if (res = reallocate(p, n)) return res;
55         }
56     }
57     // 由用户设置，在内存不足的时候进行处理，由上面两个函数调用
58     static void(*_oom_handler)();
59 };
60 
61 // 处理函数默认为0 
62 void(*base_alloc::_oom_handler)() = 0;

  1 enum { _ALIGN = 8 };    // 对齐
  2 enum { _MAX_BYTES = 128 }; // 区块大小上限
  3 enum { _NFREELISTS = _MAX_BYTES / _ALIGN }; // free-list个数
  4 
  5 class default_alloc {
  6 private:
  7     // 将bytes上调到8的倍数
  8     static size_t ROUND_UP(size_t bytes)
  9     {
 10         return (bytes + _ALIGN - 1) & ~(_ALIGN - 1);
 11     }
 12 private:
 13     union obj {
 14         union obj* free_list_link;
 15         char client_data[1];
 16     };
 17 private:
 18     // 16个free-lists 各自管理分别为8,16,24...的小额区块
 19     static obj* free_list[_NFREELISTS];
 20     // 根据区块大小，决定使用第n号free-list
 21     static size_t FREELIST_INDEX(size_t bytes)
 22     {
 23         return (bytes + _ALIGN - 1) / _ALIGN - 1;
 24     }
 25     // 分配内存，返回一个大小为n的区块，可能将大小为n的其他区块加入到free_list
 26     static void* refill(size_t n)
 27     {
 28         // 默认分配20个区块
 29         int nobjs = 20;
 30         char* chunk = chunk_alloc(n, nobjs);
 31         obj** my_free_list;
 32         obj* result, *current_obj, *next_obj;
 33 
 34         // 如果只分配了一个区块，直接返回
 35         if (1 == nobjs) return chunk;
 36         // 否则将其他区块插入到free list
 37         my_free_list = free_list + FREELIST_INDEX(n);
 38         result = (obj*)chunk;
 39         // 第一个区块返回 后面的区块插入到free list
 40         *my_free_list = next_obj = (obj*)(chunk + n);
 41         for (int i = 1;; ++i)
 42         {
 43             current_obj = next_obj;
 44             next_obj = (obj*)((char*)next_obj + n);
 45             // 最后一个next的free_list_link为0
 46             if (nobjs - 1 == i)
 47             {
 48                 current_obj->free_list_link = 0;
 49                 break;
 50             }
 51             current_obj->free_list_link = next_obj;
 52         }
 53         return result;
 54     }
 55     // 分配内存
 56     // 在内存池容量足够时，只调整start_free跟end_free指针
 57     // 在内存池容量不足时，调用malloc分配内存(2 * size * nobjs +  ROUND_UP(heap_size >> 4)，每次调整heap_size += 本次分配内存的大小) 
 58     static char* chunk_alloc(size_t size, int& nobjs);
 59 
 60     static char* start_free; //内存池的起始位置
 61     static char* end_free;     //内存池的结束位置
 62     static size_t heap_size;         //分配内存时的附加量
 63 public:
 64     static void* allocate(size_t n)
 65     {
 66         obj** my_free_list;
 67         obj* result;
 68         // 大于128就调用第一级空间配置器
 69         if (n > (size_t)_MAX_BYTES)
 70             return base_alloc::allocate(n);
 71 
 72         // 寻找适当的free-list
 73         my_free_list = free_list + FREELIST_INDEX(n);
 74         result = *my_free_list;
 75         // 没有可用的free list
 76         if (result == 0)
 77             return refill(ROUND_UP(n));
 78 
 79         // 调整free list 移除free list
 80         *my_free_list = result->free_list_link;
 81         return result;
 82     }
 83     static void deallocate(void* p, size_t n)
 84     {
 85         obj* q = (obj*)p;
 86         obj** my_free_list;
 87 
 88         // 大于128就调用第一级空间配置器
 89         if (n > (size_t)_MAX_BYTES)
 90         {
 91             base_alloc::deallocate(p);
 92             return;
 93         }
 94 
 95         // 寻找对应的free list
 96         my_free_list = free_list + FREELIST_INDEX(n);
 97         // 调整free list 回收区块(将区块插入到my_free_list)
 98         q->free_list_link = *my_free_list;
 99         *my_free_list = q;
100     }
101     static void reallocate(void* p, size_t old_sz, size_t new_sz);
102 };
103 
104 char* default_alloc::start_free = 0;
105 char* default_alloc::end_free = 0;
106 size_t default_alloc::heap_size = 0;
107 default_alloc::obj* default_alloc::free_list[_NFREELISTS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };