内存管理（四）SGI STL 空间配置器

最新推荐文章于 2024-04-19 18:01:17 发布
最新推荐文章于 2024-04-19 18:01:17 发布
阅读量342 收藏
点赞数 1
文章标签： c++ 内存管理 sgi stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45074185/article/details/107750754
版权

前言

根据之前的学习，C++的内存申请的基本操作就是： 调用::operator new()；释放内存的操作就是：调用 ::operator delete()。而二者是通过malloc() 和 free() 实现的。因此SGI空间配置器就是使用malloc() 和 free() 来代替C++的内存操作实现的内存管理。

正文

1.空间配置器的要求

SGI 对于空间配置器的设计提出了以下几点：
1.向 system heap 要求空间
2.考虑多线程状态
3.考虑内存不足时的应变措施
4.考虑过多“小型区块”可能造成的内存碎片问题
以下给出的代码和问题的探讨皆排除多线程状态。

2.SGI空间配置器的双层设计

SGI空间配置器设计了两层配置器，第一级配置器直接使用malloc() 和 free()来配置内存。第二级配置器分情况采取不同的策略：当需要申请的内存大于128字节时，视之为足够大，直接调用第一级配置器的接口；当需要申请的内存小于128字节时，为了避免多余的空间浪费（主要是cookie的空间），采用复杂的memory pool来管理内存。
一二级空间配置器的调用关系：
在这里插入图片描述

3.一级空间配置器

typedef void(*H)();
template<int inst> //一级空间配置器
	class __malloc_alloc_template
	{
	private :
		
		//用来处理内存不足时的情况
		static void* oom_malloc(size_t); //oom:out of memory
		static void* oom_realloc(void*, size_t);
		static void (*__malloc_alloc_oom_handler)();

	public:
		static void* allocate(size_t n)   //申请内存
		{
			void* result = malloc(n);
			if (0 == result)
				result = oom_malloc(n);
			return result;
		}
		static void deallocate(void* p,size_t)
		{
			if (p)
				free(p);
		}
		static void* reallocate(void* p, size_t, size_t new_sz)
		{
			void* result = realloc(p, new_sz);
			if (0 == result)
				result = oom_realloc(p, new_sz);
			return result;
		}

		// 仿真C++的set_new_handler
		static H set_malloc_handler(H f)
		{
			H old = __malloc_alloc_oom_handler;
			__malloc_alloc_oom_handler = f;
			return old;
		}
	};
//template<int inst>
//void (*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;

template<int inst>
H __malloc_alloc_template<inst>::__malloc_alloc_oom_handler = 0;

template<int inst>
void*__malloc_alloc_template<inst>::oom_malloc(size_t n)
{
	H my_malloc_handler;
	void* result;
	while (1)  //不断尝试释放，配置
	{
		my_malloc_handler = __malloc_alloc_oom_handler;
		if (0 == __malloc_alloc_oom_handler)   //没有设置释放内存回调函数直接抛出异常
		{
			std::cerr << "out of memory" << std::endl;
			exit(1);
		}
		(*my_malloc_handler)();     //调用释放内存的回调
		result = malloc(n);         //重新尝试申请
		if (result)
			return result;
	}
}


template<int inst>
void* __malloc_alloc_template<inst>::oom_realloc(void* p, size_t n)
{
	H my_malloc_handler;
	void* result;
	while (1)
	{
		my_malloc_handler = __malloc_alloc_oom_handler;
		if (0 == __malloc_alloc_oom_handler)
		{
			std::cerr << "out of memory" << std::endl;
			exit(1);
		}
		(*my_malloc_handler)();
		result = realloc(p,n);
		if (result)
			return result;
	}
}

typedef __malloc_alloc_template<0> malloc_alloc;

第一级空间配置器只是对malloc() 和 free() 进行了一层封装并且通过模拟C++中的 new_handler 机制来接解决内存不足的问题。
以allocate函数为例，会先调用malloc来直接配置内存，如果配置失败调用oom_malloc，在oom_malloc中，如果有设置__malloc_alloc_oom_handler，则不断循环调用该回调并配置内存直到成功，否则直接抛出异常。
set_malloc_handler函数与C++ 中的_set_new_handler函数功能一致。
总体来说，第一级空间配置器就是对C++中的内存配置和释放机制的浅封装。

4.二级空间配置器

#define __ALIGN 8
#define __MAX_BYTES 128
#define __NFREELISTS  __MAX_BYTES/__ALIGN
#define __OBJNUM 20

template<int inst>
class __default_alloc_template   //二级空间配置器
{
private:
	static size_t ROUND_UP(size_t bytes)  //将bytes调至8的倍数
	{
		return ((bytes)+__ALIGN - 1) & ~(__ALIGN - 1);
	}
    struct obj  //嵌入式指针
	{
		struct obj* free_list_link;
	};

public:
    static obj* free_list[__NFREELISTS];  //根据大小区分的空闲内存区块
	static size_t FREELIST_INDEX(size_t bytes) //根据字节确定区块索引
	{
		return ((bytes)+__ALIGN - 1)/(__ALIGN - 1);
	}

	static void* refill(size_t n);

	static char* chunk_alloc(size_t size, int &nodjs);

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

 public:
	 static void* allocate(size_t n);
	 static void deallocate(void* p, size_t n);
	 //static void* reallocate(void* p, size_t old_sz, size_t new_sz);
};
typedef __default_alloc_template<0> alloc;
template<int inst>
char* __default_alloc_template<inst>::start_free = 0;

template<int inst>
char* __default_alloc_template<inst>::end_free = 0;

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

template<int inst> typename
__default_alloc_template<inst>::obj*
__default_alloc_template<inst>::free_list[__NFREELISTS] 
= { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };

二级空间配置器维护着16个链表，由一个静态的指针数组来存储。其中每一个元素都是一个链表的头。每一个链表中挂着相应大小的内存块若干（数量不定，<=20，可以为空），并且每一次申请的空间必须满足8字节的倍数，不足的由 ROUND_UP函数调整到8字节的倍数。

（一）allocate函数

template<int inst>
void* __default_alloc_template<inst>::allocate(size_t n)  //申请内存
{
	obj** my_free_list;
	obj* result;

	if (n > (size_t)__MAX_BYTES)   //大于128调用一级空间配置器
	{
		return malloc_alloc::allocate(n);
	}
	my_free_list = free_list + FREELIST_INDEX(n);

	result = *my_free_list;
	if (0 == result)   //没有可用的free list，使用refill函数填充
	{
		void* r = refill(ROUND_UP(n));
		return r;
	}

	*my_free_list = result->free_list_link;   //result 和 *my_free_list 此时指向同一块内存
	return (result);

}

二级空间配置器的allocate有两种决策：当申请内存大于128字节时，直接调用一级配置器的allocate；当小于128字节的时候，找到相应大小字节的链表头（由FREELIST_INDEX算出目标元素与指针数组首地址的偏移量）。如果此时链表中由元素，直接返回第一块，并更新链表头。否则调用refill函数填充链表后返回第一块。

（二）deallocate函数

template<int inst>
void __default_alloc_template<inst>::deallocate(void* p, size_t n)
{
	obj* q = (obj*)p;
	obj** my_free_list;
	if(n > (size_t)__MAX_BYTES)   //大于128调用一级空间配置器
	{
		 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;
}

同样的，对于deallcoate函数，先判断释放内存的大小，如果大于128字就调用一级配置器的接口，否则将该内存块归还到相应的链表中，更新链表头。

（三）refill函数

template<int inst>
void* __default_alloc_template<inst>::refill(size_t n)
{
	int nobjs = __OBJNUM;
	char* chunk = chunk_alloc(n, nobjs);
	obj** my_free_list;
	obj* result;
	obj* current_obj;
	obj* next_obj;
	if (1 == nobjs)   //只获得1块，直接返回，不向free_list 中新加节点
		return chunk;
	my_free_list = free_list + FREELIST_INDEX(n);
	result = (obj*)chunk;
	//让my_free_list指向第二个节点（因为第一个节点要被返回，不用添加进free_list）
	*my_free_list = next_obj = (obj*)(chunk + n);
	for (int i = 1;i<nobjs-1; i++)
	{
		current_obj = next_obj;
		next_obj = (obj*)((char*)next_obj + n);
		current_obj->free_list_link = next_obj;
	}
	next_obj->free_list_link = 0;
	return result;
}

先调用chunk_alloc函数从内存池中获取一定数量内存块（最大不超过__OBJNUM块），获取到的块数由nobjs返回，如果只获取到了一块，直接将内存返回给上一层，不用将之添加到链表中；若是多余一块，将剩余的内存块添加到链表中。

（四）chunk_alloc函数

template<int inst>
char* __default_alloc_template<inst>::chunk_alloc(size_t size, int& nobjs)
{
	char* result;
	size_t total_bytes = size * nobjs;
	size_t bytes_left = end_free - start_free;  //内存池剩余空间
	if (bytes_left >= total_bytes) //剩余空间足够满足全部需求
	{
		result = start_free;
		start_free += total_bytes;
		return result;
	}
	else if (bytes_left >= size)  //剩余空间不够满足全部需求，但是可以满足一个或以上的区块（不到20个）
	{
		nobjs = bytes_left / size;
		total_bytes = nobjs * size;
		result = start_free;
		start_free += total_bytes;
		return result;
	}
	else  //剩余空间一块都满足不了
	{
		//存在小的内存碎片，将之挂到相应大小的free_list上
		//（因为每次都是以8的倍数拿取，所以可以在free_list中找到同样大小的块）
		if (bytes_left > 0)  
		{
			obj** my_free_list;
			my_free_list = free_list + FREELIST_INDEX(bytes_left);
			((obj*)start_free)->free_list_link = *my_free_list;
			*my_free_list = (obj*)start_free;
		}

		//申请堆内存来填充内存池
		size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
		start_free = (char*)malloc(bytes_to_get);
		if (0 == start_free) //分配失败
		{
			obj** my_free_list;
			obj* p;
			for (int i = size; i <= __MAX_BYTES; i += __ALIGN)  //寻找比size大的区块
			{
				my_free_list = free_list + FREELIST_INDEX(i);
				p = *my_free_list;
				if (p)      //如果由空闲的free_list取出一块给内存池
				{
					*my_free_list = p->free_list_link;
					start_free = (char*)p;
					end_free = start_free + i;
					return chunk_alloc(size, nobjs);  //递归调用，修正nobjs的值
				}
			}
			//没有拿到合适的区块，转而调用一级空间配置器
			//尝试使用out of memory 机制释放一部分内存
			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);
	}
}

chunk_alloc函数是整个配置器中的难点和精髓部分。首先检测内存池中剩余空间是否满足全部需求（__OBJNUM块的内存），如果满足直接把内存返回给上一层，并更新内存池的剩余量。如果不能满足全部需求（大于等于1，小于__OBJNUM块），但可以满足一块或者以上，就返回可以返回的最大块数的内存。但是如果连一块内存都满足不了的情况，回先将内存池中剩余小的区块（此时可以视之为内存碎片）挂载到相应的链表上。然后用malloc申请堆内存来填充内存池，此时的申请的内存总量等于需求量的二倍，加上追加量，并调到8字节的倍数。这时候如果malloc失败的话，就在链表中找到一个比需求区块大并且相差最小的链表，从中拿出一块放回内存池后递归调用chunk_alloc来修正nobjs。但是若是出现最差的情况，所有的链表表中都没有符合的空闲内存可以用时，就会调用一级配置器中的allocate来尝试oom机制是否可以解决这个问题，就会出现上述一级配置器中成功返回和抛出异常的结果。（如果__malloc_alloc_oom_handler设计的不好可能出现死循环，也就是不断地待用回调，但还是分配不到空间）

4.一二级配置器统一封装的接口

想要在STL标准的容器中使用需要满足标准的接口，下面的封装实现了配置器接口的转调用。

template<class T,class Alloc>
	class simple_alloc
	{
	public:
		static T* allocate(size_t n)  //申请多个时调用接口
		{
			return 0 == n ? n : (T*)Alloc::allocate(n * sizeof(T));
		}
		static T* allocate(void)    //申请一个时调用接口
		{
			return (T*)Alloc::allocate(sizeof(T));
		}
		static void deallocate(T* p, size_t n) //释放多个时调用接口
		{
			if (0 != n)
				Alloc::deallocate(p, n * sizeof(T));  
		}
		static void deallocate(T* p) //释放一个时调用接口
		{
			Alloc::deallocate(p);
		}
	};

5.测试

#include<stdlib.h>
#include<iostream>

namespace wlj
{
	typedef void(*H)();
	//封装的统一接口
	template<class T,class Alloc>
	class simple_alloc
	{
	public:
		static T* allocate(size_t n)  //申请多个时调用接口
		{
			return 0 == n ? n : (T*)Alloc::allocate(n * sizeof(T));
		}
		static T* allocate(void)    //申请一个时调用接口
		{
			return (T*)Alloc::allocate(sizeof(T));
		}
		static void deallocate(T* p, size_t n) //释放多个时调用接口
		{
			if (0 != n)
				Alloc::deallocate(p, n * sizeof(T));  
		}
		static void deallocate(T* p) //释放一个时调用接口
		{
			Alloc::deallocate(p);
		}
	};

	//==================================================================================================

	template<int inst> //一级空间配置器
	class __malloc_alloc_template
	{
	private :
		
		//用来处理内存不足时的情况
		static void* oom_malloc(size_t); //oom:out of memory
		static void* oom_realloc(void*, size_t);
		static void (*__malloc_alloc_oom_handler)();

	public:
		static void* allocate(size_t n)   //申请内存
		{
			void* result = malloc(n);
			if (0 == result)
				result = oom_malloc(n);
			return result;
		}
		static void deallocate(void* p,size_t)
		{
			if (p)
				free(p);
		}
		static void* reallocate(void* p, size_t, size_t new_sz)
		{
			void* result = realloc(p, new_sz);
			if (0 == result)
				result = oom_realloc(p, new_sz);
			return result;
		}

		// 仿真C++的set_new_handler
		static H set_malloc_handler(H f)
		{
			H old = __malloc_alloc_oom_handler;
			__malloc_alloc_oom_handler = f;
			return old;
		}
	};
//template<int inst>
//void (*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;

template<int inst>
H __malloc_alloc_template<inst>::__malloc_alloc_oom_handler = 0;

template<int inst>
void*__malloc_alloc_template<inst>::oom_malloc(size_t n)
{
	H my_malloc_handler;
	void* result;
	while (1)  //不断尝试释放，配置
	{
		my_malloc_handler = __malloc_alloc_oom_handler;
		if (0 == __malloc_alloc_oom_handler)   //没有设置释放内存回调函数直接抛出异常
		{
			std::cerr << "out of memory" << std::endl;
			exit(1);
		}
		(*my_malloc_handler)();     //调用释放内存的回调
		result = malloc(n);         //重新尝试申请
		if (result)
			return result;
	}
}


template<int inst>
void* __malloc_alloc_template<inst>::oom_realloc(void* p, size_t n)
{
	H my_malloc_handler;
	void* result;
	while (1)
	{
		my_malloc_handler = __malloc_alloc_oom_handler;
		if (0 == __malloc_alloc_oom_handler)
		{
			std::cerr << "out of memory" << std::endl;
			exit(1);
		}
		(*my_malloc_handler)();
		result = realloc(p,n);
		if (result)
			return result;
	}
}

typedef __malloc_alloc_template<0> malloc_alloc;
   //====================================================================================
#define __ALIGN 8
#define __MAX_BYTES 128
#define __NFREELISTS  __MAX_BYTES/__ALIGN
#define __OBJNUM 20

template<int inst>
class __default_alloc_template   //二级空间配置器
{
private:
	static size_t ROUND_UP(size_t bytes)  //将bytes调至8的倍数
	{
		return ((bytes)+__ALIGN - 1) & ~(__ALIGN - 1);
	}
    struct obj  //嵌入式指针
	{
		struct obj* free_list_link;
	};

public:static obj* free_list[__NFREELISTS];  //根据大小区分的空闲内存区块
	static size_t FREELIST_INDEX(size_t bytes) //根据字节确定区块索引
	{
		return ((bytes)+__ALIGN - 1)/(__ALIGN - 1);
	}

	static void* refill(size_t n);

	static char* chunk_alloc(size_t size, int &nodjs);

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

 public:
	 static void* allocate(size_t n);
	 static void deallocate(void* p, size_t n);
	 //static void* reallocate(void* p, size_t old_sz, size_t new_sz);
};
typedef __default_alloc_template<0> alloc;
template<int inst>
char* __default_alloc_template<inst>::start_free = 0;

template<int inst>
char* __default_alloc_template<inst>::end_free = 0;

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

template<int inst> typename
__default_alloc_template<inst>::obj*
__default_alloc_template<inst>::free_list[__NFREELISTS] 
= { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };


template<int inst>
void* __default_alloc_template<inst>::allocate(size_t n)  //申请内存
{
	obj** my_free_list;
	obj* result;

	if (n > (size_t)__MAX_BYTES)   //大于128调用一级空间配置器
	{
		return malloc_alloc::allocate(n);
	}
	my_free_list = free_list + FREELIST_INDEX(n);

	result = *my_free_list;
	if (0 == result)   //没有可用的free list，使用refill函数填充
	{
		void* r = refill(ROUND_UP(n));
		return r;
	}

	*my_free_list = result->free_list_link;   //result 和 *my_free_list 此时指向同一块内存
	return (result);

}


template<int inst>
void __default_alloc_template<inst>::deallocate(void* p, size_t n)
{
	obj* q = (obj*)p;
	obj** my_free_list;
	if(n > (size_t)__MAX_BYTES)   //大于128调用一级空间配置器
	{
		 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;
}


template<int inst>
void* __default_alloc_template<inst>::refill(size_t n)
{
	int nobjs = __OBJNUM;
	char* chunk = chunk_alloc(n, nobjs);
	obj** my_free_list;
	obj* result;
	obj* current_obj;
	obj* next_obj;
	if (1 == nobjs)   //只获得1块，直接返回，不向free_list 中新加节点
		return chunk;
	my_free_list = free_list + FREELIST_INDEX(n);
	result = (obj*)chunk;
	//让my_free_list指向第二个节点（因为第一个节点要被返回，不用添加进free_list）
	*my_free_list = next_obj = (obj*)(chunk + n);
	for (int i = 1;i<nobjs-1; i++)
	{
		current_obj = next_obj;
		next_obj = (obj*)((char*)next_obj + n);
		current_obj->free_list_link = next_obj;
	}
	next_obj->free_list_link = 0;
	return result;
}

template<int inst>
char* __default_alloc_template<inst>::chunk_alloc(size_t size, int& nobjs)
{
	char* result;
	size_t total_bytes = size * nobjs;
	size_t bytes_left = end_free - start_free;  //内存池剩余空间
	if (bytes_left >= total_bytes) //剩余空间足够满足全部需求
	{
		result = start_free;
		start_free += total_bytes;
		return result;
	}
	else if (bytes_left >= size)  //剩余空间不够满足全部需求，但是可以满足一个或以上的区块（不到20个）
	{
		nobjs = bytes_left / size;
		total_bytes = nobjs * size;
		result = start_free;
		start_free += total_bytes;
		return result;
	}
	else  //剩余空间一块都满足不了
	{
		//存在小的内存碎片，将之挂到相应大小的free_list上
		//（因为每次都是以8的倍数拿取，所以可以在free_list中找到同样大小的块）
		if (bytes_left > 0)  
		{
			obj** my_free_list;
			my_free_list = free_list + FREELIST_INDEX(bytes_left);
			((obj*)start_free)->free_list_link = *my_free_list;
			*my_free_list = (obj*)start_free;
		}

		//申请堆内存来填充内存池
		size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
		start_free = (char*)malloc(bytes_to_get);
		if (0 == start_free) //分配失败
		{
			obj** my_free_list;
			obj* p;
			for (int i = size; i <= __MAX_BYTES; i += __ALIGN)  //寻找比size大的区块
			{
				my_free_list = free_list + FREELIST_INDEX(i);
				p = *my_free_list;
				if (p)      //如果由空闲的free_list取出一块给内存池
				{
					*my_free_list = p->free_list_link;
					start_free = (char*)p;
					end_free = start_free + i;
					return chunk_alloc(size, nobjs);  //递归调用，修正nobjs的值
				}
			}
			//没有拿到合适的区块，转而调用一级空间配置器
			//尝试使用out of memory 机制释放一部分内存
			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);
	}
}

}
template<class T,class Alloc = wlj::alloc>
class A
{
protected:
	typedef wlj::simple_alloc<T, Alloc> data_allocator;
public:
	T* get_instance(T n)
	{
		T* result = data_allocator::allocate();
		*result = n;
		return result;
	}
};

int main()
{
	
	A<int>a;
	int* val = a.get_instance(10);
	std::cout << *val << std::endl;

}

整体的测试一下。

6. 总结与思考

1.采用二层配置的机制，在不同内存需求的情况下采取不同的策略。造成内存浪费的主要原因是由于操作系统需要通过cookie来管理分配出去的内存，用malloc每次分配内存都会额外的有8字节的开销用于存放cookie，相较于大的区块，8字节所占的比例很小，内存的浪费可以接受，但是对于大量的小区块，cookie的开销就显得格外庞大。能过通过内存池的方式管理内存的客观条件就是我们在释放内存时不需要访问cookie就已经知道了此次需要释放的内存大小，也就无需cookie，所以对于所有的小区块进行了调整，让其满足于8字节的倍数，在释放时通过简单的计算就可以直接定位到相应的链表并归还。
2.在处理内存碎片问题上，直接将当前的碎片挂在到相应链表中去。
3.在chunk_alloc 无法 malloc 到内存时，只是找寻比需求内存大的链表，就会出现一种情况：大的链表都没有空闲的内存，但是比之小的链表其实还有很多内存，引出一个思考：小的区块是不是也可以用呢？
答案是很难实现，因为链表的区块与区块之间并不一定是真正连续的，即使多块总和满足需求，但是不连续是没用的。
4.在chunk_alloc 调用 malloc 时只以bytes_to_get为大小调用了一次，没有再次尝试改变bytes_to_get（将之变小）后调用malloc，其实这样的方式也是解决的一种办法，但是SGI空间配置器中并没有进行这样的设计，原因是：对于多进程的系统来说，如果某一个进程将所有能用的内存都占用，对于其他进程是灾难性的，避免竭泽而渔是一种很睿智的举动。

说LAI话长
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《STL源码剖析》深入剖析理解
qq_51969153的博客
07-24 476
《STL源码剖析》是由侯捷所著，是一本经典的C++ STL源码解析书籍，它深入剖析SGI版本的C++ STL源代码，解释了STL各个组件的实现原理和设计思路。
SGI STL原代码分析之Vector（一）。
qq_21441793的博客
01-19 2452
STL版本有很多种，STL是一套泛型编程框架标准，只要实现了这套标准的东西，都是叫做STL。。  所以STL有很多版本， 但是SGI STL是最为标准，而且是STL之父写的所以是最为权威的STL模板。 目的：分析Vector构造到Push_back这一系列过程中，STL中的实现过程。 开干。。。~！！！！ 首先来到Vector这个类，Vector模板里面传递了两个参数，第一个是
空间配置器(SGI-STL)
amara
03-13 412
理解 是一种管理空间的机制，对空间进行分配、回收 重要性：整个STL的操作对象都存放在容器中，容器需要配置空间置放数据。空间配置器为各容器实现了对空间的高效管理 为什么不直接用new/delete? 用户自己管理空间，容易内存泄漏 频繁申请小的内存空间，造成内存碎片 频繁调用函数过程中要出栈压栈，效率低 会产生额外的空间浪费(申请的空间大小+对空间管理的空间) 可能申请失败 为什么不说allo...
SGI STL二级空间配置器--内存池源码剖析
最新发布
木牛的博客
04-19 50
在上图，可以看到在一级空间配置器中，construct和destroy,对容器对象的构造和析构，其中构造使用了定位new的方式，在指定的内存上进行对象的构造，construct调用了p->~T(),这是由于析构函数名和类型是一样的。事实上，在我们使用STL容器时，有一点没有关心到的是我们默认使用了标准库里边的空间配置器，当然标准这样的做法是为了减少学习成本，但是当我们深入学习时，就一定要明白这些容器底层是如何工作，才能注重效率，才能用好STL容器。二、二级空间配置器（内存池的分析）
SGI STL源码剖析——空间配置器
qq_31082639的博客
01-23 1096
SGI STL源码剖析——空间配置器前言空间配置器SGI空间配置器内存配置和对象构造如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 这段时间读了侯捷老师的STL源码剖析，有一些体会和收获，看书的过程也碰到了许多疑惑，因此将自己的理解记录下来，原书和源码 https:
SGI STL源码.zip
12-14
SGI STL，全称为Stanford Graphics Group Standard Template Library，是由SGI公司开发并推广的一套C++标准模板库。这个库极大地丰富了C++的容器、迭代器、算法和函数对象，为C++程序员提供了高效且灵活的抽象数据...
SGI-STL.rar_sgi stl
09-22
6. **内存管理**：SGI-STL使用了智能指针（如auto_ptr）和分配器（Allocator）来管理内存，智能指针自动处理对象的生命周期，分配器则允许用户自定义内存分配策略。 7. **泛型编程**：SGI-STL的精髓在于泛型编程，...
SGI STL的源码
05-11
SGI STL（斯坦福大学图形小组Standard Template Library）是C++编程中的一种早期实现，它为C++标准库提供了一套高效、灵活的模板类集合，包括容器、迭代器、算法和函数对象等。SGI STL的设计理念是通过泛型编程来...
C++ - SGI 版本 STL源码
10-25
- STL容器使用分配器来管理内存，分配器是模板参数，可以定制以适应特定的内存管理策略。 6. **特殊容器** - bitset: 用于高效存储和操作位序列的容器。 - stack: 采用后进先出（LIFO）原则的容器适配器，底层...
SGISTL.rar_Boost_STL_STL手册_sgi stl
09-14
SGI的STL（Standard Template ...通过阅读和实践SGISTL.chm手册中的内容，你可以深入理解STL的设计哲学，学会如何选择合适的数据结构，以及如何有效地利用STL提供的算法，从而编写出更高效、更易于维护的C++代码。
STL-:SGI STL的二进制剖析以及直接封装的空间配置器代码
03-23
STL-:SGI STL的二进制剖析以及直接封装的空间配置器代码
SGI_STL空间配置器源码剖析（一）总览
qq_20756957的博客
04-10 782
如下是SGI STL的stl_vector.h文件中，vector类相关的声明：上图展示了通过宏定义，vector 区分使用C++标准提供的内存分配器（allocator）还是使用SGI自己实现的空间配置器。# else# endif# endif从上面可以看到 __STL_DEFAULT_ALLOCATOR通过宏控制有两种实现，一种是，另一种是alloc，这两种分别就是SGI STL的一级空间配置器和二级空间配置器的实现。
C++：了解SGI-STL空间配置器
AngelDg的博客
05-28 954
空间配置器什么是空间配置器为什么需要空间配置器SGI-STL空间配置器实现原理一级空间配置器二级空间配置器内存池SGI-STL中二级空间配置器设计SGI-STL二级空间配置器之空间申请 什么是空间配置器 空间配置器，顾名思义就是为各个容器高效的管理空间(空间的申请与回收)的，在默默地工作。虽然在常规使用STL时，可能用不到它，但站在学习研究的角度，学习它的实现原理对我们有很大的帮助。 为什么需要空间配置器 前面在模拟实现vector、list、map、unordered_map等容器时，所有需要空间的地方
STL版本介绍：HP STL、SGI STL、STL Port、PJ STL、RW STL
kanguolaikanguolaik的专栏
09-09 7535
C++STL的版本实现有很多种，包括：HP STL、SGI STL、STLPort、P.J.Plauger STL和Rouge Wave STL等 一、HP STL。 1.1 设计实现       HP STL是Alexandar Stepanov在惠普Palo Alto实验室工作时，与Meng Lee合作完成的。 1.2 实际应用       其他版本的C++ STL，一般是以
SGISTL源码-分配器 笔记
weixin_46065476的博客
07-06 219
本文是阅读SGISTL-分配器相关源码时所记录的笔记
SGI STL 空间配置器
weixin_45768137的博客
10-14 612
SGI STL 空间配置器详解
SGI内存池详解
bo_peter的博客
12-31 847
SGI内存池详解 SGI空间配置器，分为一级配置器和二级配置器，一级配置器对malloc和free(new和delete)做了一次封装，并且开通了预申请的接口。二级配置器，是真正的内存池，减少了内存开辟和释放所进行的上下文切换，提高了内存申请和释放效率。
STL源码剖析（二）：空间配置器alloctor（2）
youaremyalllove的博客
04-05 813
空间的配置和释放：alloc 考虑到小型区块可能造成的内存破碎问题，SGI设计了双层级配置器：当配置区块超过128bytes时，便调用第一级配置器；如果小于128bytes，为降低overhead，便采用复杂的memory pool整理方式。为使得alloc符合STL规格，SGI将Alloc做了一层封装： 首先看下第一级配置器 class __malloc_alloc_template template <int __inst> class __malloc_alloc_templ.
sgi stl内存池
10-21
SGI STL中的内存池是一种用于管理小对象内存分配的机制。它使用了SGI自己定义的allocator，实现了一个small object的内存池。这个内存池的主要目的是为了防止小块内存频繁分配、释放，造成系统内很多内存碎片，没有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值