走进STL - 空间配置器,STL背后的故事

若有迷惑不解之处,或可在此篇找到解答:走近STL -STL概论

文章目录

      • 1、何为“空间配置器”
          • a、为何需要先了解空间配置器
          • b、SGI STL专属空间配置器
          • c、alloc的优势
      • 2、alloc全貌
          • a、 C++内存配置操作与释放操作
          • b、析构和构造的基本函数
          • c、空间的配置与释放(alloc)
            • c.1 真·alloc设计奥义
            • c.2 alloc一级配置器源码(截取)
            • c.3 alloc 二级配置器源码(截取)
            • c.4空间配置函数allocate
            • c.5 空间释放函数deallocate
            • c.6 重新填充free lists 函数refill
            • c. 内存池的chunk_alloc()操作
        • 篇章说明:

1、何为“空间配置器”

a、为何需要先了解空间配置器

从使用STL层面而言,空间配置器并不需要介绍,所以我的“走近STL”系列中并没有它的位置。
但若是从STL实现角度出发,空间配置器确实首要理解的。

作为STL设计背后的故事,空间配置器总是在默默地付出着。为什么你可以使用算法处理数据,为什么可以对容器进行操作,为什么迭代器可以遍历空间,这一切的一切,都有“空间配置器”的功劳。

而如果不经过本章,看后续章节会给自己徒增许多烦恼。

b、SGI STL专属空间配置器

SGI STL 的空间配置器与众不同,且与STL标准规范不同,其名为alloc,而非allocator。

SGI STL allocator未能符合标准,不过这并不会给我们造成困扰,因为我们没什么事儿不会自己去配置这个。而SGI的每一个容器都已经预设好了alloc。举例声明如下:

template <class T,class Alloc = alloc>	//预设使用alloc配置器
class vector{···};

虽然SGI也配置了allocatalor,但是它自己并不使用,也不建议我们使用,原因是效率比较感人,
因为它只是在基层进行配置/释放空间而已。

c、alloc的优势

三言两语无法说清,也不具说服力,具体请看下面 alloc全貌 的介绍。
(友情提醒:可以参考 2.c - c.1)

2、alloc全貌

a、 C++内存配置操作与释放操作

且看以下小栗子:

class test{···};

test *pf = new test;	//配置内存,然后构造对象
···
delete pf;		//析构对象,然后释放内存

这其中的new包含两个步骤:调用 ::operator new分配内存 ,调用test::test() 创建对象
其中的delete也包含两个步骤:调用test::~test()析构对象,调用 ::operator delete 释放空间

为了精密分工,STL allocator 将这两个步骤分开来,由alloc:allocate()负责内存配置操作,内存释放操作由alloc:deallocate()负责;对象构造操作由 ::construct()负责,对象析构操作由 ::destroy() 负责。

STL标准规则告诉我们,配置器定义于之中,SGI的内含以下两个文件:

#include 		//负责内存空间的配置与释放
#include 	//负责对象内容的构造与析构

来看张图:
走进STL - 空间配置器,STL背后的故事_第1张图片
初学作图,有点丑,还能看。


b、析构和构造的基本函数

construct()和destroy的源代码,睁大眼睛哦,虽然这两个函数不难

//以下是construct()函数

#include 

template <typename T1,typename t2>
inline void construct(T1 *p,const T2& value)
{
	new (p) T1(value);	//调用T1::T1(value)
}
//以下是destroy()函数第一版本

template <typename T>	//第一版本,接受一个指针

inline void destroy(T *pointer)
{
	pointer->~T();	  //调用 dtor ~T()
}
//以下是destroy()函数第二版本,接受两个迭代器

template <typename ForwardIterator>

inline void destory(ForwardIterator first,ForwardIterator last)
{
	__destory(first,last,value_type(first));
}
//判断元素的数值型别(value type)是否无关痛痒(trivial destructor)
template <typename ForwardIterator,typename T>

inline void __destroy(ForwardIterator first,ForwardIterator last,T*)
{
	typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;//注1
	__destroy_aux(first,last,trivial_destructor());
}

注1:这一句如果看不懂,我已经备好了排忧解难工具包

//如果是有关痛痒(non-trivial destructor)的

template <typename ForwardIterator,typename T>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__false_type)
{
	for(;first<last;++first)
	{
		destroy(&*first);
	}
}
//如果是trivial destructor,则no-op

template <typename ForwardIterator,typename T>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__true_type){}

这么长一串怕是看呆了,再来张图吧,献丑了
走进STL - 空间配置器,STL背后的故事_第2张图片


c、空间的配置与释放(alloc)

上面那一块是对象的构造和析构,接下来要讲的是对象构造和析构背后的故事——(内存的分配与释放),不要搞混了哦。

c.1 真·alloc设计奥义

对象构造和析构之后的内存管理诸项事宜,由一律负责。
SGI对此的设计原则如下:

  • 向system heap索要空间
  • 考虑多线程状态
  • 考虑内存不足时的应变措施
  • 考虑过多小型区块造成的内存碎片问题

考虑到小型区块可能造成的内存破碎问题,SGI为此设计了双层级配置器。
当配置区块超过128bytes时,称为足够大,使用第一级配置器,直接使用malloc()和free()。
当配置区块不大于128bytes时,为了降低额外负担,直接使用第二级配置器,采用复杂的memory pool处理方式。

无论使用第一级配接器或是第二级配接器,alloc都为其包装了接口,使其能够符合STL标准。

c.2 alloc一级配置器源码(截取)

睁大眼睛吧,看看这鬼斧生工的设计:

#include 

//注意,alloc不接受“template 型别参数”,所以就算你定义了也用不上

class __malloc_alloc_template
{
	private:	//这里面都是函数指针,用来处理内存不足的情况
	static void *oom_malloc(size_t);	
	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 /*n*/)
	{
		free(p);
	}

	//正常重分配空间
	static void * reallocate(void *p,size_t /* old_sz */,size_t new_sz)
	{
		void * result = realloc(p,new_sz);
		if( 0 == result )
			result = oom_realloc(p,new_sz);
		return result;
	}
}

//截取片段,留作向后拓展的部分这里就不提了

//下面为异常情况处理(空间不够)

void *__malloc_alloc_tempate<0>::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);
}
void *__malloc_alloc_tempate<0>::oom_realloc(void *p,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 = realloc(p,n);			//尝试再次配置内存
		if(result)
			return (result);
}

SGI 以malloc,而非 ::operator new 来分配内存,有历史因素,也有重配内存的因素在里面吧。


c.3 alloc 二级配置器源码(截取)

如果累了,建议先歇会儿,保护眼睛保护大脑。

接下来的这部分,将会更加的让我们为大师的智慧折服。

第二级配置器多了一些机制,专门针对内存碎片。内存碎片化带来的不仅仅是回收时的困难,配置也是一个负担。额外负担永远无法避免,毕竟系统要划出这么多的资源来管理另外的资源,但是区块越小,额外负担率就越高。
(索求任何一块内存,都得有一些“回扣”要交给系统)

SGI第二级配置器解决了多少问题呢?那就看各位的理解到什么程度了。
SGI第二级配置器的做法是“:sub-allocation (层次架构):

  • 每次分配一大块内存,并维护对应之自由链表(free-list)。
  • 下次若再有相同大小的内存需求,则直接从free-lists中取出。
  • 如果客端释放小额区块,就收回free-lists.

苍白的文字啊,看图:

走进STL - 空间配置器,STL背后的故事_第3张图片

清楚明了吧。

为了方便管理,SGI配置器会主动将任何小区块的内存需求量提升至8的倍数,就是整数字节的大小。
如果客端要求2个比特,就会自动分配到8比特。

并维护了16个free-list,图中已明确指出了。

如果我的图太难看,我在别的地方也找了一张:
走进STL - 空间配置器,STL背后的故事_第4张图片
free-list的节点结构真的是要惊叹的了:

看:

注:如果关于联合体把你困住了,我帮你解决了:工具包

union obj
{
	union obj *free_list_link;
	char client_data[1];
}

乍一看可能平淡无奇,认真一看,那个 union obj共出现了两次。这样有什么好处?
由于union的缘故,从其第一字段来看,obj可被视为一个指针,执行指向另一个obj;
从第二个字段来看,obj可以被看作一个指针,指向实际区块。

这样的好处在于,不会为了维护链表所必须的指针而造成另一次内存浪费。
秀吧,天秀!

好,接下来是第二级配置器的部分实现内容:

enum {__ALIGN = 8};	//小型区块的上调边界
enum {__MAX_BYTES = 128};	//小型区块的上限
enum {__NFREELISTS/ALIGN}	//free-list个数
class __default_alloc_template{
	
private:
//将byte上调至8的倍数
	static size_t ROUND_UP(size_t bytes){
		return (((bytes)+__ALIGN-1) &~ (__ALIGN -1));	
	}
private:
	//free-list的节点构造
private:
	//16个free-list
	static obj *volatile free_list[__NFREELISTS];
	//根据区块大小,决定使用n号free-list。n从1开始算
	static size_t FREELIST_INDEX(size_t bytes)	{
		return return (((bytes)+__ALIGN-1) / __ALIGN -1);	
	}
}

···
c.4空间配置函数allocate

文字叙述前面已经很详尽了,倒是代码零零散散,这里将代码串起来。

static void *alloc(size_t n)
{
	obj * volatile my_free_list;
	obj * result;

//一级
	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)
	{
		//没有可用free-list,准备重新填充
		void *r = refill(ROUND_UP(n));
		return r;
	}
	*my_free_list = result->free_list_link;
	return (result);
}

c.5 空间释放函数deallocate

有配置自然要有相应的释放函数了。
文字叙述已经很详尽了,直接看代码吧。

static void deallocate(void *p,size_t n)
{
	obj *q = (obj *)p;
	obj *volatile *my_free_list;

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

//寻找对应的free list
	my_free_list = free_list + FREELIST_INDEX(n);

//调整free_list,回收区块
	q->free_list_link = *my_free_list;
	*my_free_list = q;
}
c.6 重新填充free lists 函数refill

前面将这块放空。始终觉得看不过去。

当分配空间时发现没有可用区块空间了,就需要使用refill从内存池中申请空间。

void * __default_alloc_template</**参数不管它*/>::refill(size_t n)
{
	int nobjs = 20;

//调用chunk_alloc(),尝试取得nobjs个区块作为新节点
	char *chunk = chunk_alloc(n,nobjs);
	obj *volatile *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);


//睁大眼睛吧

//接下来准备在chunk空间中建立free list
	result = (obj *)chunk;	//先给调用者来一块
//接下来引导free list来拿地
	*my_free_list = next_obj = (obj *)(chunk + n);
//然后将新拿到的地消化吸收
	for(i = 1; ;i++)	//从1开始,0给别人了
	{
		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);
}

c. 内存池的chunk_alloc()操作

从内存池中取空间给free list 使用,是chunk_alloc() 的工作。

char * __default_alloc_template</*参数不管它*/>::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)	//不够总量,但是总归还是有一些存货的
	{
		nobjs = bytes_left/size;
		total_bytes = size*nobjs;
		result = start_free;
		start_free += total_bytes;
		return (result);
		//能给多少多少给多少吧
	}
	else
	{
		//一点都没了
		size_t byte_to_get = 2*total_bytes + ROUND_UP(heap_size >> 4);
		//先找些零零散散的拼一下看看
		if(bytes_left>0)
		{
			obj * volatile *my_free_list = free_list + FREELIST_INDEX(bytes_left);
			//调整free-list,将残余空间塞进去
			((obj *)start_free)->free_list_link = *my_free_list;
			*my_free_list = (obj *)start_free;
		}

	//记得我们开头说过,空间总是从system-heap中索求的,现在是时候去索求了
	//这块省略吧,太长了
	}
}

万一山穷水尽,连system heap都没空间了,那就一首凉凉。

篇章说明:

本篇主要来自与侯捷先生的《STL源码剖析》。
我在CSDN上也看到不少此类文章,但是大多是生搬硬套,很多点都讲的不清不楚,我在查资料的时候也是很懵。
所以我尽量把自己能看懂的内容摘取,看不懂的都去查了资料,工具包都嵌在文中了,或注释,或链接。

下一篇章将会是《迭代器》,不过不知道要写多久,这篇整整写了五天。

你可能感兴趣的:(STL)