40 空间配置器（补充）

且听吟风°

已于 2024-07-10 23:21:49 修改

阅读量885

点赞数 28

分类专栏： 03 深入理解 c++ 文章标签： windows 开发语言 c++ STL

于 2024-07-10 10:14:53 首次发布

本文链接：https://blog.csdn.net/qq_43422358/article/details/140310152

版权

03 深入理解 c++ 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

1. 什么是空间配置器

空间配置器，顾名思义就是为各个容器高效的管理空间（空间的申请与回收的），在默默的工作。虽然在常规使用STL时，可能用不到它，但原理可以了解一下有很大的帮助

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

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

空间申请与释放需要自己管理，容易造成内存泄露
频繁向系统申请小块内存，容易造成内存碎片
频繁向系统申请小块内存，影响程序运行效率
直接使用malloc和new申请，每块空间都有额外浪费
申请空间失败怎么应对
代码结构混乱，复用率不高
未考虑线程安全问题

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

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

最主要的不足韩式频繁向系统申请小块内存造成的，什么才算小块内存。SGI-STL以128作为分界线，用两级结构，一级空间配置器处理大块内存，二级处理小块内存

3.1 一级空间配置器

一级空间配置器原理非常简单，直接对malloc与free封装，并增加了c++set_new_handle思想

template <int inst>
class __malloc_alloc_template
{
private:
	static void* oom_malloc(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);
	}
	// 模拟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);
	}
}
typedef __malloc_alloc_template<0> malloc_alloc;

3.2 二级空间配置器

二级空间配置器专门处理小于128字节的小块内存。如何才能提升小块内存的申请和释放？采用了内存池的技术来提高速度和减少浪费，采用哈希桶的方式来管理

3.2.1 内存池

先申请一块比较大的内存做备用，需要内存到内存池找，内存池不够再向内存中获取，用户不用了还给内存池，避免了频繁向系统申请小块内存
在这里插入图片描述

请大家思考：
1.当用户需要空间时，能否直接从内存池大块空间直接获取？为什么？
2.对用户归还的空间能否直接拼接在大块内存前？
3.对用户归还的空间如何进行管理？
4.不断切割会有什么后果？

3.2.2 二级空间配置器设计

采用内存池技术，但没有采用链表的表示对用户归还的空间管理（因为用户申请空间时查找合适的小块内存效率低），而是采用哈希桶的方式进行管理。不需要128个桶空间管理，因为用户申请的空间基本是4的整数倍，其他大小的空间几乎很少用到。因此，stl将申请的内存块对齐到了8的整数倍（为什么是8，不是4？）

在这里插入图片描述

3.2.3 二级空间配置器空间申请

1.前期准备

// 去掉代码中繁琐的部分
template <int inst>
class __default_alloc_template
{
private:
	enum { __ALIGN = 8 };
	// 如果用户所需内存不是8的整数倍，向上对齐到8的整数
	//倍
		enum { __MAX_BYTES = 128 };
	// 大小内存块的分界线
	enum { __NFREELISTS = __MAX_BYTES / __ALIGN };  // 采用哈希桶保存小块内存时
	//所需桶的个数
		// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
		static size_t ROUND_UP(size_t bytes)
	{
		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
	}
private:
	// 用联合体来维护链表结构----同学们可以思考下此处为什么没有使用结构体
	union obj
	{
		union obj* free_list_link;
		char client_data[1];
	};
private:
	static obj* free_list[__NFREELISTS];
	/* The client sees this.        */
	 // 哈希函数，根据用户提供字节数找到对应的桶号
	static  size_t FREELIST_INDEX(size_t bytes)
	{
		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
	}
	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
	static char* start_free;
	static char* end_free;
	// 用来记录该空间配置器已经想系统索要了多少的内存块
	static size_t heap_size;
	// ...
};

2.申请空间
在这里插入图片描述
实际顺序是用户申请字节数，直接走二级空间配置器，在二级里判断是大块还是小块内存

	// 函数功能：向空间配置器索要空间
// 参数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);
	};

3.填充内存块
用户申请了内存，配置器内存池在向内存申请空间并不是按用户给的大小，会多申请一部分做备用，这里是20个
在这里插入图片描述

	// 函数功能：向哈希桶中补充空间
// 参数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.向内存池索要空间
在这里插入图片描述

	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置空，因为一级空间配置器一旦抛异常就会出
				//问题
			}
		}
	}

3.2.4 空间回收

在这里插入图片描述

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

内碎片和外碎片
内存碎片，假设要的是20byte，给24byte，有4byte是用不上，这次就白白浪费了，就是内碎片
外碎片，假设开始申请1000次8byte，200次24byte，10008+20024。现在要一个128byte，前面的内存用不上。
stl的空间配置器没有解决这个问题，更优的内存池会考虑缓解这个问题，解决这个问题得合并，但不好处理，得找到连续的才能合

<128释放回来的内存挂到桶上，什么时候还给系统。不能超过限度还，因为申请的时候时大块内存，小内存是切出来的，不支持分开还，也不知道切出来的内存挂在哪个桶，要释放需要全部从桶里删除。也没想过要还，进程结束时会还给系统

stl的空间配置器是有缺陷的，外碎片和空间释放都没有解决，但这个效率比malloc高的

3.3 空间配置器的默认选择

默认使用一级还是二级，通过USE-MALLOC宏控制

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

源码中该宏没有定义，默认使用二级配置器

3.4 再次封装

c++中，用户所需空间可能是任意类型的，有单个对象空间，连续空间，每次让用户自己计算所需空间不是很友好，因此再封装了一层

// T: 元素类型
// Alloc: 空间配置器
// 注意：该类只负责申请与归还对象的空间，不负责空间中对象的构造与析构
template<class T, class Alloc>
class simple_alloc
{
public:
	// 申请n个T类型对象大小的空间
	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.5 对象的构造和析构

为了效率，将两个过程分开，有些对象构造不需要析构函数，销毁不需要析构函数，该过程分开提高性能

// 归还空间时，先先调用该函数将对象中资源清理掉
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 (p) T1(value);
}

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);
	}
	// ...
};