[C++ 系列] 87. 简要剖析SGI-STL空间配置器

其他 2020-03-27 13:43:04 阅读次数: 0

文章目录

1. 什么是空间配置器

空间配置器，顾名思义就是 为各个容器高效的管理空间(空间的申请与回收)的，在默默地工作。虽然在常规使用STL时，可能用不到它，但站在学习研究的角度，学习它的实现原理对我们有一定的帮助。

2. 为什么需要空间配置器

前面在模拟实现 vector、list、map、unordered_map 等容器时，所有需要空间的地方都是通过 new 申请的，虽然代码可以正常运行，但是有以下不足之处：

  • 空间申请与释放需要用户自己管理，容易造成内存泄漏。假如使用一个 list，我们需要对每个节点进行 new，在释放时若没注意少了一个 delete，即造成内存泄漏。这个由程序员水平决定，是可避免的问题
  • 频繁向系统申请小块内存块，容易造成内存碎片。在管理内存时在堆上申请空间，若一直申请离散的小内存，则会影响到连续大内存的申请，这些小内存之间会产生大量的内存碎片
  • 频繁向系统申请小块内存，影响程序运行效率。new 与 delete 开销并不小，若过于频繁则影响程序效率
  • 直接使用 malloc 与 new 进行申请，每块空间前有额外空间浪费。在使用 malloc 与 new 时，会在申请空间前方有一个类似结构的头，这个了解即可。而频繁申请小块内存，这些头就会大量产生，造成额外空间浪费
  • 申请空间失败怎么应对。若为小型的空间基本没法处理，如果申请一片大空间，统一对空间申请失败进行处理相对来讲比较容易
  • 代码结构比较混乱，代码复用率不高
  • 未考虑线程安全问题

因此需要设计一块高效的内存管理机制。

3. SGI-STL空间配置器实现原理

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

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

3.1 一级空间配置器

一级空间配置器原理非常简单，直接对 malloc 与 free 进行了封装，并增加了 C++ 中 set_new_handle 思想，set_new_handle 为系统提供的函数，即进行错误处理，在异常安全有设计。

3.1.1 简单的 set_new_handle 实例

参见代码如下：

#include <iostream>
using namespace std;

void outOfMem()
{
	cerr << "内存申请失败" << endl;
	//throw bad_alloc();
}

int main()
{
	// 参数为 返回值为空参数为空的函数指针
	set_new_handler(outOfMem);
	// 传入0，指没有这个函数指针
	// set_new_handler(0);

	try{
		int *ptest1 = new int[100000000];
		int *ptest2 = new int[100000000];
		int *ptest3 = new int[100000000];
		int *ptest4 = new int[100000000];
		int *ptest5 = new int[100000000];
		int *ptest6 = new int[100000000];
		int *ptest7 = new int[100000000];
		int *ptest8 = new int[100000000];
	}
	catch (bad_alloc &bc)
	{
		cout << "bad alloc error!" << endl;
		cout << bc.what() << endl;
	}

	return 0;
}
3.1.2 模拟实现一级空间配置器

下面是对模拟实现 SGI-STL 一级空间配置器，基本与底层源码相同。已经过详细注释。

参见代码如下：

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)())) ()
	// 参数为void (*)() 返回值也为 void (*)() 无参函数指针
	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)
        {
			// 那么直接抛出bad_alloc异常
			__THROW_BAD_ALLOC; 
        }
        // 如果设置，执行用户提供的空间不足应对措施
		// 一般这个函数会释放一部分内存空间，便于下边的空间申请
        (*my_malloc_handler)();
        // 继续申请空间，可能就会申请成功
        result = malloc(n);
        // 若一直申请失败，这个for循环为死循环
        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);
    }
}
// 将inst传入为0的情况定义为malloc_alloc
typedef __malloc_alloc_template<0> malloc_alloc;

一级空间配置器其实就是对 new 和 delete 的封装，也就是模拟了 new 与 delete 的一种新机制。

直观上理解：一级空间配置器用于大内存分配，也就是重写了 new 和 delete。使用 new 与使用一级空间配置器没什么本质区别，但是当 new 出错时，我们无法对其进行修改，但是可以对一级空间配置器进行修改，它并不是在 new 的基础上进行封装而是把自己封装成 new。

3.2 二级空间配置器

**二级空间配置器专门负责处理小于 128 字节的小块内存。**如何才能提升小块内存的申请与释放的方式呢？

SGI-STL采用了内存池的技术来提高申请空间的速度以及减少额外空间的浪费，采用哈希桶的方式来提高用户获取空间的速度与高效管理。

3.2.1 内存池

内存池就是：先申请一块比较大的内存块已做备用，当需要内存时，直接到内存池中去取，当池中空间不够时，再向内存中去取，当用户不用时，直接还回内存池即可。避免了频繁向系统申请小块内存所造成的效率低、内存碎片以及额外浪费的问题。

内存池在 [C++系列] 39. new定位表达式 中被涉及到，希望能够复看。
在这里插入图片描述
以下几个问题值得思考：

  1. 当用户需要空间时，能否直接从内存池中大块空间中直接截取？为什么？
  • 不允许，造成大量内存碎片
  1. 对用户归还的空间能否直接拼接在大块内存前？
  • 随便拼容易造成内存碎片
  1. 对用户归还的空间如何进行管理？
  • 查看下面源码分析即可
  1. 不断切割会有什么后果？
  • 内存碎片等不良影响
3.2.2 SGI-STL中二级空间配置器设计

SGI-STL 中的二级空间配置器使用了内存池技术，但没有采用链表的方式对用户已经归还的空间进行管理(因为用户申请空间时在查找合适的小块内存时效率比较低)，而是采用了哈希桶的方式进行管理。那是否需要 128 桶个空间来管理用户已经归还的内存块呢？答案是不需要，因为用户申请的空间基本都是 4 的整数倍，其他大小的空间几乎很少用到。因此：SGI-STL 将用户申请的内存块向上对齐到了 8 的整数倍。

在此为什么不是 4 的整数倍呢？

  • 每个桶里都是一个指针，而指针在主流的 64 位操作系统下为 8 字节。而这个指针必须是可读的，在下面分析有具体解释。
    在这里插入图片描述
3.2.3 SGI-STL二级空间配置器之空间申请
  1. 前期的准备

参见代码如下：

// 去掉代码中繁琐的部分
template <int inst>
class __default_alloc_template 
{
private:
	// 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
    enum {__ALIGN = 8};   
	// 大小内存块的分界线	
    enum {__MAX_BYTES = 128};   
	// 采用哈希桶保存小块内存时所需桶的个数
    enum {__NFREELISTS = __MAX_BYTES/__ALIGN};  
    
	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
	static size_t ROUND_UP(size_t bytes)
	{
		// 与上反7保证了低三位是0，所以得到的一定是8的倍数。
		return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1)); 
	}
  
private:
    // 用联合体来维护链表结构
	// 此处为什么没有使用结构体
	// 使用联合体用一份空间保存了两个值，十分巧妙
	union obj 
	{
		// 链表指针（next）
		union obj * free_list_link;
		// 指向自身的指针，数组名相当于指针	
		char client_data[1];   
	};
    
private:
	// 链表数组（哈希桶）
    static obj *  free_list[__NFREELISTS];  
  
    // 哈希函数，根据用户提供字节数找到对应的桶号
    static  size_t FREELIST_INDEX(size_t bytes)
    {
		// 除以8找到对应位置，-1可以得到下标
        return (((bytes) + __ALIGN-1)/__ALIGN - 1); 
    }
    
    // start_free与end_free用来标记内存池中大块内存的起始与末尾位置
    static char *start_free;
    static char *end_free;
    
    // 用来记录该空间配置器已经向系统索要了多少的内存块
    static size_t heap_size;
    
    // ...
} ;
  1. 申请空间
    在这里插入图片描述
    参见代码如下：
// 函数功能：向空间配置器索要空间
// 参数n: 用户所需空间字节数
// 返回值：返回空间的首地址
static void * allocate(size_t n)
{
	// 封装volatile，强制使用底层内存而不使用编译器优化的临时寄存器空间
	// 在此以联合体二级指针进行看待，也就是桶
    obj * __VOLATILE * my_free_list;
	// 这片空间只能使用当前的指针访问，不能被其它访问
	// 将其看待为桶中的某个节点
    obj * __RESTRICT result;

    // 检测用户所需空间是否超过128(即是否为小块内存)
    if (n > (size_t) __MAX_BYTES) 
    {
        // 不是小块内存交由一级空间配置器处理
        return (malloc_alloc::allocate(n));
    }
    
    // 根据用户所需字节找到对应的桶号
	// FREELIST_INDEX(n)得到桶号
    my_free_list = free_list + FREELIST_INDEX(n);
	// 找到桶的链表头
    result = *my_free_list;
	
	// 等价处理
	/*
	int hushnum = FREELIST_INDEX(n); 
	result = free_list[hushnum];
	*/
    
    // 如果该桶中没有内存块时，向该桶中补充空间
    if (result == 0)
    {
        // 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
		// refill直接返回20个ROUND_UP(n)大小的链，挂在桶上
        void *r = refill(ROUND_UP(n));
        return r;
    }
    
	// 哈希桶里的空间均是未被使用过的
	// 若该内存块被使用，则要进行出链
    // 并维护桶中剩余内存块的链式关系
    *my_free_list = result -> free_list_link;
	// free_list[hushnum] = result->next;
    return (result);
};
  1. 填充内存块
    在这里插入图片描述
// 函数功能：向哈希桶中补充空间
// 参数n：小块内存字节数
// 返回值：首个小块内存的首地址
template <int inst>
void* __default_alloc_template<inst>::refill(size_t n)
{
    int nobjs = 20;
	// 一次性向内存池索要20个n字节的小块内存
	// 并且返回第一块内存
    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++)  
    {
		// cur = cur->next
		current_obj = next_obj; 
		// next = next->next;
		next_obj = (obj *)((char *)next_obj + n); 
		// 一旦是最后一块空间了
		if (nobjs - 1 == i)  
		{
			// next置空跳出
			current_obj -> free_list_link = 0; 
			break;
		} 
		else 
		{
			// 如果不是最后一片空间，就将他们挂成链
			current_obj -> free_list_link = next_obj;  
		}
    }
    
    return(result);
}
  1. 向内存池中索要空间
    在这里插入图片描述
    这个是重点也是难点，情况较多，需要仔细研读，代码已经过详细注释。

参见代码如下：

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)
                {
					// head = head->next
                    *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));
    }
}
3.3.4 SGI-STL二级空间配置器之空间回收

在这里插入图片描述
参见代码如下：

// 函数功能：用户将空间归还给空间配置器
// 参数：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;
}

3.4 空间配置器的默认选择

SGI-STL 默认使用一级还是二级空间配置器，通过 USE_MALLOC 宏进行控制：

参见代码如下：

#ifdef __USE_MALLOC
 
typedef malloc_alloc alloc;
typedef malloc_alloc single_client_alloc;
 
#else
   
    // 二级空间配置器定义
 
#endif

在 SGI_STL 中该宏没有定义，因此：默认情况下 SGI_STL 使用二级空间配置器。若对该宏进行定义，那么才会使用一级空间配置器。

3.5 空间配置器的再次封装

在 C++ 中，用户所需空间可能是任意类型的，有单个对象空间，有连续空间，每次让用户自己计算所需空间总大小不是很友好，因此 SGI-STL 将空间配置器重新再封装了一层：

参见代码如下：

template<class T, class Alloc>
class simple_alloc 
{
public:
	// 申请n个T类型对象大小的空间
	// 空间配置器不支持0个空间的分配，但是malloc支持
	static T *allocate(size_t n)
	{ 
		return 0 == n ? 0 : (T*) Alloc::allocate(n * sizeof (T)); 
	}
	
	// 申请一个T类型对象大小的空间
	static T *allocate(void)
	{ 
		return (T*) Alloc::allocate(sizeof (T));
	}
	
	// 释放n个T类型对象大小的空间
	static void deallocate(T *p, size_t n)
	{ 
		if (0 != n) 
			Alloc::deallocate(p, n * sizeof (T));
	}
	
	// 释放一个T类型对象大小的空间
	static void deallocate(T *p)
	{ 
		Alloc::deallocate(p, sizeof (T)); 
	}
};

3.6 对象的构造与释放

我们以上所执行的一切实际上是 operator new 与 operator delete 的操作，而 new 在申请空间上执行构造函数完成对象构造以及 delete 在申请空间上执行析构函数完成对象中资源清理工作均未执行。

一切为了效率考虑，SGI-STL 决定将空间申请释放和对象的构造析构两个过程分离开，因为有些对象的构造不需要调用析构函数，销毁时不需要调用析构函数，将该过程分离开可以提高程序的性能：

参见代码如下：

// 归还空间时，先先调用该函数将对象中资源清理掉
template <class T>
inline void destroy(T* pointer)
{
    pointer->~T();
}
 
// 空间申请好后调用该函数：利用placement-new完成对象的构造
template <class T1, class T2>
inline void construct(T1* p, const T2& value) 
{
	// 利用定位new表达式调用构造函数
	// 其不会申请新的空间，只会在旧有的空间上进行申请
    new (p) T1(value);
}

注意：

  1. 在释放对象时，需要根据对象的类型确定是否调用析构函数(类型萃取)–较难可参考博主博文：[C++系列 64. 模板深层次讨论
  2. 对象的类型可以通过迭代器获萃取到

以上两步在实现时稍微有点复杂，有兴趣可参考STL源码。

4. 与容器结合

下例给出 list 与空间配置器是如何结合的，大家参考可给出vector 的实现。

参见代码如下：

template <class T, class Alloc = alloc>
class list 
{
 // ...
 // 实例化空间配置器
 typedef simple_alloc<list_node, Alloc> list_node_allocator;
 // ...

protected:
link_type get_node()
{
   // 调用空间配置器接口先申请节点的空间
   return list_node_allocator::allocate(); 
}

// 将节点归还给空间配置器
void put_node(link_type p) 
{
   list_node_allocator::deallocate(p);
}

// 创建节点：1. 申请空间  2. 完成节点构造
link_type create_node(const T& x)
{
   link_type p = get_node();
   construct(&p->data, x);
   return p;
}

// 销毁节点： 1. 调用析构函数清理节点中资源  2. 将节点空间归还给空间配置器
void destroy_node(link_type p)
{
	destroy(&p->data);
	put_node(p);
}

// ...
iterator insert(iterator position, const T& x)
{
	link_type tmp = create_node(x);
	tmp->next = position.node;
	tmp->prev = position.node->prev;
	(link_type(position.node->prev))->next = tmp;
	position.node->prev = tmp;
	return tmp;
}

iterator erase(iterator position) 
{
	link_type next_node = link_type(position.node->next);
	link_type prev_node = link_type(position.node->prev);
	prev_node->next = next_node;
	next_node->prev = prev_node;
	destroy_node(position.node);
	return iterator(next_node);
}

 // ...
};

5. 要点总结

以诙谐白话文形式，总结本次学习：

1、用户向空间配置器申请空间

if(要申请的空间是大空间(>128bytes))
{
	使用一级空间配置器
}
else
{
	确认这个待分配空间属于哪个桶。
	if(这个桶里有货)
	{
		直接给货
	}
	else
	{
		先补货（往桶里补充空间）
		再给货
	}
}

2、向桶中补货

用户申请一件货物
if(只给了一件)
{
	直接送到
}
else //给了很多相同的货物，当前客户消费不完
{
	先把第一个送到，剩下的结成链。
}

3、向内存池中索要空间

向总部报告，用户想要鸡腿，我要申请20个鸡腿
if(总部有20个鸡腿)
{
	派送20个鸡腿，结束。
}
else if(总部没有20个鸡腿，但是有若干个)
{
	有几个派送几个，结束。
}
else //总部一个鸡腿都没有
{
	总部向供应商申请鸡腿
	
	我先将杂物清理掉（内存池还剩多少，挂在桶里）
	
	if(总部申请到了鸡腿)
	{
		重新执行用户的需求（从一开始重新执行）
	}
	else
	{
		看看库里还有没有整鸡
		if(有整鸡)
		{
			掰个鸡腿给用户先发了
		}
		else
		{
			启动用户一开始约定的没有鸡腿怎么办的应急预案（调用一级空间配置器，通过set new handle函数榨取空间）
		}
	}
}

4、回收空间

看下垃圾属于大型垃圾还是可回收垃圾
if(大型垃圾)
{
	烧毁
}
else //可回收垃圾
{
	回收到对应的桶里
}

※一级空间配置器不是封装了new，而是封装成了new
※一般STL会优先选择二级空间配置器
Y_puyu
发布了391 篇原创文章 · 获赞 329 · 访问量 8万+
私信 关注

猜你喜欢

转载自blog.csdn.net/yl_puyu/article/details/104943625
今日推荐
富文本编辑器 Quill 2.0 重磅发布，特性、可靠性与开发者体验大幅提升
“开源信徒”周鸿祎开源360智脑大模型
周排行
VS2017编译opensmile具体过程和遇到的问题
PowerEnglish——mini-story3总结
微信小程序 数据库获取字符串 在view中显示换行
Java静态代码块/构造代码块/构造函数/静态变量/成员变量(相关示例)
Keras使用tensorflowjs部署demo
window下用git连接Github
图象的全变分和去噪
LeetCode刷题笔记--119. Pascal's Triangle II
【Linux】进程间通信 - 管道
polyA|ribo-minus|differentiated cell|Genetic heterogeneity
每日归档
更多
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)
2024-04-11(14)
2024-04-10(68)
2024-04-09(5)
2024-04-08(60)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022