天天看点
返回

Cpp || 空间配置器

文章目录

      • 空间配置器
        • 一:需要空间配置器的原因
        • 二:SGI-STL空间配置器实现原理
        • 三:一级空间配置器
        • 四:二级空间配置器
          • 4.1:内存池
          • 4.2:SGI-STL中二级空间配置器设计
          • 4.3:申请空间
          • 4.4:填充内存块
          • 4.5:向内存池中索要空间
          • 4.6:SGI-STL二级空间配置器之空间回收

空间配置器

  • 用途:空间配置器:为了各个容器高效的管理空间(空间的申请与回收)的,

一:需要空间配置器的原因

  • 前面在模拟实现vector、list、map、unordered_map等容器时,所需要的空间都是通过new申请的,虽然代码可以正常运行,但是存在以下问题
  • 1.空间申请与释放需要用户自己管理,容易造成内存泄漏
  • 2.频繁向系统申请小块内存,影响程序运行效率
  • 3.频繁向系统申请小块内存,容易造成内存泄漏
  • 4.直接使用malloc与new进行申请,每块空间有额外空间浪费
  • 5.申请空间失败怎么应对?
  • 6.代码结构比较混乱
  • 7.未考虑线程安全问题

因此需要设计一块高效的内存管理机制–>空间配置器

二:SGI-STL空间配置器实现原理

以上提到的几点不足之处，最主要还是：频繁向系统申请小块内存造成的。那什么才算是小块内存？SGI-STL

以128作为小块内存与大块内存的分界线，将空间配置器其分为两级结构，一级空间配置器处理大块内存，二级空间配置器处理小块内存。

三:一级空间配置器

  • 一级空间配置器原理非常简单，直接对malloc与free进行了封装，并增加了C++中set_new_handle思想。
  • 其中C++ new_handler机制是,你可以要求系统在内存配置需求无法满足时,调用一个你所指定的函数,换句话说:一旦 ::operator new 无法完成任务,在丢出std::bad_alloc异常状态之前,会调用由客户端指定的处理例程,该处理例程通常既被称为new_handler。new_handler解决了内存不足的做法有特定的模式,请参考《Effective C++》2e条款7 
template <int inst>
class __malloc_alloc_template
{
private:
static void *oom_malloc(size_t);
static void *oom_realloc(void *, size_t);
public:
 // 对malloc的封装
static void * allocate(size_t n) {
 // 申请空间成功，直接返回，失败交由oom_malloc处理
 void *result = malloc(n);
 if (0 == result) 
 result = oom_malloc(n);
 
 return result; }
 // 对free的封装
static void deallocate(void *p, size_t /* n */) {
 free(p);
}
 // 对realloc的封装---该函数基本不用
static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz) {
 void * result = realloc(p, new_sz);
 if (0 == result) 
 result = oom_realloc(p, new_sz);
 return result; }
// 模拟set_new_handle
// 该函数的参数为函数指针，返回值类型也为函数指针
// void (* set_malloc_handler( void (*f)() ) )()
static void (* set_malloc_handler(void (*f)()))()
{
 void (* old)() = __malloc_alloc_oom_handler;
 __malloc_alloc_oom_handler = f;
 return(old);
}
};
// malloc申请空间失败时代用该函数
template <int inst>
void * __malloc_alloc_template<inst>::oom_malloc(size_t n) {
 void (* my_malloc_handler)();
 void *result;
 for (;;) 
 {
 // 检测用户是否设置空间不足应对措施，如果没有设置，抛异常，模式new的方式
 my_malloc_handler = __malloc_alloc_oom_handler;
 if (0 == my_malloc_handler)
 {
 __THROW_BAD_ALLOC; 
 }
 
 // 如果设置，执行用户提供的空间不足应对措施
 (*my_malloc_handler)();
 
 // 继续申请空间，可能就会申请成功
 result = malloc(n);
 
 if (result)
 return(result);
 }
}
// 类似oom_malloc
template <int inst>
void * __malloc_alloc_template<inst>::oom_realloc(void *p, size_t n) {
 void (* my_malloc_handler)();
 void *result;
 for (;;) 
 {
 my_malloc_handler = __malloc_alloc_oom_handler;
 if (0 == my_malloc_handler)
 {
 __THROW_BAD_ALLOC; 
 }
 
 (*my_malloc_handler)();
 result = realloc(p, n);
 
 if (result) 
 return(result);
 }
}
typedef __malloc_alloc_template<0> malloc_alloc;

四:二级空间配置器

  • 二级空间配置器专门负责处理小于128字节的小块内存。如何才能提升小块内存的申请与释放的方式呢？SGI-STL采用了内存池的技术来提高申请空间的速度以及减少额外空间的浪费，采用哈希桶的方式来提高用户获取空间的速度与高效管理。
  • 第二层配置器的核心就是内存池
  • SGI-STL的内存池通过free_list数组来管理,数组中包含16个free list,每个free list结点大小依次为8,16,24以8的倍数递增到128byte
  • 分配内存时(假定分配大小在128byte内),首先根据分配大小找到合适的free list, 如果该free list中没有可用的结点,则调用refill()函数从内存池中取空间给该free list 用,然后返回第一个结点的内存空间,并调整该free list;
  • refill缺省取20个新节点(区块),通过调用chunk_alloc(),然后根据所取的新结点的实际个数,调用相应的free list(大于1)
4.1:内存池
  • 内存池:先申请一块比较大的内存块做备用,当需要使用内存时,直接到内存池中去取,当池中空间不够时,再向内存中去取,当用户不用时,直接还回内存池即可.避免频繁的向系统申请小块内存所造成的效率低,内存碎片以及额外浪费的问题
    Cpp || 空间配置器
  • 类似与vector,使用指针来标识内存池的起始位置和结束位置(有效空间包含在其中)
4.2:SGI-STL中二级空间配置器设计
  • SGI-STL中的二级空间配置器使用了内存池技术，但没有采用链表的方式对用户已经归还的空间进行管理(因为用户申请空间时在查找合适的小块内存时效率比较低)，而是采用了哈希桶的方式进行管理。那是否需要128桶个空间来管理用户已经归还的内存块呢？
  • 答案是不需要，因为用户申请的空间基本都是4的整数倍，其他大小的空间几乎很少用到。因此：SGI-STL将用户申请的内存块向上对齐到了8的整数倍
Cpp || 空间配置器
4.3:申请空间
  • 过程图示
    Cpp || 空间配置器
// 函数功能：向空间配置器索要空间
// 参数n: 用户所需空间字节数
// 返回值：返回空间的首地址
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));
 }
 
 // 根据用户所需字节找到对应的桶号
 my_free_list = free_list + FREELIST_INDEX(n);
 result = *my_free_list;
 
 // 如果该桶中没有内存块时，向该桶中补充空间
 if (result == 0)
 {
 // 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
 void *r = refill(ROUND_UP(n));
 return r;
 }
 
 // 维护桶中剩余内存块的链式关系
 *my_free_list = result -> free_list_link;
 return (result);
};
4.4:填充内存块
  • 过程图
Cpp || 空间配置器
// 函数功能：向哈希桶中补充空间
// 参数n：小块内存字节数
// 返回值：首个小块内存的首地址
template <int inst>
void* __default_alloc_template<inst>::refill(size_t n) {
 // 一次性向内存池索要20个n字节的小块内存
 int nobjs = 20;
 char * chunk = chunk_alloc(n, nobjs);
 
 obj ** 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);
 for (i = 1; ; i++) 
 {
 current_obj = next_obj;
 next_obj = (obj *)((char *)next_obj + n);
 if (nobjs - 1 == i) 
 {
 current_obj -> free_list_link = 0;
 break;
 } 
 else
 {
 current_obj -> free_list_link = next_obj;
 }
 }
 return(result);
}
4.5:向内存池中索要空间
  • 过程图示
Cpp || 空间配置器
template <int inst>
char* __default_alloc_template<inst>::chunk_alloc(size_t size, int& nobjs) {
 // 计算nobjs个size字节内存块的总大小以及内存池中剩余空间总大小
 char * result;
 size_t total_bytes = size * nobjs;
 size_t bytes_left = end_free - start_free;
 // 如果内存池可以提供total_bytes字节，返回
 if (bytes_left >= total_bytes) 
 {
 result = start_free;
 start_free += total_bytes;
 return(result);
 } 
 else if (bytes_left >= size)
 {
 // nobjs块无法提供，但是至少可以提供1块size字节内存块，提供后返回
 nobjs = bytes_left/size;
 total_bytes = size * nobjs;
 result = start_free;
 start_free += total_bytes;
 return(result);
 } 
 else
 {
 // 内存池空间不足，连一块小块村内都不能提供
 // 向系统堆求助，往内存池中补充空间
 // 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
 size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
 
 // 如果内存池有剩余空间(该空间一定是8的整数倍)，将该空间挂到对应哈希桶中
 if (bytes_left > 0) 
 {
 // 找对用哈希桶，将剩余空间挂在其上
 obj ** my_free_list = free_list + FREELIST_INDEX(bytes_left);
 ((obj *)start_free) -> free_list_link = *my_free_list;
 *my_ree_list = (obj *)start_free;
 }
 
 // 通过系统堆向内存池补充空间，如果补充成功，递归继续分配
 start_free = (char *)malloc(bytes_to_get);
 if (0 == start_free) 
 {
 // 通过系统堆补充空间失败，在哈希桶中找是否有没有使用的较大的内存块
 int i;
 obj ** my_free_list, *p;
 for (i = size; i <= __MAX_BYTES; i += __ALIGN)
 {
 my_free_list = free_list + FREELIST_INDEX(i);
 p = *my_free_list;
 
 // 如果有，将该内存块补充进内存池，递归继续分配
 if (0 != p)
 {
 *my_free_list = p -> free_list_link;
 start_free = (char *)p;
 end_free = start_free + i;
 return(chunk_alloc(size, nobjs));
 }
 }
 
 // 山穷水尽，只能向一级空间配置器求助
 // 注意：此处一定要将end_free置空，因为一级空间配置器一旦抛异常就会出问题
 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));
 }
}
4.6:SGI-STL二级空间配置器之空间回收
  • 过程图示
Cpp || 空间配置器
// 函数功能：用户将空间归还给空间配置器
// 参数：p空间首地址 n空间总大小
static void deallocate(void *p, size_t n) {
 obj *q = (obj *)p;
 obj ** my_free_list;
 // 如果空间不是小块内存，交给一级空间配置器回收
 if (n > (size_t) __MAX_BYTES)
 {
 malloc_alloc::deallocate(p, n);
 return;
 }
 
 // 找到对应的哈希桶，将内存挂在哈希桶中
 my_free_list = free_list + FREELIST_INDEX(n);
 q -> free_list_link = *my_free_list;
 *my_free_list = q; }
Cpp进阶学习
上一篇: mac下flink集群安装
下一篇: G Data （歌德塔）