一、SGI空间配置器介绍

在这里插入图片描述

一级配置器：

  • 使用malloc / free

二级配置器：

申请/释放空间使用手段
> 128字节使用一级配置器malloc / free
<= 128字节使用使用内存池memory pool

注意：二级配置器有可能会使用一级配置器。

二、一级空间配置器的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#ifndef MY_ALLOC_H
#define MY_ALLOC_H
#include<iostream>
namespace pzj
{
//开关语句
#if 0
#include<new>
#define __THROW_BAD_ALLOC throw std::bad_alloc;
#elif !defined (__THROW_BAD_ALLOC)
#define __THROW_BAD_ALLOC std::cout << "Out Of Memory"<< endl; exit(1);
#endif


//2:05
	template<int inst>
	class __malloc_alloc_template
	{
	public:
		using PFUN = void(*)();
		//typedef void(*PFUN)();

	private:
		//malloc空间不足
		static void* oom_malloc(size_t n)
		{
			void* result = NULL;
			void (*my_malloc_handler)() = NULL;
			while (1)
			{
				my_malloc_handler = __malloc_alloc_oom_handler;
				if (my_malloc_handler == NULL)
				{
					__THROW_BAD_ALLOC;
				}
				//释放出更多内存
				my_malloc_handler();
				result = malloc(n);
				if (result != NULL)
				{
					return result;
				}
			}
		}
		//realloc空间不足
		static void* oom_realloc(void* p, size_t n)
		{
			void* result = NULL;
			void (*my_malloc_handler)() = NULL;
			while (1)
			{
				my_malloc_handler = __malloc_alloc_oom_handler;
				if (my_malloc_handler == NULL)
				{
					__THROW_BAD_ALLOC;
				}
				//释放出更多内存
				my_malloc_handler();
				result = realloc(p ,n);
				if (result != NULL)
				{
					return result;
				}
			}
		}
		//函数指针解决内存不足
		static PFUN __malloc_alloc_oom_handler;

	public:
		//malloc申请空间
		static void* allocate(size_t n)
		{
			void* result = malloc(n);
			if (result == NULL)
			{
				return oom_malloc(n);
			}
			return result;
		}
		//free释放空间
		static void deallocate(void* p, size_t n)
		{
			free(p);
		}
		//realloc扩容
		static void* reallocate(void* p, size_t old_size, size_t new_size)
		{
			void* result = realloc(p, new_size);
			if (result == NULL)
			{
				oom_realloc(p, new_size);
			}
			return result;
		}

		//解决内存不足
		static PFUN set_malloc_handler(PFUN p)
		{
			PFUN old = __malloc_alloc_oom_handler;
			__malloc_alloc_oom_handler = p;
			return old;
		}
	};
	//类外初始化
	template<int inst>
	typename __malloc_alloc_template<inst>::PFUN
		__malloc_alloc_template<inst>::__malloc_alloc_oom_handler = NULL;

	//类型重命名
	typedef __malloc_alloc_template<0> malloc_alloc;

}

#endif

三、一级空间配置器测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include"my_alloc.h"


//占用的空间
char* p = (char*)malloc(10000);


//释放空间函数
void rest()
{
	if (p != NULL)
	{
		free(p);
	}
	p = NULL;
	//将
	pzj::malloc_alloc::set_malloc_handler(NULL);
}


int main()
{
	//设置内存清理函数
	pzj::malloc_alloc::set_malloc_handler(rest);

	//开辟新空间
	void* sp = pzj::malloc_alloc::allocate(1000);
	
	return 0;
}