有关SGI STL的alloc

Ryan小小锅

已于 2022-12-20 14:17:12 修改

阅读量805

点赞数 4

分类专栏： # STL 文章标签： c++ 开发语言 STL 程序人生

于 2022-12-11 19:57:36 首次发布

csdn-@oorik/大臣

本文链接：https://blog.csdn.net/weixin_51609435/article/details/128158468

版权

STL 专栏收录该内容

19 篇文章 2 订阅

订阅专栏

在STL的使用者层面上，空间配置器一般是隐藏的，使用者不需要知道其具体实现细节即
可进行使用；但是从STL的实现角度来说，由于整个STL的操作对象都存放在容器之内，而容器
需要配置一定的空间来进行存放数据，因此，想要实现或者说深入了解STL的第一步便是掌握
空间配置器的原理。

主要还是说说SGI版本的STL的配置器

我们知道，stl有容器，空间配置器，适配器，迭代器，仿函数以及算法这6个组件：他们之间的运行关系大概是：容器通过配置器去获得数据和存储空间，算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套界仿函数。

allocator是STL的重要组成，但是一般用户不怎么熟悉他，因为allocator隐藏在所有容器（包括vector）身后，默默完成内存配置与释放，对象构造和析构的工作。

首先我们知道c++中内存分配和释放操作是由new和delete去完成的

class A {};
A* p = new A;
//...执行其他操作
delete p;

在我们使用new来建造一个对象的时候，一般是分为两个步骤的：
	1.调用::operator new()来构建空间；
	2.调用对象的构造函数。
	注：::operator new内部由malloc实现、省略指针转换这步。

	同理，当我们使用delete函数的时候：
	1.调用对象的析构函数
	2.调用::operator delete()释放空间。
	注：::operator delete内部由free实现

在STL的实现中，为了精细分工、STL allocator决定将上述步骤的两阶段操作分开来，内存
配置操作由alloc::allocate()负责，内存释放由alloc::deallocate负责，对象构建
操作由construct负责，对象析构操作由destroy负责。对于实现我就不过多赘述了

下面主要还是说说SGI版本的STL的配置器

对于SGI STL的实现来说、他这里含有了两个不同的空间配置器

第一个是一个符合部分标准、名为allocatr的配置器std::allocator


仅仅是将::operator new()和
::operator delete()做了一层简单的封装，因此效率比较差。

它存在的意义仅在于为用户提供一个兼容老代码的折衷方法，我们不建议使用，而且SGI内部也不使用这种标准的配置器，看一下了解一下

#ifnedf DEFALLOC_H
#define DEFALLOC_H

#include <new.h>
#include <stddef.h>
#include <stdlib.h>
#include <limits.h>
#include <iostream.h>
#include <algobase.h>

template <class T>
inline T* allocate(ptrdiff_t size, T*) {
    set_new_handler(0);
    T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
    if (tmp == 0) {
        cerr << "out of memory" << endl;
        exit(1);
    }
    return tmp;
}

template <class T>
inline void deallocate(T* buffer) {
    ::operator delete(buffer);
}

template <class T>
class allocator {
public:
    typedef T value_type;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    pointer allocate(size_type n) { return ::allocate((difference_type)n, (pointer)0); }
    void deallocate(pointer p) { ::deallocator(p); }
    pointer address(reference x) { return (pointer)&x; }
    const_pointer const_address(const_reference x) { return (const_pointer)&x; }
    size_type init_page_size() {
        return max(size_type(1), size_type(UINT_MAX/sizeof(T)));
    }
};

class allocator<void> {
public:
    typedef void* pointer;
}；

第二个是我们需要重点掌握的特殊配置器 std::alloc

这个配置器是SGI STL的默认配置器，它在<memory>中实现。

<memory>中包含三个文件：

<stl_construct.h>：定义了全局函数construct()和destroy()，负责对象构造和析构。
<stl_alloc.h>：内存配置和释放在此处实现，其内部有两级配置器，第一级结构简单，封装malloc()和free()，第二级实现了自由链表和内存池，用于提升大量小额内存配置时的性能。
<stl_uninitialiezed.h>：一些用于用于填充和拷贝大块内存的全局函数。

对象构造和/析构，与内存配置/释放是分离实现的。

SGI对于alloc函数的要求如下所示：
	1.向system heap要求空间
	2.考虑多线程状态
	3.考虑内存不足的应变措施
	4.考虑过多“小型区块”可能造成的内存碎片问题。

两层配置器的关系如下：

根据情况来判定，如果配置区块大于128bytes，说明“足够大”，调用第一级配置器，而小于等于128bytes，则采用复杂内存池（memory pool）来管理。

同时为了自由选择，STL又规定了 __USE_MALLOC 宏，如果它存在则直接调用第一级配置器，不然则直接调用第二级配置器。SGI未定义该宏，也就是说默认使用第二级配置器

由于一级配置器存在内存碎片的问题，所以有了二级配置器

转自《STL源码剖析》的SGI STL特殊配置器的内部实现图

图示左边是用户代码，右边是STL的内部。

我们可以看到，用户代码实例化一个vector对象，vector对象调用alloc的接口，注意，不同于之前标准的allocator，这里不需要实例化一个空间配置器，只需要调用alloc的静态函数就行了。

std::alloc的接口与标准非常相似：

static T* allocate()函数负责空间配置，返回一个T对象大小的空间。
static T* allocate(size_t)函数负责批量空间配置。
static void deallocate(T*)函数负责空间释放。
static void deallocate(T*,size_t)函数负责批量空间释放。

在接口之下，我们看到还有两级配置器，上面的接口根据情况调用这两个配置器，第二级配置器实现了内存池和自由链表，当程序多次进行小空间的配置时，可以从内存池和自由链表中获取空间，减少系统调用，提升性能。当进行大空间的配置时，上面的接口直接调用第一级配置器。最终，它们都是用malloc()和free()来配置和释放空间。

一般C++开发者了解到此已经足够应付大多数开发场景了。

这样看起来std::alloc的结构还算清晰，但是实际实现还会出现多种边界情况，比如，当系统调用malloc()空间不足时，我们需要让第一级配置器来处理，这可能涉及从第二级配置器中回收已经缓存但还未使用的空间，事情就变得繁琐了。

下面来手撕两层配置器的实现：

一级空间配置器

一级配置器直接用C中的malloc()以及free()函数来进行处理，当我们的内存分配不足的时候，我们调用oom_malloc()函数和oom_realloc进行处理,这两个函数里面都有循环，不断地去调用“内存不足，要调用例程”，去处理。

#if 1
#include<new>
#define __THROW_BAD_ALLOC throw bad_alloc
#else !defined(__THROW_BAD_ALLOC)
#define __THROW_BAD_ALLOC cerr<<"out of memory"<<endl;
#endif

template<int inst>
class __malloc_alloc_template
{
private:
	static void* oom_malloc(size_t);//malloc--指针函数
	static void* oom_realloc(void*, size_t);//realloc--指针函数
	static void(*__malloc_alloc_oom_handler)();//函数指针
public:
	static void* allocate(size_t n)//申请空间
	{
		void* result = malloc(n);//第一级配置器直接使用malloc
		//如果无法满足需求，费用oom_malloc()
		if (result == 0) {
			result == oom_malloc(n);
		}
		return result;
	}
	static void deallocate(void* p, size_t)
	{
		free(p);//第一级配置器直接使用free()
	}
	static void* reallocate(void* p, size_t)//不够了追加,是对allocate的补救
	{
		void* result = realloc(p, new_sz);//第一级配置器直接使用realloc
		//无法满足需求，改用oom_realloc()
		if (result == 0) {
			result = oom_realloc(p, new_sz);
			return result;
		}
	} 
	//下面这个可以通过他去指定自己的
	//out-of-memory handler
	static void (*set_malloc_handler(void(*f)()))()
	{
		void (*old)() = __malloc_alloc_oom_handler;
		__malloc_alloc_oom_handler = f;
		return old;
	}
};
//初始值为0，可以在客户端自己设定
template<int inst>
void(*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;

template<int inst>
void* __malloc_alloc_template<inst>::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;
	}
}
template<int inst>
void* __malloc_alloc_template<inst>::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;
	}
}
typedef __malloc_alloc_template<0> malloc_alloc;

void Out_Of_Memory()//测试
{
	cout << "this is out of memory" << endl;
	// exit(1);
}
//测试
int main()
{
	__malloc_alloc_template<0>::set_malloc_handler(Out_Of_Memory);
	int* p = (int*)__malloc_alloc_template<0>::allocate(sizeof(int) * 536870911);
	return 0;
}

二级空间配置器

第二级空间配置器多了一些机制，避免太多小额区块造成的内存的碎片，小额区块带来的其实
不仅是内存碎片，配置时的额外负担也是一个大问题(cookie)，SGI第二级配置器的做法是，
如果区块够大，超过4096bytes时，就移交第一级配置器，否则就以内存池的方式管理：每次
配置一大块内存，并维护对应的自由链表，下次若再有相同大小的内存需求，就直接从free list
中拔出。如果请求端释放小额内存，就由配置器回收到free list中，为了方便管理，SGI第二级
配置器会主动将任何小额区块的内存需求量上调至8的倍数。

typedef __malloc_alloc_template<0> malloc_alloc;
enum { __ALIGN = 8 };//小区块的上调边界
enum { __MAX_BYTES = 128 };//小型区块的上线
enum { __NFREELISTS = __MAX_BYTES / __ALIGN };//自由链表个数

template<bool threads, int inst>
class __default_alloc_template
{
private:
	//把ROUND_UP上调到8的倍数
	static size_t ROUND_UP(size_t bytes)
	{
		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
	}
private:
	union obj//共用体
	{
		union obj* free_list_link;
		char client_data[1];
	};
private:
	//16个自由链表
	static obj* free_list[__NFREELISTS];
	//下面根据区块的大小，决定使用第n号free_list，n从1开始算
	static size_t FREELIST_INDEX(size_t bytes)
	{
		return ((bytes)+__ALIGN - 1) / __ALIGN - 1;
	}
	//返回一个大小为n的对象，并可能加入大小为n的其他区块到 free list
	static void* refill(size_t n)
	{
		int nobjs = 20;
		char* chunk = chunk_alloc(n, nobjs);
		obj** my_free_list;
		obj* result;
		char* 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++)//把free list各个节点串起来
		{
			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;
	}
	//配置一大块空间，可以容纳nogjs个大小为size的区块
	//内存池
	static char* chunk_alloc(size_t size, int& nobjs)
	{
		char* result;
		size_t total_bytes = size * nobjs;  //8*20
		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
		{//一个区块也无法提供
			//320
			size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
			if (bytes_left > 0)
			{
				obj** my_free_list = free_list + REFFLIST_INDEX(bytes_left);
				((obj*)start_free)->free_list_link = *my_free_list;
				*my_free_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);
					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 = 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));
		}
	}
	static char* start_free;//内存池起始位置
	static char* end_free;//内存池结束位置
	static size_t heap_size;
public:
	//空间申请的接口
	//首先判断区块的大小，如果大于 128bytes –> 调用第一级配置器；
	//小于128bytes–> 就检查对应的 free_list（如果没有可用区块，就将区块上调至 8 倍数的边界，
	//然后调用 refill(), 为 free list 重新填充空间。
	static void* allocate(size_t n)
	{
		obj** my_free_list;
		obj* result;
		if (n > (size_t)__MAX_BYTES)  //如果>128 调用一级
		{
			return (malloc_alloc::allocate(n));
		}
		//寻找16个free list的适合的一个
		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;
	}
	//释放空间
	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;
		}
	}
	static void* reallocate(void* p, size_t old_sz, size_t new_sz);

};
template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::start_free = 0;
template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::end_free = 0;

template<bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;
template<bool threads, int inst>
__default_alloc_template<threads, inst>::obj*
__default_alloc_template<threads, inst>::free_list[__NFREELISTS] = { 0,0,0,0,0,0 }

推荐阅读：_herongweiV的博客-CSDN博客

二级空间配置器的原理剖析和简单实现_

Ryan小小锅

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
4
评论
有关SGI STL的alloc

在STL的使用者层面上，空间配置器一般是隐藏的，使用者不需要知道其具体实现细节即可进行使用；但是从STL的实现角度来说，由于整个STL的操作对象都存放在容器之内，而容器需要配置一定的空间来进行存放数据，因此，想要实现或者说深入了解STL的第一步便是掌握空间配置器的原理。目录主要还是说说SGI版本的STL的配置器我们知道，stl有容器，空间配置器，适配器，迭代器，仿函数以及算法这6个组件：他们之间的运行关系大概是：容器通过配置器去获得数据和存储空间，算法通过迭代器获取容器内容,仿函数可以协助算法完成不同
复制链接

扫一扫