STL 模板库第二日： 什么是空间配置器

最新推荐文章于 2022-02-25 18:40:38 发布
最新推荐文章于 2022-02-25 18:40:38 发布
阅读量154 收藏 1
点赞数
分类专栏： STL模板库温习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32378713/article/details/79331693
版权
一：什么是空间配置器？
空间适配器，所谓空间适配器，就是用来管理内存的一个器具。对于STL来说，空间适配器是它可以正常工作的基础，也为它可以高效工作提供了动力。对于使用STL来说，它是不和用户直接打交道的，而是隐藏在一切STL组件之后，默默为各种内存申请提供支持的。
对于c++用户来说，new和delete很熟悉，这两个函数可以分别完成内存的申请和释放，和c里面的malloc和free如出一辙，SGI 有一个标准空间适配器，同时还有一个特殊空间适配器，标准空间适配器为：std::allocator，这个适配器只是对new和delete的浅层包装，所以没有什么技术含量，所以在SGI中从没使用过这个标准适配器。另一个空间适配器是std:alloc，这是一个具有次分配能力的特殊空间适配器，它具有一级和二级适配器，它们协调工作。
Std::alloc的主要思想是：定义一个空间大小阈值，128bytes，如果申请的空间大于128bytes，那么就调用第一级空间适配器来完成分配工作，如果小于128bytes，那么就调用第二级空间适配器来完成。对于第一级适配器，直接调用malloc和free来完成分配与释放内存的工作（没有调用new和delete），最为重要的是，第一级适配器具有new-handle机制，用户可以指定当出现out-of-memory时的处理函数，在SGI里面，当第一级alloc失败时，会接着调用oom_alloc函数来尝试分配内存，如果oom发现没有指定new-handler函数的话，那就无能为力了！会抛出__THROW_BAD_ALLOC这个异常。
其中：这里所谓的两级并没有高低之分，它们之间的区别就是看你想要申请内存空间的大小。如果申请的内存大小超过128，那么空间配置器就自动调用一级空间配置器。反之调用二级空间配置器。而且在这里要说明的是空间配置器默认使用的是一级空间配置器。

二：一级空间配置器解析 

static void * allocate(size_t n) 
{ 
　　void *result = malloc(n);//直接使用第一级分配器，直接使用malloc 
　　if (0 == result) 

　　result = oom_malloc(n);//第一级分配器失效了，那就使 用oom(out of memeory) 
　　return result;//将分配的空间以void*的方式返回，用户可以随意转化为需要的类型 
}
 一级空间配置器就比较简单了，STL源码中的一级空间配置器命名为class __malloc_alloc_template ，它很简单，就是对malloc，free，realloc等系统分配函数的一层封装。

下面是仿照new_handle做的一个oom_malloc
template  
void * __malloc_alloc_template::oom_malloc(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 = malloc(n);
　　//分配内存 
　　　　if (result) 
　　　　return(result);

　　//如果内存已经得到满足的话，那么就可以返回了，如果不满足，那么 //就继续释放，分配.... 
　　　} 
}
其中的__malloc_alloc_oom_handler就是由用户设定的new-handler，我们可以通过下面的函数来设定
这个句柄：
static void (* set_malloc_handler(void (*f)()))() 
{ 
　　void (* old)() = __malloc_alloc_oom_handler;//old handler of outing of memory 
　　__malloc_alloc_oom_handler = f;//new handler for hander the out of memory 
　　return(old); 

}

三：二级空间配置器
一级空间配置器说起来比较乏味，他只是一层系统函数封装，真正酸爽的是二级空间配置器，里面有很多很棒的设计。多的不说，先来看二级空间配置器的框架，上代码：

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">template<bool threads,int inst>  
  2. class DefaultAllocTemplate//二级空间配置器  
  3. {  
  4. private:  
  5.     enum{ ALIGN = 8 };  
  6.     enum{ MAX_BYTES = 128 };  
  7.     enum{ FREELISTSIZE = MAX_BYTES / ALIGN };  
  8. public:  
  9.     static void* Allocate(size_t n)  
  10.     {  
  11.         if (n > MAX_BYTES)  
  12.         {  
  13.             return MallocAllocTemplate<inst>::Allocate(n);  
  14.         }  
  15.         void* ret = NULL;  
  16.         size_t index = GetFreeListIndex(n);  
  17.   
  18.         if (FreeList[index])//自由链表上有内存块  
  19.         {  
  20.             obj* cur = FreeList[index];  
  21.             ret = cur;  
  22.             FreeList[index] = cur->listLink;  
  23.         }  
  24.         else   //调用refill从内存池填充自由链表并返回内存池的第一个内存块  
  25.         {  
  26.             size_t bytes = GetRoundUpNum(n);  
  27.             return Refill(bytes);  
  28.         }  
  29.         return ret;  
  30.     }  
  31.     static void* Reallocate(void* p, size_t oldsize, size_t newsize)  
  32.     {  
  33.         void* ret = NULL;  
  34.         if (oldsize > (size_t)MAX_BYTES&&newsize > (size_t)MAX_BYTES)  
  35.             return (realloc(p, newsize));  
  36.         if (GetRoundUpNum(oldsize) == GetRoundUpNum(newsize))  
  37.             return p;  
  38.         ret = Allocate(newsize);  
  39.         size_t copysize = oldsize > newsize ? newsize : oldsize;  
  40.         memcopy(ret, p, copysize);  
  41.         DeAllocate(p, oldsize);  
  42.         return ret;  
  43.     }  
  44.     static void Deallocate(void* p, size_t n)  
  45.     {  
  46.         if (n > MAX_BYTES)//如果大于MAX_BYTES直接交还给一级空间配置器释放  
  47.             return MallocAllocTemplate<inst>::Deallocate(p, n);  
  48.         else//放回二级空间配置器的自由链表  
  49.         {  
  50.             size_t index = GetFreeListIndex(n);  
  51.             obj* tmp = (obj*)p;  
  52.             tmp->listLink = FreeList[index];  
  53.             Freelist[index] = tmp;  
  54.         }  
  55.     }  
  56. public:  
  57.     union obj  
  58.     {  
  59.         union obj* listLink;//自由链表中指向下一个内存快的指针  
  60.         char clientData[1];//调试用  
  61.     };  
  62.     static size_t GetFreeListIndex(size_t bytes)//得到所需内存块在自由链表中的下标  
  63.     {  
  64.         return ((bytes + ALIGN - 1) / ALIGN - 1);  
  65.     }  
  66.     static size_t GetRoundUpNum(size_t bytes)//得到内存块大小的向上对齐数  
  67.     {  
  68.         return (bytes + ALIGN - 1)&~(ALIGN - 1);  
  69.     }  
  70.   
  71.     static void* Refill(size_t n)//从内存池拿出内存填充自由链表  
  72.     {  
  73.         int nobjs = 20;//申请20个n大小的内存块  
  74.         char* chunk = ChunkAlloc(n, nobjs);  
  75.         if (nobj == 1)//只分配到一个内存  
  76.         {  
  77.             return chunk;  
  78.         }  
  79.         obj* ret = NULL;  
  80.         obj* cur = NULL;  
  81.         size_t index = GetFreeListIndex(n);  
  82.         ret = (obj*)chunk;  
  83.         cur = (obj*)(chunk + n);  
  84.   
  85.         //将nobj-2个内存块挂到自由链表上  
  86.         FreeList[index] = cur;  
  87.         for (int i = 2; i < nobjs; ++i)  
  88.         {  
  89.             cur->listLink = (obj*)(chunk + n*i);  
  90.             cur = cur->listLink;  
  91.         }  
  92.         cur->listLink = NULL;  
  93.         return ret;  
  94.     }  
  95.     static char* ChunkAlloc(size_t size, int& nobjs)  
  96.     {  
  97.         char* ret = NULL;  
  98.         size_t Leftbytes = endFree - startFree;  
  99.         size_t Needbytes = size * nobjs;  
  100.         if (Leftbytes >= Needbytes)  
  101.         {  
  102.             ret = startFree;  
  103.             startFree += Needbytes;  
  104.         }  
  105.         else if (Leftbytes >= size)//至少能分配到uoge内存块  
  106.         {  
  107.             ret = startFree;  
  108.             nobjs = Leftbytes / size;  
  109.             startFree += nobjs*size;  
  110.         }  
  111.         else     //一个内存块都分配不出来  
  112.         {  
  113.             if (Leftbytes > 0)  
  114.             {  
  115.                 size_t index = GetFreeListIndex(Leftbytes);  
  116.                 ((obj*)startFree)->listLink = FreeList[index];  
  117.                 FreeList[index] = (obj*)startFree;  
  118.                 startFree = NULL;  
  119.             }  
  120.             //向操作系统申请2倍Needbytes加上已分配的heapsize/8的内存到内存池  
  121.             size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);  
  122.             startFree = (char*)malloc(getBytes);  
  123.             if (startFree == NULL)//从系统堆中分配内存失败  
  124.             {  
  125.                 for (int i = size; i < MAX_BYTES; i += ALIGN)  
  126.                 {  
  127.                     obj* head = FreeList[GetFreeListIndex(i)];  
  128.                     if (head)  
  129.                     {  
  130.                         startFree = (char*)head;  
  131.                         head = head->listLink;  
  132.                         endFree = startFree + i;  
  133.                         return ChunkAlloc(size, nobjs);  
  134.                     }  
  135.                 }  
  136.                 //最后的一根救命稻草，找一级空间配置器分配内存  
  137.                 //（其他进程归还内存，调用自定义的句柄处理函数释放内存）  
  138.                 startFree = MallocAllocTemplate<inst>::Allocate(getBytes);  
  139.             }  
  140.             heapSize += getBytes;//从系统堆分配的总字节数（可以用于下次分配时进行调节）  
  141.             endFree = startFree + getBytes;  
  142.   
  143.             return ChunkAlloc(size, nobjs);//递归调用获取内存  
  144.         }  
  145.         return ret;  
  146.     }  
  147.   
  148.     static obj* volatile FreeList[FREELISTSIZE];  
  149.     static char* startFree;  
  150.     static char* endFree;  
  151.     static size_t heapSize;  
  152.   
  153. };  
  154.   
  155.   
  156. //typename表示DefaultAllocTemplate<threads, inst>是一个类型，  
  157. //如果不标识，编译器对此模板一无所知  
  158. template<bool threads, int inst>  
  159. typename DefaultAllocTemplate<threads, inst>::obj* volatile     
  160.            DefaultAllocTemplate<threads, inst>::FreeList[FREELISTSIZE] = { 0 };  
  161.   
  162. template<bool threads, int inst>  
  163. char* DefaultAllocTemplate<threads, inst>::startFree = 0;  
  164.   
  165. template<bool threads, int inst>  
  166. char* DefaultAllocTemplate<threads, inst>::endFree = 0;  
  167.   
  168. template<bool threads, int inst>  
  169. size_t DefaultAllocTemplate<threads, inst>::heapSize = 0;</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">template<bool threads,int inst>
class DefaultAllocTemplate//二级空间配置器
{
private:
	enum{ ALIGN = 8 };
	enum{ MAX_BYTES = 128 };
	enum{ FREELISTSIZE = MAX_BYTES / ALIGN };
public:
	static void* Allocate(size_t n)
	{
		if (n > MAX_BYTES)
		{
			return MallocAllocTemplate<inst>::Allocate(n);
		}
		void* ret = NULL;
		size_t index = GetFreeListIndex(n);

		if (FreeList[index])//自由链表上有内存块
		{
			obj* cur = FreeList[index];
			ret = cur;
			FreeList[index] = cur->listLink;
		}
		else   //调用refill从内存池填充自由链表并返回内存池的第一个内存块
		{
			size_t bytes = GetRoundUpNum(n);
			return Refill(bytes);
		}
		return ret;
	}
	static void* Reallocate(void* p, size_t oldsize, size_t newsize)
	{
		void* ret = NULL;
		if (oldsize > (size_t)MAX_BYTES&&newsize > (size_t)MAX_BYTES)
			return (realloc(p, newsize));
		if (GetRoundUpNum(oldsize) == GetRoundUpNum(newsize))
			return p;
		ret = Allocate(newsize);
		size_t copysize = oldsize > newsize ? newsize : oldsize;
		memcopy(ret, p, copysize);
		DeAllocate(p, oldsize);
		return ret;
	}
	static void Deallocate(void* p, size_t n)
	{
		if (n > MAX_BYTES)//如果大于MAX_BYTES直接交还给一级空间配置器释放
			return MallocAllocTemplate<inst>::Deallocate(p, n);
		else//放回二级空间配置器的自由链表
		{
			size_t index = GetFreeListIndex(n);
			obj* tmp = (obj*)p;
			tmp->listLink = FreeList[index];
			Freelist[index] = tmp;
		}
	}
public:
	union obj
	{
		union obj* listLink;//自由链表中指向下一个内存快的指针
		char clientData[1];//调试用
	};
	static size_t GetFreeListIndex(size_t bytes)//得到所需内存块在自由链表中的下标
	{
		return ((bytes + ALIGN - 1) / ALIGN - 1);
	}
	static size_t GetRoundUpNum(size_t bytes)//得到内存块大小的向上对齐数
	{
		return (bytes + ALIGN - 1)&~(ALIGN - 1);
	}

	static void* Refill(size_t n)//从内存池拿出内存填充自由链表
	{
		int nobjs = 20;//申请20个n大小的内存块
		char* chunk = ChunkAlloc(n, nobjs);
		if (nobj == 1)//只分配到一个内存
		{
			return chunk;
		}
		obj* ret = NULL;
		obj* cur = NULL;
		size_t index = GetFreeListIndex(n);
		ret = (obj*)chunk;
		cur = (obj*)(chunk + n);

		//将nobj-2个内存块挂到自由链表上
		FreeList[index] = cur;
		for (int i = 2; i < nobjs; ++i)
		{
			cur->listLink = (obj*)(chunk + n*i);
			cur = cur->listLink;
		}
		cur->listLink = NULL;
		return ret;
	}
	static char* ChunkAlloc(size_t size, int& nobjs)
	{
		char* ret = NULL;
		size_t Leftbytes = endFree - startFree;
		size_t Needbytes = size * nobjs;
		if (Leftbytes >= Needbytes)
		{
			ret = startFree;
			startFree += Needbytes;
		}
		else if (Leftbytes >= size)//至少能分配到uoge内存块
		{
			ret = startFree;
			nobjs = Leftbytes / size;
			startFree += nobjs*size;
		}
		else     //一个内存块都分配不出来
		{
			if (Leftbytes > 0)
			{
				size_t index = GetFreeListIndex(Leftbytes);
				((obj*)startFree)->listLink = FreeList[index];
				FreeList[index] = (obj*)startFree;
				startFree = NULL;
			}
			//向操作系统申请2倍Needbytes加上已分配的heapsize/8的内存到内存池
			size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);
			startFree = (char*)malloc(getBytes);
			if (startFree == NULL)//从系统堆中分配内存失败
			{
				for (int i = size; i < MAX_BYTES; i += ALIGN)
				{
					obj* head = FreeList[GetFreeListIndex(i)];
					if (head)
					{
						startFree = (char*)head;
						head = head->listLink;
						endFree = startFree + i;
						return ChunkAlloc(size, nobjs);
					}
				}
				//最后的一根救命稻草，找一级空间配置器分配内存
				//（其他进程归还内存，调用自定义的句柄处理函数释放内存）
				startFree = MallocAllocTemplate<inst>::Allocate(getBytes);
			}
			heapSize += getBytes;//从系统堆分配的总字节数（可以用于下次分配时进行调节）
			endFree = startFree + getBytes;

			return ChunkAlloc(size, nobjs);//递归调用获取内存
		}
		return ret;
	}

	static obj* volatile FreeList[FREELISTSIZE];
	static char* startFree;
	static char* endFree;
	static size_t heapSize;

};


//typename表示DefaultAllocTemplate<threads, inst>是一个类型，
//如果不标识，编译器对此模板一无所知
template<bool threads, int inst>
typename DefaultAllocTemplate<threads, inst>::obj* volatile   
           DefaultAllocTemplate<threads, inst>::FreeList[FREELISTSIZE] = { 0 };

template<bool threads, int inst>
char* DefaultAllocTemplate<threads, inst>::startFree = 0;

template<bool threads, int inst>
char* DefaultAllocTemplate<threads, inst>::endFree = 0;

template<bool threads, int inst>
size_t DefaultAllocTemplate<threads, inst>::heapSize = 0;</span>

    这个代码是我自己提取出来的源码框架，但是他已经可以实现所有的功能。

   首先需要说明的是二级空间配置器是由一个内存池和自由链表配合实现的。

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">    static obj* volatile FreeList[FREELISTSIZE];//维护自由链表  
  2.     static char* startFree;//维护内存池  
  3.     static char* endFree;</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">	static obj* volatile FreeList[FREELISTSIZE];//维护自由链表
	static char* startFree;//维护内存池
	static char* endFree;</span>

     srartFree就相当于水位线的一种东西，它标志着内存池的大小。

     自由链表中其实是一个大小为16的指针数组，间隔为8的倍数。各自管理大小分别为8，16，24，32，40，48，56，64，72，80，88，96，104， 112，120，128 字节的小额区块。在每个下标下挂着一个链表，把同样大小的内存块链接在一起。此处特别像哈希桶。

自由链表结构：

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">    union obj  
  2.     {  
  3.         union obj* listLink;//自由链表中指向下一个内存快的指针  
  4.         char clientData[1];//调试用  
  5.     };</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">	union obj
	{
		union obj* listLink;//自由链表中指向下一个内存快的指针
		char clientData[1];//调试用
	};</span>

     这个结构可以看做是从一个内存块中抠出4个字节大小来，当这个内存块空闲时，它存储了下个空闲块，当这个内存块交付给用户时，它存储的时用户的数据。因此，allocator中的空闲块链表可以表示成：
    obj* free_list[16];

     obj* 是4个字节那么大，但是大部分内存块大于4。我们想要做的只是将一块块内存链接起来，我们不用看到内存里所有的东西，所以我们可以只用强转为obj*就可以实现大内存块的链接。


   二级空间配置器是为频繁分配小内存而生的一种算法。其实就是消除一级空间配置器的外碎片问题。


操作系统频繁分配内存和回收内存的时候。这些6M，4M的小内存无法利用造成了外部碎片。


二级空间配置器就比较复杂了，现在我们来分析他的那些重要的函数：

 Allocate()中:

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;"><span style="white-space:pre">    </span>static size_t GetFreeListIndex(size_t bytes)//得到所需内存块在自由链表中的下标  
  2. <span style="white-space:pre">    </span>{  
  3. <span style="white-space:pre">        </span>return ((bytes + ALIGN - 1) / ALIGN - 1);  
  4. <span style="white-space:pre">    </span>}</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="white-space:pre">	</span>static size_t GetFreeListIndex(size_t bytes)//得到所需内存块在自由链表中的下标
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>return ((bytes + ALIGN - 1) / ALIGN - 1);
<span style="white-space:pre">	</span>}</span>
    此函数和源码中的FREELIST_INDEX(n)是一样的，它就是找到需要分配的内存块在自由链表中的什么地方，它的实现是((bytes + ALIGN - 1) / ALIGN - 1)。它其实是把药分配的内存大小提升一个数量级（+7，每间隔8为一个数量级），然后除以8，可以算到要找的内存块下标的下一个下标，减一，刚好久找到合适的下标处，取出一块内存块。

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">    static size_t GetRoundUpNum(size_t bytes)//得到内存块大小的向上对齐数  
  2.     {  
  3.         return (bytes + ALIGN - 1)&~(ALIGN - 1);  
  4.     }</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">	static size_t GetRoundUpNum(size_t bytes)//得到内存块大小的向上对齐数
	{
		return (bytes + ALIGN - 1)&~(ALIGN - 1);
	}</span>

      此函数是得到所需内存块大小的向上对齐数。在自由链表中，我们的内存块大小总是8的倍数，但是并不是每次所需内存大小都是8的倍数。所以我们就要取比所需大小大或相等的内存块，这就是向上取整。&~(ALIGN - 1)相当于将低8位置0，只取高8位，高8位总是8的倍数，正好符合题意。


Allocate中最重要的两个函数static void* Refill(size_t n)和static char* ChunkAlloc(size_t size, int& nobjs)：

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">static void* Refill(size_t n)//从内存池拿出内存填充自由链表  
  2.     {  
  3.         int nobjs = 20;//申请20个n大小的内存块  
  4.         char* chunk = ChunkAlloc(n, nobjs);  
  5.         if (nobj == 1)//只分配到一个内存  
  6.         {  
  7.             return chunk;  
  8.         }  
  9.         obj* ret = NULL;  
  10.         obj* cur = NULL;  
  11.         size_t index = GetFreeListIndex(n);  
  12.         ret = (obj*)chunk;  
  13.         cur = (obj*)(chunk + n);  
  14.   
  15.         //将nobj-2个内存块挂到自由链表上  
  16.         FreeList[index] = cur;  
  17.         for (int i = 2; i < nobjs; ++i)  
  18.         {  
  19.             cur->listLink = (obj*)(chunk + n*i);  
  20.             cur = cur->listLink;  
  21.         }  
  22.         cur->listLink = NULL;  
  23.         return ret;  
  24.     }</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">static void* Refill(size_t n)//从内存池拿出内存填充自由链表
	{
		int nobjs = 20;//申请20个n大小的内存块
		char* chunk = ChunkAlloc(n, nobjs);
		if (nobj == 1)//只分配到一个内存
		{
			return chunk;
		}
		obj* ret = NULL;
		obj* cur = NULL;
		size_t index = GetFreeListIndex(n);
		ret = (obj*)chunk;
		cur = (obj*)(chunk + n);

		//将nobj-2个内存块挂到自由链表上
		FreeList[index] = cur;
		for (int i = 2; i < nobjs; ++i)
		{
			cur->listLink = (obj*)(chunk + n*i);
			cur = cur->listLink;
		}
		cur->listLink = NULL;
		return ret;
	}</span>

     当在自由链表的下标处没有内存块时，我们就必须调用refill去填充自由链表。申请时一般一次性申请20个内存块大小的内存。通过移动startFree指针将内存池内的一段内存给“切割”出来，然后按照大小切成小块挂在自由链表下面。。返回第一块内存块给用户，其余的都挂在自由链表下，方便下次分配，根据局部性原理，这将极大地提升了分配内存空间的效率。

[cpp] view plain copy
print ?
  1. <span style="font-family:Microsoft YaHei;font-size:14px;">static char* ChunkAlloc(size_t size, int& nobjs)  
  2.     {  
  3.         char* ret = NULL;  
  4.         size_t Leftbytes = endFree - startFree;  
  5.         size_t Needbytes = size * nobjs;  
  6.         if (Leftbytes >= Needbytes)  
  7.         {  
  8.             ret = startFree;  
  9.             startFree += Needbytes;  
  10.         }  
  11.         else if (Leftbytes >= size)//至少能分配到一个内存块  
  12.         {  
  13.             ret = startFree;  
  14.             nobjs = Leftbytes / size;  
  15.             startFree += nobjs*size;  
  16.         }  
  17.         else     //一个内存块都分配不出来  
  18.         {  
  19.             if (Leftbytes > 0)  
  20.             {  
  21.                 size_t index = GetFreeListIndex(Leftbytes);  
  22.                 ((obj*)startFree)->listLink = FreeList[index];  
  23.                 FreeList[index] = (obj*)startFree;  
  24.                 startFree = NULL;  
  25.             }  
  26.             //向操作系统申请2倍Needbytes加上已分配的heapsize/8的内存到内存池  
  27.             size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);  
  28.             startFree = (char*)malloc(getBytes);  
  29.             if (startFree == NULL)//从系统堆中分配内存失败  
  30.             {  
  31.                 for (int i = size; i < MAX_BYTES; i += ALIGN)  
  32.                 {  
  33.                     obj* head = FreeList[GetFreeListIndex(i)];  
  34.                     if (head)  
  35.                     {  
  36.                         startFree = (char*)head;  
  37.                         head = head->listLink;  
  38.                         endFree = startFree + i;  
  39.                         return ChunkAlloc(size, nobjs);  
  40.                     }  
  41.                 }  
  42.                 //最后的一根救命稻草，找一级空间配置器分配内存  
  43.                 //（其他进程归还内存，调用自定义的句柄处理函数释放内存）  
  44.                 startFree = MallocAllocTemplate<inst>::Allocate(getBytes);  
  45.             }  
  46.             heapSize += getBytes;//从系统堆分配的总字节数（可以用于下次分配时进行调节）  
  47.             endFree = startFree + getBytes;  
  48.   
  49.             return ChunkAlloc(size, nobjs);//递归调用获取内存  
  50.         }  
  51.         return ret;  
  52.     }</span>  
<span style="font-family:Microsoft YaHei;font-size:14px;">static char* ChunkAlloc(size_t size, int& nobjs)
	{
		char* ret = NULL;
		size_t Leftbytes = endFree - startFree;
		size_t Needbytes = size * nobjs;
		if (Leftbytes >= Needbytes)
		{
			ret = startFree;
			startFree += Needbytes;
		}
		else if (Leftbytes >= size)//至少能分配到一个内存块
		{
			ret = startFree;
			nobjs = Leftbytes / size;
			startFree += nobjs*size;
		}
		else     //一个内存块都分配不出来
		{
			if (Leftbytes > 0)
			{
				size_t index = GetFreeListIndex(Leftbytes);
				((obj*)startFree)->listLink = FreeList[index];
				FreeList[index] = (obj*)startFree;
				startFree = NULL;
			}
			//向操作系统申请2倍Needbytes加上已分配的heapsize/8的内存到内存池
			size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);
			startFree = (char*)malloc(getBytes);
			if (startFree == NULL)//从系统堆中分配内存失败
			{
				for (int i = size; i < MAX_BYTES; i += ALIGN)
				{
					obj* head = FreeList[GetFreeListIndex(i)];
					if (head)
					{
						startFree = (char*)head;
						head = head->listLink;
						endFree = startFree + i;
						return ChunkAlloc(size, nobjs);
					}
				}
				//最后的一根救命稻草，找一级空间配置器分配内存
				//（其他进程归还内存，调用自定义的句柄处理函数释放内存）
				startFree = MallocAllocTemplate<inst>::Allocate(getBytes);
			}
			heapSize += getBytes;//从系统堆分配的总字节数（可以用于下次分配时进行调节）
			endFree = startFree + getBytes;

			return ChunkAlloc(size, nobjs);//递归调用获取内存
		}
		return ret;
	}</span>

ChunkAlloc要做的就是去找操作系统要内存，依次性要20个，但是我们要考虑很多情况：

  1. 内存池里有足够20块大的内存
  2. 内存池里有小于20块大于等于1块的内存大小
  3. 内存池里1块内存那么大都没有
STL是这样做的：     如果有足够的内存，那么一次性就给20块，返回第一块给用户，其余的挂在自由链表上。
                               只有一块或者多块，返回一块给用户。
                               没有内存了，找操作系统要。
                               操作系统没有了，启用最后一根救命稻草，调用一级空间配置器，通过句柄函数释放内存，分配内存。

这个就是二级空间配置器的主要逻辑结构。


还有要说明的几点就是：
  1. 空间配置器里所有的成员都是静态的。是为了在外面通过作用域就可以调用，而不需要构造对象。
  2. 空间配置器可以使用于大部分的数据结构，如List，vector等。
  3. 对于自由链表的初始化时特别容易错的。
    template<bool threads, int inst>
    typename DefaultAllocTemplate<threads, inst>::obj* volatile  
            DefaultAllocTemplate<threads, inst>::FreeList[FREELISTSIZE] = { 0 };
    注意到typename了吗。它就为了完成一个功能，到苏编译器DefaultAllocTemplate<threads, inst>是一个类型，不然会出现如下错误：



这是难以发现的错误，编译器认识DefaultAllocTemplate<threads, inst>，报一个搞不懂的错误。


Ym影子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
dvlinker的技术专栏
12-03 2万+
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
STL之空间配置器详细讲解
一个菜鸟的博客
01-31 1242
需要搞清楚空间配置器之前必须分清楚C++中各种内存分配和释放的区别？ 大型开源项目一般喜欢加上一个自己喜欢的内存池，哈哈 ，貌似可以解决一些内存碎片的功能，但是不知道效果大不大。到目前为止，我知道libevent里面没有使用内存池但是自己可以实现一个，给它使用；Nignx里面自己实现了内存池。 可以先看看自己如何实现一个内存池功能 SGI含有两个空间配置器类，std::allocator内存...
STL 模板库 第六日 ： deque
阿呆的隐秘角落
02-19 309
STL 模板库 deque一：什么是deque所谓的deque是”double ended queue”的缩写，双端队列不论在尾部或头部插入元素，都十分迅速。而在中间插入元素则会比较费时，因为必须移动中间其他的元素。双端队列是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候改变自身大小，完成了标准的C++数据结构中队列的所有功能。Vector是单向开口的连续线性...
STL之【空间配置器】
ChenYang1998的博客
06-05 302
什么是空间配置器 空房间配置器，顾名思义就是用来配置，管理，分配，释放内存空间的，有了它，它为我们的各种容器提供了生存的空间。有人会问，为什么不直接用malloc来申请呢，而要用空间配置器呢？ 提高效率：频繁的向系统申请小块内存，效率低下。 减少内存的碎片问题： 提高代码复用率和功能模块化。 空间不足时，有对应的应对措施。 隐藏实际内存分配的细节，确保分配出去的内存都会回收。 二...
STL剖析——空间配置器
宇哲
12-09 921
近来闲来无趣，看了下STL的空间配置器。首先恭喜我入坑，网上无数的人都在剖析这STL的空间配置器，所以，刚好，今天我也加入了这个团队，这个应该是我目前看到的比较完整架构的一个源码了吧，希望能提示我的水平，毕竟设计的很好。在这里特别说下，没有操作系统的知识，所以在这里的线程和锁的这些问题，我们一概不讨论STL的空间配置器，就是一个为了给容器进行分配内存和管理内存的东西，容许我盗几张图给大家说明。 这
史上STL最最最最最最全工具书，看我就够了
热门推荐
北北北
07-28 1万+
史上最全STL工具书，哪里不会查哪里
STL容器
erci_fc的博客
02-25 770
Nancy's first test 基础知识 遍历容器 //反向迭代器map std::map<int, string> mp; std::map<int, string>::reverse_iterator riter; mp[1] = "aaa"; mp[2] = "bbb"; riter = mp.rbegin(); while(riter != mp.rend()) { std::cout<<riter->first<<" "<<
leetcode和ctf-skr_learn_list:skr_learn_list
06-30
leetcode和ctf 这是什么？ 这是一份skr_university的学习清单，因为太菜被抓，努力学习的一份记录 skr_learn_list 前面因为年代久远，就以周为单位，后面...第二周（2020.5.23-2020.5.29）：STL源码抄写和相应漏洞查找
STL 模板库 第五日 ： vector的使用
阿呆的隐秘角落
02-19 337
STL 模板库    vector一：什么是vector  vector(向量):是一种顺序容器，事实上和数组差不多，但它比数组更优越。一般来说数组不能动态拓展，因此在程序运行的时候不是浪费内存，就是造成越界。而vector正好弥补了这个缺陷，它的特征是相当于可分配拓展的数组，它的随机访问快，在中间插入和删除慢，但在末端插入和删除快。 二：vector的本质是什么vector 是一个动态数组，它可...
STL 模板库第八日 ： set与multiset
阿呆的隐秘角落
02-20 260
set 容器前言：什么是set容器？map容器是键-值对的集合，好比以任命为键的地址和电话号码。而set容器只是单纯的键的集合。当只想知道一个值是否存在时，使用set容器是最适合。使用set容器必须包含set头文件：#include &lt;set&gt;set容器支持大部分map操作，包括：    关联容器中通用的操作。    三种构造函数。    insert操作。    count和find...
STL 模板库第四日 ：玩转 string
阿呆的隐秘角落
02-18 230
前言：C中是没有string这个类的（或者说就没有类的概念），C++ STL中提供了关于字符串操作的一系列操作，包括定义初始化，字符串算法，迭代器等等的一系列内容。下面是自己实现的一个简单的string类：#include &lt;iostream&gt; #include &lt;cstring&gt; using namespace std; class String{ public: ...
STL 模板库第一日：什么是模板
阿呆的隐秘角落
02-16 205
在c++Template中非常多地方都用到了typename与class这两个关键字，并且好像能够替换，是不是这两个关键字全然一样呢? 答：class用于定义类，在模板引入c++后，最初定义模板的方法为：template，这里class关键字表明T是一个类型。后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字。它的作用同class一样表明后面的符号为一个...
C++ STL模板库学习之路（前言）
阿呆的隐秘角落
02-16 198
在正式开始复习STL模板库之前，首先要知道什么是STL模板库。一：什么是STLSTL是Standard Template Library的简称，中文名标准模板库，惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,se...
STL 模板库第七日 : List
阿呆的隐秘角落
02-19 159
一：List基础List简介   list是一个双向链表容器，可高效地进行插入删除元素。   list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符。It++(ok) it+5(err)  #include &lt;list&gt;  list对象的默认构造list采用采用模板类实现,对象的默认构造形式：list&lt;T&gt; lstT;  如：list&lt;int&gt; ...
STL模板库第十日 ： 配接器（adapters）
阿呆的隐秘角落
02-22 138
前言： 在容器部分结束后其实是一些坑留下来的，比如 STACK、queue等容器，并没有介绍，但是并不是表示它们不重要，恰恰相反，他们代表的思想可能更加需要重视：配接器的思想。在学习设计模式的时候，我们就知道有一种设计模式叫装饰器模式：《Design Patterns》对 Adapter 设计模式的定义如下：将一个 class 的接口转换为另一个 class 的接口，使原本因接口不兼容而不能合作的...
STL模板库第十一日 ： 算法基础
阿呆的隐秘角落
02-22 119
前言： 算法部分主要由头文件&lt;algorithm&gt;，&lt;numeric&gt;和&lt;functional&gt;组成。 &lt;algorithm&gt;是所有STL头文件中最大的一个，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、反转、排序、合并等等。  &lt;numeric&gt;体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法...
基于springboot大学生智能消费记账系统的设计与实现.docx
最新发布
09-06
基于springboot大学生智能消费记账系统的设计与实现.docx
C++标准模板库STL详解：容器、迭代器与算法
"这篇资料是关于C++编程中第九章的内容，主要讲解了标准模板库STL。STL是一个包含了一系列通用程序组件的库，尤其是类模板和函数模板，用于提高编程效率。它由容器、迭代器、算法、函数对象、内存分配器和适配器等六...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ym影子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值