【C++】空间配置器 allocator：原理及底层解析

已于 2023-12-05 17:26:40 修改
阅读量576 收藏 12
点赞数 1
分类专栏： C++ 文章标签： c++ java 数据库
于 2023-10-09 15:40:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67470729/article/details/133698885
版权

文章目录

空间配置器

提到空间配置，难免让人联想到 malloc 系列函数。malloc 可以设定用户自己需要的类型为其开辟空间，而空间配置器是专门为 STL 容器进行空间配置的。

空间配置器 allocator：为各个容器进行高效的空间管理（空间的申请与回收）。

如果我们用 new 自己设计空间管理，容易因为 频繁向系统申请小块内存而造成内存碎片、影响程序运行效率。而 SGI-STL 以 128 作为小块内存与大块内存的分界线，将空间配置器其分为两级结构，一级空间配置器处理大块内存，二级空间配置器处理小块内存。

一级空间配置器

一级空间配置器原理非常简单，直接对 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;

二级空间配置器

二级空间配置器专门负责处理小于 128 字节的小块内存。SGI-STL 采用了 内存池 的技术来提高申请空间的速度以及减少额外空间的浪费，采用 哈希桶 的方式来提高用户获取空间的速度与高效管理。

1. 内存池

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

2. SGI-STL 中二级空间配置器设计 - - 哈希桶

内存池的空间是以哈希桶结构管理的，这里的哈希桶是以 8 字节 的 整数倍 进行设置的， 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍。原因有两个：

  1. 因为用户申请的空间基本都是4的整数倍，其他大小的空间几乎很少用到。

  2. 每个桶下面悬挂一个个的未被分配的空间，他们的首部 4/8 个字节 储存的都是下一块空间的地址（或者 nullptr），而 64 位空间下的地址就是 8 字节。

在这里插入图片描述

小于 128 的小块内存申请和释放，在哈希桶中以头删和头插的方式实现。

3. 二级空间配置器的空间申请

申请空间：

  • 申请空间大于 128 一级 allocator 进行分配
  • 小于 128 去找相应大小的桶，如果下面有悬挂内存，就把第一个给用户
  • 如果桶下没有内存，去找内存池索要（见下），并将第一个内存块返回给用户

在这里插入图片描述

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

填充内存块：

  • 用户申请空间桶下没有空闲空间，于是需要向 内存池申请空间（见下）
  • 一次申请 nobjs(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);
}

向内存池中索要空间：

  • 桶下无可使用空间，向内存池接着索要 nobjs（20） 个 n 字节小块，需要计算内存池剩余空间是否足够给出
  • 如果剩余空间足够，就给出空间
  • 如果剩余空间不够 20 块，就把能分配整数块空间一块一块的先切割出去
    • 不足一块时，将剩余内存挂接到链表中，通过系统堆向内存池中补充内存
    • 如果补充成功正常使用
    • 如果补充失败，从哈希表中找到比请求空间更大的内存块进行补充
      • 如果补充成功正常使用
      • 如果再次补充失败，向一级空间配置器申请补充
        在这里插入图片描述
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));
	}
}

SGI-STL 二级空间配置器之空间回收：

  • 和申请一样，以 128 为分界线
  • 大于 128 交给 一级空间配置器来释放
  • 小与 128 则找到对应的哈希桶，头插 到其中
    在这里插入图片描述
// 函数功能：用户将空间归还给空间配置器
// 参数：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;
}

空间配置器的默认选择

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

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

在 SGI_STL 中该宏没有定义，故，默认情况下 SGI_STL 使用二级空间配置器

空间配置器的再封装：添加了数据类型大小

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

空间配置器对象的构造与析构

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 (p) T1(value);
}
  • 在释放对象时，需要根据对象的类型确定是否调用析构函数（类型萃取）
  • 对象的类型可以通过迭代器萃取到

容器中的 allocator

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

🥰如果本文对你有些帮助，请给个赞或收藏，你的支持是对作者大大莫大的鼓励！！(✿◡‿◡) 欢迎评论留言~~

TTang-sq
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++动态内存分配---allocator类的原理与实现(一)
wutao1530663的博客
03-19 4454
包装标准库函数operator new和delete 实现了简单的allocator类，并与默认allocator类对比
C++: STL内存分配器--allocator
好好学习，天天向上~
12-10 5438
**STL内存分配器--allocator** 一、STL内存分配器二、STL allocator 一、STL内存分配器 分配器(allocator))是C ++标准库的一个组件, 主要用来处理所有给定容器(vector，list，map等)内存的分配和释放。C ++标准库提供了默认使用的通用分配器std::allocator，但开发者可以自定义分配器。 GNU STL除了提供默认分配器，还提供了__pool_alloc、__mt_alloc、array_allocator、malloc_allocat
浅谈C++ allocator内存管理（对比new的局限性）
机器学习
12-23 5909
STL中，对内存管理的alloc的设计，迫使我去学习了allocator类。这里对allocator内存管理做了点笔记留给自己后续查阅。allocator类声明、定义于头文件&amp;amp;amp;amp;amp;lt;memory&amp;amp;amp;amp;amp;gt;中的std命名空间内。所以，应该有以下内容位于文件头部… #include &amp;amp;amp;amp;amp;lt;memory&amp;amp;amp;amp;amp;gt; using
C++的空间分配器allocator
sinat_31608641的博客
07-24 3585
一、背景 在STL中，Memory Allocator 处于最底层的位置，为一切容器提供存储服务，是一切其他组件的基石。对于一般使用 STL 的用户而言，Allocator 是不可见的，如果需要对 STL 进行扩展，如编写自定义的容器，就需要调用 Allocator 的内存分配函数进行空间配置。 ......
C++allocator类
最新发布
2301_80224556的博客
04-05 1000
new有一些灵活性上的局限，其中一方面表现在它将内存分配和对象构造组合在了一起。因为在这种情况下，我们几乎肯定知道对象应有什么值。更重要的是，那些没有默认构造函数的类就不能动态分配数组了。
c++ allocator类
weixin_57165154的博客
04-15 1122
c++
C++内存管理07 GCC std::alloc 运行模式解读
FairLikeSnow的博客
12-22 496
GCC std::alloc 运行模式解读 首先看如下图，这个图是侯捷老师画的，我向他致敬 前面几章我写的内存管理器，一次只能管理一个内存链表。在这里alloc将会管理16种不同的链表。Free_list[16],其中管理关系如下规则： 0-8 1-16 2-24 3-32 … 14-120 15-128 运行模式解释情景1： 首先要声明一点，在这里alloc会自动将用户传入的内存大小和自身设定...
buddy-allocator:嵌入式 C++ 伙伴分配器
06-26
嵌入式 C++ 伙伴分配器 大卫·B·罗宾斯 版权所有 :copyright:2015 David B. Robins。 在修改后的（3 条）BSD 许可下发布。 首次发布 2015-01-23。 概述 这是一个用 C++ (C++11) 编写的用于嵌入式环境的。 它最初...
MemoryAllocator：自定义内存分配器
02-09
内存分配器 基于显式空闲列表的自定义内存分配器 有几种常用的实现自定义内存分配器的方法，例如隐式空闲列表，显式空闲列表，隔离的空闲列表和平衡的二进制搜索树，每种方法各有优缺点。 在这里，我使用显式的空闲...
buddy_allocator:伙伴系统内存分配器
07-09
buddy_allocator buddy system memory allocator from Linux kernel System Storage 两个大小相等且邻接的内存块被称作伙伴。 如果两个伙伴都是空闲的，会将其合并成一个更大的内存块，作为下一层次上某个内存块的...
mmap_allocator:mmap内存的基本分配器
05-16
mmap_allocator mmap内存的基本分配器此时，您可以创建mmap共享内存（create_shared_memory），并使用分配器（mmap_alloc）通过仅传递mmap起始指针和大小来分配任何种类的东西。 使用mmap_free可以释放所有变量。 ...
buddy-allocator:用C ++编写的简单伙伴分配器
05-25
好友分配器 用C ++编写的简单伙伴分配器。
cs371p-allocator:cs371p 的分配器项目
07-14
cs371p-分配器cs371p 的分配器项目
D3D12MemoryAllocator:易于集成Direct3D 12的内存分配库
05-04
该库可以通过提供类似于标准ID3D12Device::CreateCommittedResource功能Allocator::CreateResource来帮助开发人员管理内存分配和资源创建。 在内部： 分配并跟踪更大的内存堆，其中的已使用和未使用范围
hostport-allocator:Kubernetes运营商分配主机端口
05-21
HostPort分配器Kubernetes运营商分配主机端口概述Kubernetes主机端口对于将Pod直接暴露在它们正在运行的节点上非常有用。 但是，在多租户群集上管理分配和限制使用的开销可能很困难。 HostPort Allocator旨在通过像...
C++学习笔记（十） 内存机制与Allocator
justaipanda的专栏
07-26 1万+
C++为我们提供了安全的内存空间申请方式与释放方式，但是new与delete表达式却是把空间的分配回收与对象的构建销毁紧紧的关联在一起。实际上，作为与C语言兼容的语言，C++也为我们提供了更加底层的内存操作方式的。 谈C++就离不开STL，考虑一下vector template void Vector::push_back(const T& t) { // are we out of s
c 语言中内存的动态分配（allocate）和释放（free）
热门推荐
Kodulf的专栏
07-18 1万+
0: C语言的数据结构，通常都是固定大小的，例如：数组有固定的大小 数组的使用一般是静态的，但是也可以动态的修改，方法就是内存的动态的分配 1：动态内存分配 2：动态分配字符串 3：动态分配数组 4：释放内存 1: 内存分配函数（allocate 分配的意思） malloc（manual） 函数，分配内存，但是不对内存进行初始化，
C++ allocator类
ruiyao_369的博客
09-02 117
标准库allocator类定义在头文件memory中 标准库allocator类及其算法 allocator < T > a 定义了一个名为a的allocator的对象，它可以为类型为T的对象分配内存 a.allocate(n) 分配一段原始的，未构造的内存，保存n个类型为T的对象 a.deallocate(p,n) 释放从T*指针p中地址开始的内存，这块内...
c++ std::allocator
08-12
C++中的std::allocator是一个用于动态分配和释放内存的模板类。它是C++标准库中的一部分，位于<memory>头文件中。 std::allocator提供了一种通用的内存分配和释放机制，用于支持STL容器和其他需要动态分配内存的类。它是通过以下两个成员函数来完成内存管理的： 1. allocate：用于分配一块原始的、未初始化的内存空间。 2. deallocate：用于释放先前分配的内存空间。 使用std::allocator的示例代码如下： ```cpp #include <iostream> #include <memory> int main() { std::allocator<int> alloc; int* ptr = alloc.allocate(5); // 分配5个int大小的内存空间 for (int i = 0; i < 5; ++i) { alloc.construct(ptr + i, i); // 在分配的内存上构造对象 } std::cout << "Allocated memory: "; for (int i = 0; i < 5; ++i) { std::cout << *(ptr + i) << " "; // 输出分配的内存中的值 } std::cout << std::endl; for (int i = 0; i < 5; ++i) { alloc.destroy(ptr + i); // 销毁对象 } alloc.deallocate(ptr, 5); // 释放内存空间 return 0; } ``` 在上面的示例中，我们使用std::allocator分配了5个int大小的内存空间，并在该空间上构造了5个对象。然后，我们输出了分配的内存中的值，并在最后释放了内存空间。 这只是std::allocator的基本用法，你可以通过阅读C++标准库的文档来了解更多关于std::allocator的详细信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值