STL：空间配置器 —— 第二级配置器：__default_alloc_template | 自实现reallocate()

置顶 已于 2022-05-03 19:20:22 修改
阅读量1k 收藏 4
点赞数 3
分类专栏： # C++ # C++ STL 文章标签： c++ 开发语言 c语言 链表
于 2022-05-02 23:06:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56257585/article/details/124528999
版权
C++ 同时被 2 个专栏收录
48 篇文章 5 订阅
订阅专栏
C++ STL
12 篇文章 1 订阅
订阅专栏

前言

这一系列文章都是对STL的讲解，本文接着上篇第一级配置器，来讲解第二级配置器。第二级配置器是空间配置器的重点内容，也是相当麻烦的一部分内容。本文除了对《STL源码剖析》书中内容的讲解外，还自实现了 reallocate()函数，可以说相当不易，提前感谢大家的收看。
在这里插入图片描述

文章目录

一、一二级空间配置器的关系

  1. SGI STL 一级配置器
template<int inst>
class __malloc_alloc_template {};

其中，allocate()直接使用 malloc(), deallocate()直接使用 free()。
模拟C++的 set_new_handler()以处理内存不足问题。

  1. SGI STL 二级配置器
template<bo0l threads, int inst>
class __default_alloc_template {};

其中:
2.1 维护16个自由链表( free lists ) ，负责16种小型区块的次配置能力。

内存池（memory pool) 以malloc() 配置而得。如果内存不足，转调用第一
级配置器(那儿有处理程序)。

2.2 如果需求区块大于128 bytes，就转调用第一级配置器。

二、一二级配置器的接口和运用方式

在这里插入图片描述

三、二级配置器——__default_alloc_template

第二级配置器多了一些机制，避免太多小额区块道成内存的碎片。小额区块带来的其实不仅是内存碎片，配置时的额外负担也是大问题。
额外负担永远无法避免，毕竟系统要靠这多出来的空间来管理内存。
但是区块愈小，额外负担所占的比例就愈大，愈显得浪费。

1.什么是小额区块

小额区块怎么理解？

在C程序向堆区使用malloc()申请空间时，除了指定获得的字节个数，还需要向系统申请越界位置。

示例：

#include<malloc.h>

int main(void)
{
	int* p = (int*)malloc(sizeof(int));

	free(p);
	p = NULL;

	return 0;
}

通过内存和监视器可以看出，这个申请的空间还有上越界和下越界标记，那么如果这种小额空间申请的次数越多，标记信息也越多，显得越浪费。
在这里插入图片描述

2. 维护自由链表

SGI 第二级配置器的做法是，如果区块够大，超过128 bytes时，就移交第一级配置器处理。 当区块小于128 bytes时，则以内存池（ memory pool）管理，此法又称为次层配置（ sub-allocation)：每次配置一大块内存，并维护对应之自由链表(free-list )。下次若再有相同大小的内存需求，就直接从free-lists中拨出。如果客端释还小额区块，就由配置器回收到free-lists中 —— 是的，别忘了，配置器除了负责配置，也负责回收。为了方便管理，SGl 第二级配置器会主动将任何小额区块的内存需求量上调至8的倍数（例如客端要求30 bytes，就自动调整为32 bytes) ,并维护16个 free-lists，各自管理大小分别为8,16, 24,32,40,48,56,64,72,80,88,96,104,112,120,128 bytes的小额区块。free-lists的节点结构如下:

代码

这里的 free_list_link也可以理解为链表节点的next域

enum { __ALIGN = 8 };	// 小型区块的上调边界
enum { __MAX_BYTES = 128 };	// 小型区块的上限
enum { __NFREELISTS = __MAX_BYTES / __ALIGN };	// free_lists个数

private:
	union obj
	{
		union obj* free_list_link;	// next;
		char client_data[1];
	};
	// 一个指针数组，自由链表
	static obj* volatile free_list[__NFREELISTS];

图示

那么该自由链表可以看作这样：

在这里插入图片描述

辅助函数ROUND_UP() / FREELIST_INDEX()

// 将bytes上调至8的倍数
static size_t ROUND_UP(size_t bytes) // 1~8 / 9~16...
{
	return (bytes + __ALIGN - 1) & ~(__ALIGN - 1);
}
// 根据区块大小，决定使用第n个free_list
static size_t FREELIST_INDEX(size_t bytes)
{
	return (bytes + __ALIGN - 1) / __ALIGN - 1;
}

3. 空间配置函数allocate()

此函数首先判断区块大小，大于128 bytes就调用第一级配置器，小于128 bytes就检查对应的free_list。如果 free_list 之内有可用的区块，就直接拿来用，如果没有可用区块，就将区块大小上调至8倍数边界，然后调用refill () ,准备为free list重新填充空间。refill()将于稍后介绍。

代码

public:
	static void* allocate(size_t size)
	{
		// 如果大于128bytes，交给第一级配置器
		if (size > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::allocate(size);
		}
		
		obj* result = nullptr;
		obj* volatile* my_free_list = nullptr;
		my_free_list = free_list + FREELIST_INDEX(size);
		result = *my_free_list;
		if (nullptr == result)
		{
			void* r = refill(ROUND_UP(size));
			return r;
		}
		*my_free_list = result->free_list_link;
		return result;
	}

分析：假设size的大小为20.

  1. 如果申请的空间大于128字节，就交给第一级配置器。
  2. 声明一个结点类型的返回值result和一个二级指针my_free_list供后面使用。
  3. 根据size的大小计算出应该从free_list的哪个节点上去取空间。（free_list表示自由链表的首地址，size为20，那么就应该在17~24范围内的结点，即第三个结点(free_list + 2) 上去取空间。)
  4. 那么二级指针my_free_list指向需要去取空间的那个结点。
  5. 通过一级指针result取得二级指针的第一个结点，即第一个24字节的内存块的地址。
  6. 如果有内存块，就将其取出来，并将二级指针my_free_list（解引用后）指向result的next域（result->free_list_link）。
  7. 如果该结点没有内存块了，就需要交给填充函数refill()来实现，稍后会说到。
    在这里插入图片描述

4. 空间释放函数deallocate()

和allocate()相反，allocate()是链表的头删法，此函数相当于头插法。

该函数首先判断区块大小，大于128 bytes就调用第一级配置器，小于128 bytes就找出对应的free_list，将区块回收。这里就不多解释。

public:
	static void deallocate(void* p, size_t n)
	{
		if (n > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::deallocate(p, n);
		}

		obj* q = (obj*)p;
		obj* volatile* my_free_list = nullptr;
		// 寻找相应的free_list
		my_free_list = free_list + FREELIST_INDEX(n);
		// 头插法，回收区块
		q->free_list_link = *my_free_list;
		*my_free_list = q;
	}

图示：
在这里插入图片描述

5. 内存池

一个从堆区申请的空间，heap_size表示该空间总大小；
start_free表示内存池起始位置，end_free表示内存池结束位置。

private:
	static char* start_free;
	static char* end_free;
	static size_t heap_size; // total
	
	// 配置一大块空间，可以容纳nobjs个size大小的区块
	// 如果配置nobjs个区块有所不便，nobjs会做出相应改变
	static char* chunk_alloc(size_t size, int& nobjs);
	
	// 返回一个大小为size的对象，
	// 并可能加入大小为size的其他区块到free_list中
	static void* refill(size_t size);

简图：

在这里插入图片描述

chunk_alloc()

该函数的工作是，从内存池中取出空间供给free_list使用

private:
	// 配置一大块空间，可以容纳nobjs个size大小的区块
	// 如果配置nobjs个区块有所不便，nobjs会做出相应改变
	static char* chunk_alloc(size_t size, int& nobjs)
	{
		char* result = nullptr;
		// 需要空间的总大小
		size_t total_bytes = size * nobjs;
		// 内存池剩余空间
		size_t bytes_left = end_free - start_free;	// 1

		// 如果内存池剩余空间满足需要空间
		if (bytes_left >= total_bytes)	// 2
		{
			result = start_free;
			start_free = start_free + total_bytes;
			return result;
		}
		else if (bytes_left >= size)	// 3
		{
			// 如果剩余空间只够1个以上的块（但小于总需求）
			nobjs = bytes_left / size;
			result = start_free;
			start_free = start_free + total_bytes;
			return result;
		}
		else
		{
			// 如果连一块空间都不够		// 4
			size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
			
			// 将剩下的一点点空间再利用
			if (bytes_left > 0)			// 5
			{
				// 将剩余空间配置给合适的free_list
				obj* volatile* my_free_list = free_list + FREELIST_INDEX(bytes_left);
				((obj*)start_free)->free_list_link = *my_free_list;
				*my_free_list = (obj*)start_free;
			}

			// 配置heap空间，补充内存池
			start_free = (char*)malloc(bytes_to_get);	// 6
			if (nullptr == start_free)				// 7
			{
				obj* volatile* my_free_list = nullptr;
				obj* p = nullptr;
				for (int i = size; i <= __MAX_BYTES; i += __ALIGN)
				{
					my_free_list = free_list + FREELIST_INDEX(i);
					p = *my_free_list;
					if (nullptr != p)
					{
						*my_free_list = p->free_list_link;
						start_free = (char*)p;
						end_free = start_free + i;
						return chunk_alloc(size, nobjs);
					}
				}
				end_free = 0;		// 8
				start_free = (char*)malloc_alloc::allocate(bytes_to_get);
			}

			// 修正内存池的结束位置和总大小	// 9
			end_free = start_free + bytes_to_get;
			heap_size += bytes_to_get;
			// 递归调用自己，修正nobjs
			return chunk_alloc(size, nobjs);
		}
	}

解析

根据代码中的数字来看

该函数的参数：size表示区块的大小（8的倍数），nobjs表示需要多少块（注意这里是引用）。

  1. 声明返回值、所需要空间总大小、内存池剩余容量并计算出来。
  2. 如果容量足够，就将返回值指向start_free，并将start_free下移（移到减去total_bytes的位置），返回result。
  3. 如果容量不足所需要的，但是够一个以上的区块，就将nobjs修正，只返回当前所能提供的块数，然后和第二步一样。
  4. 如果连一个区块也无法提供：先声明一个将要向堆区申请的变量（bytes_to_get);
  5. 如果内存池容量还大于0，就先将剩余的零头配置到合适的free_list中去（利用FREELIST_INDEX)。
  6. 然后配置堆区空间，申请大小是bytes_to_get，如果申请失败，说明堆区没有资源了；
  7. 如果堆区也没有资源，那就查看free_list中的空闲空间，利用for循环，利用二级指针遍历free_list，如果有空间就释放出当前free_list的第一个区块，并让内存池的首尾指针指向该区块（start_free和end_free)；然后递归调用自身函数，用来修正nobjs。
  8. 如果出现意外，就是到了山穷水尽的时候，就调用第一级配置器的allocate()，会导致抛出异常，这个宏在第一级配置器的开始有定义；
  9. 如果配置堆区资源成功，即不执行6、7步骤，那么更新heap_size和end_free，并递归调用自己，修正nobjs。

refill()填充函数

再说之前的allocate()，如果free_list中没有区块了，就利用refill()从内存池中取区块来配置到free_list，这里默认取得20个区块，若不足20块，会配置的结点数可能小于20（这里的区块数就是chunk_alloc中的nobjs）。

private:
	static void* refill(size_t size)
	{
		int nobjs = 20;
		char* chunk = chunk_alloc(size, nobjs);	// 1
		if (1 == nobjs) return chunk;			// 2

		obj* volatile* my_free_list = nullptr;
		obj* result = (obj*)chunk;
		obj* current_obj = nullptr;
		obj* next_obj = nullptr;
		int i = 0;								// 3
		
		my_free_list = free_list + FREELIST_INDEX(size);	// 4
		*my_free_list = next_obj = (obj*)(chunk + size);	// 5
		for (i = 1; ; ++i)
		{
			current_obj = next_obj;							// 6
			next_obj = (obj*)((char*)next_obj + size);		// 7
			if (i == nobjs - 1)								//8
			{
				current_obj->free_list_link = nullptr;
				break;
			}
			current_obj->free_list_link = next_obj;			// 9
		}
		return result;
	}

解析

参数size表示需要填充的区块的大小（也用来寻找在哪个free_list上填充）

  1. 默认申请二十个区块，并利用指针指向当前申请的空间。
  2. 如果chunk_alloc修正后只有一个块nobjs，就先将这个块返回。
  3. 声明一些变量，分别是：用来指向free_list、指向申请的空间、指向当前区块，指向下一个区块、循环的参数 i 。
  4. 利用FREELIST_INDEX找到待填充的free_list。
  5. 接下来的步骤都是将这块大空间分成当前小区快串连起来，所以这里先将chunk偏移size个大小（因为第一块结点需要给客户使用），并强转成结点指针类型，让next_obj和*my_free_list都指向这个地址。
  6. 每次进入这个无限循环，都先让current_obj指向next_obj的位置。
  7. 将next_obj强转成char类型后加上size个大小（意味着往下偏移一个块大小），再强转成obj*类型指针，然后让next_obj指向这个偏移后的位置，意味着next_obj指向了下一个区块。
  8. 如果此时 循环条件 i 和 nobjs - 1 相等了，说明把所需的所有的块分割连接完成了，那么就将current_obj的 next域（free_list_link)置为nullptr。
  9. 这一步是连接操作，让当前结点的next域（free_list_link)指向 下一个结点(next_obj)。

内存池实际操作结果：
在这里插入图片描述

6. 自实现函数reallocate()

实际上该函数也是比较好实现的，调用reallocate()时会面临这些情况：

  1. old_sz > 128 && new_sz > 128；
    即原空间和新空间都大于128，就调用第一级配置器。

  2. old_sz 和 new_sz 都可以在同一个free_list上（比如 原：22字节，新：24字节；那么都在24字节这个free_list上取区块），那么可以不做处理，直接返回当前区块。

  3. 如果 old_sz > 128 && new_sz < 128;
    old_sz < 128 && new_sz > 128;
    old_sz < 128 && new_sz < 128;

接下来
围绕上面三点进行编写：

除去一二点，第三点可满足其他情况的发生具体流程是：

  1. 找出原大小和新大小哪个小；
  2. allocate()申请新空间；
  3. 将原空间的内容拷贝到新空间里，拷贝大小取决于原和新小的那个。
  4. deallocate()析构原空间。
  5. 返回新空间。
public:
	static void* reallocate(void* p, size_t old_sz, size_t new_sz)
	{
		// 1
		if (old_sz > (size_t)__MAX_BYTES && new_sz > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::reallocate(p, old_sz, new_sz);
		}
		// 2
		if (ROUND_UP(old_sz) == ROUND_UP(new_sz))
		{
			return p;
		}
		// 3
		size_t sz = old_sz < new_sz ? old_sz : new_sz;
		void* s = allocate(new_sz);
		memmove(s, p, sz);
		deallocate(p, old_sz);
		return s;
	}

第二级配置器源码

// 第二级配置器
enum { __ALIGN = 8 };	// 小型区块的上调边界
enum { __MAX_BYTES = 128 };	// 小型区块的上限
enum { __NFREELISTS = __MAX_BYTES / __ALIGN };	// free_lists个数

template<bool threads, int inst>
class __default_alloc_template
{
private:
	// 链表
	union obj
	{
		union obj* free_list_link;	// next;
		char client_data[1];
	};

private:
	// 一个指针数组，自由链表
	static obj* volatile free_list[__NFREELISTS];

	static size_t ROUND_UP(size_t bytes) // 1~8 / 9~16...
	{
		return (bytes + __ALIGN - 1) & ~(__ALIGN - 1);
	}
	static size_t FREELIST_INDEX(size_t bytes)
	{
		return (bytes + __ALIGN - 1) / __ALIGN - 1;
	}

	static char* start_free;	// 内存池起始位置
	static char* end_free;		// 内存池结束位置
	static size_t heap_size; // total

	// 配置一大块空间，可以容纳nobjs个size大小的区块
	// 如果配置nobjs个区块有所不便，nobjs会做出相应改变
	static char* chunk_alloc(size_t size, int& nobjs)
	{
		char* result = nullptr;
		// 需要空间的总大小
		size_t total_bytes = size * nobjs;
		// 内存池剩余空间
		size_t bytes_left = end_free - start_free;

		// 如果内存池剩余空间满足需要空间
		if (bytes_left >= total_bytes)
		{
			result = start_free;
			start_free = start_free + total_bytes;
			return result;
		}
		else if (bytes_left >= size)
		{
			// 如果剩余空间只够1个以上的块（但小于总需求）
			nobjs = bytes_left / size;
			result = start_free;
			start_free = start_free + total_bytes;
			return result;
		}
		else
		{
			// 如果连一块空间都不够
			size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
			
			// 将剩下的一点点空间再利用
			if (bytes_left > 0)
			{
				// 将剩余空间配置给合适的free_list
				obj* volatile* my_free_list = free_list + FREELIST_INDEX(bytes_left);
				((obj*)start_free)->free_list_link = *my_free_list;
				*my_free_list = (obj*)start_free;
			}

			// 配置heap空间，补充内存池
			start_free = (char*)malloc(bytes_to_get);
			if (nullptr == start_free)
			{
				obj* volatile* my_free_list = nullptr;
				obj* p = nullptr;
				for (int i = size; i <= __MAX_BYTES; i += __ALIGN)
				{
					my_free_list = free_list + FREELIST_INDEX(i);
					p = *my_free_list;
					if (nullptr != p)
					{
						*my_free_list = p->free_list_link;
						start_free = (char*)p;
						end_free = start_free + i;
						return chunk_alloc(size, nobjs);
					}
				}
				end_free = 0;
				start_free = (char*)malloc_alloc::allocate(bytes_to_get);
			}

			// 修正内存池的结束位置和总大小
			end_free = start_free + bytes_to_get;
			heap_size += bytes_to_get;
			// 递归调用自己，修正nobjs
			return chunk_alloc(size, nobjs);
		}
	}

	// 返回一个大小为size的对象，
	// 并可能加入大小为size的其他区块到free_list中
	static void* refill(size_t size)
	{
		int nobjs = 20;
		char* chunk = chunk_alloc(size, nobjs);
		if (1 == nobjs) return chunk;

		obj* volatile* my_free_list = nullptr;
		obj* result = (obj*)chunk;
		obj* current_obj = nullptr;
		obj* next_obj = nullptr;
		int i = 0;
		
		my_free_list = free_list + FREELIST_INDEX(size);
		*my_free_list = next_obj = (obj*)(chunk + size);
		for (i = 1; ; ++i)
		{
			current_obj = next_obj;
			next_obj = (obj*)((char*)next_obj + size);
			if (i == nobjs - 1)
			{
				current_obj->free_list_link = nullptr;
				break;
			}
			current_obj->free_list_link = next_obj;
		}
		return result;
	}

public:
	static void* allocate(size_t size)
	{
		if (size > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::allocate(size);
		}
		
		obj* result = nullptr;
		obj* volatile* my_free_list = nullptr;
		my_free_list = free_list + FREELIST_INDEX(size);
		result = *my_free_list;
		if (nullptr == result)
		{
			void* r = refill(ROUND_UP(size));
			return r;
		}
		*my_free_list = result->free_list_link;
		return result;
	}

	static void deallocate(void* p, size_t n)
	{
		if (n > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::deallocate(p, n);
		}

		obj* q = (obj*)p;
		obj* volatile* my_free_list = nullptr;
		// 寻找相应的free_list
		my_free_list = free_list + FREELIST_INDEX(n);
		// 头插法，回收区块
		q->free_list_link = *my_free_list;
		*my_free_list = q;
	}

	static void* reallocate(void* p, size_t old_sz, size_t new_sz)
	{
		if (old_sz > (size_t)__MAX_BYTES && new_sz > (size_t)__MAX_BYTES)
		{
			return malloc_alloc::reallocate(p, old_sz, new_sz);
		}
		if (ROUND_UP(old_sz) == ROUND_UP(new_sz))
		{
			return p;
		}

		size_t sz = old_sz < new_sz ? old_sz : new_sz;
		void* s = allocate(new_sz);
		memmove(s, p, sz);
		deallocate(p, old_sz);
		return s;
	}


};

// 对各个成员初始化
template<bool threads, int inst>
typename __default_alloc_template<threads, inst>::obj* volatile
__default_alloc_template<threads, inst>::free_list[__NFREELISTS] = {};

template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::start_free = nullptr;

template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::end_free = nullptr;

template<bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;

//
//
// SGI STL
#ifdef __USE_MALLOC
typedef __malloc_alloc_template<0> malloc_alloc;
typedef malloc_alloc alloc;
#else
typedef __default_alloc_template<0, 0> alloc;
#endif

template<typename T, typename Alloc>
class simple_alloc
{
public:
	// 申请
	static T* allocate(size_t n) // n个T类型的
	{
		return Alloc::allocate(sizeof(T) * n);
	}
	static T* allocate()
	{
		return Alloc::allocate(sizeof(T));
	}

	// 删除函数
	void deallocate(T* p, size_t n)
	{
		if (nullptr == p) return;
		Alloc::deallocate(p, size(T) * n);
	}
	void deallocate(T* p)
	{
		if (nullptr == p) return;
		Alloc::deallocate(p, sizeof(T));
	}
};
_索伦
关注
专栏目录
SGI STL空间配置器(allocator)设计原理与源码剖析(一)
ZY-JIMMY
04-15 1114
概述 、SGI标准的空间配置器：std::allocator 、SGI特殊空间配置器：std::alloc 、构造和析构基本工具：construct() 和 destroy() 、空间的配置与释放：std::alloc 、一、二级空间配置器简述
STL：二级空间配置器浅谈
Dandelion_gong的博客
05-09 3819
我们在编写程序过程中，需要内存时，我们第一反应就是malloc，但是这样容易产生内————存碎片，比如先申请50字节的空间，紧接着有申请了13字节空间，最后有申请了100字节空间，假设刚好这部分空间是连续的，那么当中间13字节空间释放后，之后一只在申请的空间都大于13字节，这是，这块空间就会形成内存碎片无法被利用。在STL中提到了空间适配器，它主要分为两级：一级空间适配置器，二级空间配置器。一级空间
STL 二级空间配置器
染尘
04-25 669
当程序需要在堆上申请空间时，我们常用的做法是直接malloc / new一块新的内存空间，这块被申请的空间需要我们手动释放，频繁的申请释放必然会导致系统产生大量内存碎片，尤其是小额区块的申请，内存碎片和额外负担很大的损害了我们的内存空间。 在STL中对于内存的申请，有着更高明的手法——allocator(空间配置器)。 一级空间配置器很简单，只是简单的将malloc进行封装，加入了异常处
STL空间配置器——第二级配置器__default_alloc_template剖析
哒哒的博客
06-18 928
SGI第二级空间配置器较第一级空间配置器加入了内存池(memory pool)管理，即次层配置。当所申请的空间大于128bytes时，直接调用一级空间配置器处理，小于128bytes时，使用次层配置器管理。申请的空间不足8的倍数，默认提升为最近的8的整数倍的空间大小。 目录展开就是简短总结
剖析SGI-STL二级空间配置器
最新发布
talk less, code more
07-20 927
阅读SGI-STL的源码，分析其二级空间配置器的实现和功能。
STL二级配置器
qq_36553387的博客
04-13 393
具备次配置力的SGI空间配置器 SGI STL的配置器与众不同，也与标准规范不同，其名称是alloc而非allocator，而且不接受任何参数。换句话说，如果你要在程序中明白采用SGI配置器，则不能采用标准写法 vector<int, std::allocator<int> > iv; 必须这么写： vector<int, std::alloc> iv; SGI STL allocator未能符合标准规格，这个事实通常不会给我们带来困扰，因为通常我们使用缺省的空间配置
STL — 浅析二级空间配置器
阿亮的博客
12-17 1105
浅析二级空间配置器SIG对于空间配置器的设计哲学为:1.向system heap 要求空间2.考虑多线程的状态3.考虑内存不足的应变措施4.考虑过多的"小型区块"可能造成的空间碎片问题.在我的上一个博客当中我们认识了一级空间配置器，但是我们在最后引出来了一个外碎片的问题,这是一级空间配置器没有办法解决. 外碎片其实就是系统剩余的内存明明足够，但是由于开辟太多了不连续的小块空间，导致没有办法开辟出来...
SGI STL二级空间配置器--内存池源码剖析
乐行僧的博客
02-11 329
一、STL容器一级空间配置器 通过SGI STL vector底层源码逐步分析内存池。 事实上，在我们使用STL容器时，有一点没有关心到的是我们默认使用了标准库里边的空间配置器，当然标准这样的做法是为了减少学习成本，但是当我们深入学习时，就一定要明白这些容器底层是如何工作，才能注重效率，才能用好STL容器。正如侯捷先生所说"源码之后，了无秘密。"， 下面通过vector容器先看一级空间配置器： ...
《STL 源码剖析》——空间配置器alloc
净无邪博客
04-03 1254
栈和队列是应用最多的数据结构之二，有数组实现和链表实现两种方式。当需要对容器做出限制，只允许一边插入和取出数据时，则需要用到栈。下面将总结数组实现的栈和阐述其原理。 一、线性表——栈Stack 1.1栈Stack定义 栈是一种特殊的线性表，其插入（也称为入栈或压栈）和删除（也称为弹出或出栈）操作都在表的同一端进行；该插入和删除的端口称为栈顶（top），另一端称为栈底（bottom）。 1.2栈的基本运算 1.2.1基本运算 (1) 初始化（构造一个空的栈） (2) 计算栈长度（栈中节点个数） (3) 插入节
STL——空间配置器剖析（一级空间配置器、二级空间配置器的本质及运用场合，是如何用内存池去管理的）
qq_37299596的博客
06-25 695
一级空间配置器、二级空间配置器的本质及运用场合，是如何用内存池去管理的 如何使用空间配置器 每个容器都会通过默认参数指定好allocator，不需要显示声明，如定义一个vector类容器：std::vector<int> vecTemp;而完整的vecTemp声明应该是vector<int,allocator<int>> vecTemp; 加入自定义了将内存分配指向磁盘或者其他存储介质空间的allocator，那么只要在声明时传入设计好的allocator，不再使用默认
STL源码分析：空间配置器浅析
HerofH_的博客
09-27 598
目录 allocator alloc 一级配置器 二级配置器 自由链表 内存分配allocate _S_refill函数 _S_chunk_alloc函数 内存释放deallocate 为什么要使用free_list？ 为什么free_list要把128bytes分成16部分？ 对于一些容器如vector、map、set之类的，都需要一个模板参数Alloc...
STL空间配置器（一级配置器及二级配置器）
qq_44824574的博客
04-06 2012
前言 在我们日常使用STL中的容器时，我们是几乎感受不到空间配置器的存在，因为他一直在默默工作，我们在之前的这一篇博客中也大概介绍过：C++（21）——vector及实现自定义vector以及allocator和iterator空间配置器，整个STL的操作对象都存放在容器之后。而容器需要配置空间以放置资料，这也就是空间配置器的作用。 注：STL提供了自定义空间配置器的接口，但是不建议自己定义，因为系统提供的空间配置器是足够安全且高效的，所以在我们使用时，一般会使用默认的配置器。 template<cl
STL二级空间配置器
weixin_33991727的博客
03-21 108
STL的二级空间配置器类似于memory_pool,但是并不是memory_pool,因为STL的二级空间配置器只维护了16个free_list,而且只是小于128byte大小的小区块，大于128byte会调用一级空间配置器malloc。16个链表放在数组中，每一个数组所链的链表代表大小相等的小区块，因为分配的时候，只会申请8的倍数大小的...
二级空间配置器
everthing willl be ok
06-15 323
一、二级空间配置器 在前面文章中我们介绍了一级空间配置器的概念和实现，一级空间配置器的实现相对比较简单，直接封装了malloc（）和free（）函数，同时增加了处理机制et_malloc_handler() 。 一级空间配置器主要处理大于128字节的大块内存分配问题，当字节数小于128字节，我们就需要用到二级空间配置器进行空间申请； STL默认是使用二级空间配置器。 1、二级空间配置器的配置...
【STL】空间配置器（二）：二级空间配置器
leap的博客
12-07 1939
SGI STL一级空间配置器: http://blog.csdn.net/bit_clearoff/article/details/53503846前面我们已经分析过了SGI STL一级空间配置器的实现以及其中的相关机制，今天我们主要来分析一下空间配置器中的重头戏：二级空间配置器。我们先来用图描述一下二级空间配置器的结构： 上图是二级空间配置器的基本结构是有一块事先分配好内存的内存池和一个给对象
stl第二级空间配置器 __defult_alloc_template
weixin_53344209的博客
04-22 242
之前说了第一级的空间配置器。这里再说一下第二级。 我们知道大于128字节的内存分配交给第一级，小于128级的交给第二级。 第二级空间配置器增加了一些机制来避免太多的小额区块造成的内存碎片。并且太多的小内存碎片对系统性能来说也是一种负担。为什么这么说呢？ 因为我们每分配一块内存，都得有一些税交给系统，里面记录了该区块的大小。内存越小，税就相对越大。 那么第二级空间配置器的做法是： 小于128的内存需求给内存池管理，此法也称为次层配置。每次配置一块大内存，并维护一个自由链表。 为了方便管理，SGI配置器会将需求
492-SGI STL二级空间配置器(allocate内存分配)
LINZEYU666的博客
08-28 236
内存池管理函数 allocate函数 传进去的参数 __n就是用户想开辟的内存的大小 如果大于128字节，就不受内存池管理，通过malloc去（一级空间配置器）。 如果小于等于128字节，就由内存池管理。 假设我们现在要申请13字节的内存块，用__my_freelist_list局部变量指向16字节大小的数组的位置1下标 我们看看函数定义的lock 利用栈上对象出作用域自动析构的特点，lock出}，就进行析构锁了。 临界区代码段，通过锁控制保证线程安全，因为自由链表的增删改不是线程安全的，所以要
STL之二级空间配置器及实现
honeyJ
06-04 1542
之前对于配置器的原理及一级配置器的介绍请看博文 这里写链接内容 下来我们直接介绍二级空间配置器。 二级空间配置器 我们通过之前的学习，已经知道。 如果所要申请的空间大于128字节，则直接交至一级空间配置器处理，如果小于128字节，则使用二级空间配置器。 二级空间配置器对内存的管理减少了小区块造成的内存碎片，它主要通过一个链表管理： 它是用一个16（128/8）个元素的自由链表来管理的...
深入理解Eff_STL：优秀C++ STL指南
Eff_STL中文版是一本专门针对C++标准模板库（Standard Template Library, STL）的深入指南，填补了众多C++教材中对STL不足的介绍。作者在1995年开始接触STL，并计划将其作为《More Effective C++》的一个补充部分，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_索伦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值