devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C++航海王：追寻罗杰的编程之路】关于空间配置器你知道多少？

作者：一键难忘520 | 2024-08-13 21:17:02

赞

踩

【C++航海王：追寻罗杰的编程之路】关于空间配置器你知道多少？

目录

1 -> 什么是空间配置器

2 -> 为什么需要空间配置器

3 -> SGI-STL空间配置器的实现原理

3.1 -> 一级空间配置器

3.2 -> 二级空间配置器

3.2.1 -> 内存池

3.2.2 -> SGI-STL中二级空间配置器设计

3.2.3 -> SGI-STL二级空间配置器之空间申请

3.2.4 -> SGI-STL二级空间配置器之空间回收

3.3 -> 空间配置器的默认选择

3.4 -> 空间配置器的再次封装

3.5 -> 对象的构造与释放

4 -> 与容器结合

1 -> 什么是空间配置器

空间配置器，顾名思义就是为各个容器高效的管理空间(空间的申请与回收)的，在默默地工作。虽然在常规使用STL时，可能用不到它，但站在学习研究的角度，学习它的实现原理对我们有很大的帮助。

2 -> 为什么需要空间配置器

在模拟实现vector、list、map、unordered_map等容器时，所有需要空间的地方都是通过new申请的，虽然代码可以正常运行，但是有以下不足之处：

  • 空间申请与释放需要用户自己管理，容易造成内存泄漏。
  • 频繁向系统申请小块内存块，容易造成内存碎片。
  • 频繁向系统申请小块内存块，影响程序运行的效率。
  • 直接使用malloc与new进行申请，每块空间前有额外的空间浪费。
  • 申请空间失败的应对方法是什么?
  • 代码结构比较混乱，代码的复用率不高。
  • 未考虑线程安全问题。

因此需要设计一块高效的内存管理机制。

3 -> SGI-STL空间配置器的实现原理

以上提到的不足，最主要还是：频繁向系统申请小块内存造成的。那什么才算是小块的内存？SGI-STL以128作为小块内存与大块内存的分界线，将空间配置器分为两级结构，一级空间配置器处理大块内存，二级空间配置器处理小块内存。

3.1 -> 一级空间配置器

一级空间配置器原理非常简单，直接对malloc与free进行封装，并增加了C++中set_new_handle思想。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __malloc_alloc_template
  8. {
  9. private:
  10. 	static void* oom_malloc(size_t);
  11.  
  12. public:
  13. 	// 对malloc的封装
  14. 	static void* allocate(size_t n)
  15. 	{
  16. 		// 申请空间成功，直接返回，失败交由oom_malloc处理
  17. 		void* result = malloc(n);
  18. 		if (0 == result)
  19. 			result = oom_malloc(n);
  20.  
  21. 		return result;
  22. 	}
  23.  
  24. 	// 对free的封装
  25. 	static void deallocate(void* p, size_t /* n */)
  26. 	{
  27. 		free(p);
  28. 	}
  29.  
  30. 	// 模拟set_new_handle
  31. 	// 该函数的参数为函数指针，返回值类型也为函数指针
  32. 	// void (*   set_malloc_handler( void (*f)() ) )()
  33. 	static void (*set_malloc_handler(void (*f)()))()
  34. 	{
  35. 		void (*old)() = __malloc_alloc_oom_handler;
  36. 		__malloc_alloc_oom_handler = f;
  37.  
  38. 		return(old);
  39. 	}
  40. };
  41.  
  42. // malloc申请空间失败时代用该函数
  43. template <int inst>
  44. void* __malloc_alloc_template<inst>::oom_malloc(size_t n)
  45. {
  46. 	void (*my_malloc_handler)();
  47. 	void* result;
  48. 	for (;;)
  49. 	{
  50. 		// 检测用户是否设置空间不足应对措施，如果没有设置，抛异常，模式new的方式
  51. 		my_malloc_handler = __malloc_alloc_oom_handler;
  52. 		if (0 == my_malloc_handler)
  53. 		{
  54. 			__THROW_BAD_ALLOC;
  55. 		}
  56.  
  57. 		// 如果设置，执行用户提供的空间不足应对措施
  58. 		(*my_malloc_handler)();
  59.  
  60. 		// 继续申请空间，可能就会申请成功
  61. 		result = malloc(n);
  62. 		if (result)
  63. 			return(result);
  64. 	}
  65. }
  66.  
  67. typedef __malloc_alloc_template<0> malloc_alloc;

3.2 -> 二级空间配置器

二级空间配置器专门负责处理小于128字节的小块内存。如何才能提升小块内存的申请与释放的方式呢？SGI-STL采用了内存池的技术来提高申请空间的速度以及减少额外空间的浪费，采用哈希桶的方式来提高用户获取空间的速度与高效管理。

3.2.1 -> 内存池

内存池就是：先申请一块比较大的内存块做备用，当需要内存时，直接到内存池中去取，当内存池中空间不够时，再向内存中去取，当用户不用时，直接还回内存池即可。避免了频繁向系统申请小块内存所造成的效率低、内存碎片以及额外浪费的问题。

3.2.2 -> SGI-STL中二级空间配置器设计

SGI-STL中的二级空间配置器使用了内存池技术，但没有采用链表的方式对用户已经归还的空间进行管理(因为用户申请空间时在查找合适的小块内存时效率比较低)，而是采用了哈希桶的方式进行管理。那是否需要128桶个空间来管理用户已经归还的内存池呢？答案是不需要，因为用户申请的空间基本都是4的整数倍，其他大小的空间几乎很少用到。因此：SGI-STL将用户申请的内存块向上对齐到了8的整数倍。

3.2.3 -> SGI-STL二级空间配置器之空间申请

1. 前期准备

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __default_alloc_template
  8. {
  9. private:
  10. 	enum 
  11. 	{ 
  12. 		__ALIGN = 8 
  13. 	}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
  14. 	enum 
  15. 	{ 
  16. 		__MAX_BYTES = 128 
  17. 	}; // 大小内存块的分界线
  18. 	enum 
  19. 	{ 
  20. 		__NFREELISTS = __MAX_BYTES / __ALIGN 
  21. 	}; // 采用哈希桶保存小块内存时所需桶的个数
  22.  
  23. 	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
  24. 	static size_t ROUND_UP(size_t bytes)
  25. 	{
  26. 		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
  27. 	}
  28.  
  29. private:
  30. 	// 用联合体来维护链表结构
  31. 	union obj
  32. 	{
  33. 		union obj* free_list_link;
  34. 		char client_data[1]; /* The client sees this. */
  35. 	};
  36.  
  37. private:
  38. 	static obj* free_list[__NFREELISTS];
  39.  
  40. 	// 哈希函数，根据用户提供字节数找到对应的桶号
  41. 	static size_t FREELIST_INDEX(size_t bytes)
  42. 	{
  43. 		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
  44. 	}
  45.  
  46. 	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
  47. 	static char* start_free;
  48. 	static char* end_free;
  49.  
  50. 	// 用来记录该空间配置器已经想系统索要了多少的内存块
  51. 	static size_t heap_size;
  52.  
  53. 	// ...
  54. };

2. 申请空间

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __default_alloc_template
  8. {
  9. private:
  10. 	enum 
  11. 	{ 
  12. 		__ALIGN = 8 
  13. 	}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
  14. 	enum 
  15. 	{ 
  16. 		__MAX_BYTES = 128 
  17. 	}; // 大小内存块的分界线
  18. 	enum 
  19. 	{ 
  20. 		__NFREELISTS = __MAX_BYTES / __ALIGN 
  21. 	}; // 采用哈希桶保存小块内存时所需桶的个数
  22.  
  23. 	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
  24. 	static size_t ROUND_UP(size_t bytes)
  25. 	{
  26. 		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
  27. 	}
  28.  
  29. private:
  30. 	// 用联合体来维护链表结构
  31. 	union obj
  32. 	{
  33. 		union obj* free_list_link;
  34. 		char client_data[1]; /* The client sees this. */
  35. 	};
  36.  
  37. private:
  38. 	static obj* free_list[__NFREELISTS];
  39.  
  40. 	// 哈希函数，根据用户提供字节数找到对应的桶号
  41. 	static size_t FREELIST_INDEX(size_t bytes)
  42. 	{
  43. 		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
  44. 	}
  45.  
  46. 	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
  47. 	static char* start_free;
  48. 	static char* end_free;
  49.  
  50. 	// 用来记录该空间配置器已经想系统索要了多少的内存块
  51. 	static size_t heap_size;
  52.  
  53. 	// 函数功能：向空间配置器索要空间
  54. 	// 参数n: 用户所需空间字节数
  55. 	// 返回值：返回空间的首地址
  56. 	static void* allocate(size_t n)
  57. 	{
  58. 		obj* __VOLATILE* my_free_list;
  59. 		obj* __RESTRICT result;
  60. 		// 检测用户所需空间释放超过128(即是否为小块内存)
  61. 		if (n > (size_t)__MAX_BYTES)
  62. 		{
  63. 			// 不是小块内存交由一级空间配置器处理
  64. 			return (malloc_alloc::allocate(n));
  65. 		}
  66.  
  67. 		// 根据用户所需字节找到对应的桶号
  68. 		my_free_list = free_list + FREELIST_INDEX(n);
  69. 		result = *my_free_list;
  70.  
  71. 		// 如果该桶中没有内存块时，向该桶中补充空间
  72. 		if (result == 0)
  73. 		{
  74. 			// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
  75. 			void* r = refill(ROUND_UP(n));
  76.  
  77. 			return r;
  78. 		}
  79.  
  80. 		// 维护桶中剩余内存块的链式关系
  81. 		*my_free_list = result->free_list_link;
  82.  
  83. 		return (result);
  84. 	};
  85. };

3. 填充内存块

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __default_alloc_template
  8. {
  9. private:
  10. 	enum 
  11. 	{ 
  12. 		__ALIGN = 8 
  13. 	}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
  14. 	enum 
  15. 	{ 
  16. 		__MAX_BYTES = 128 
  17. 	}; // 大小内存块的分界线
  18. 	enum 
  19. 	{ 
  20. 		__NFREELISTS = __MAX_BYTES / __ALIGN 
  21. 	}; // 采用哈希桶保存小块内存时所需桶的个数
  22.  
  23. 	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
  24. 	static size_t ROUND_UP(size_t bytes)
  25. 	{
  26. 		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
  27. 	}
  28.  
  29. private:
  30. 	// 用联合体来维护链表结构
  31. 	union obj
  32. 	{
  33. 		union obj* free_list_link;
  34. 		char client_data[1]; /* The client sees this. */
  35. 	};
  36.  
  37. private:
  38. 	static obj* free_list[__NFREELISTS];
  39.  
  40. 	// 哈希函数，根据用户提供字节数找到对应的桶号
  41. 	static size_t FREELIST_INDEX(size_t bytes)
  42. 	{
  43. 		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
  44. 	}
  45.  
  46. 	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
  47. 	static char* start_free;
  48. 	static char* end_free;
  49.  
  50. 	// 用来记录该空间配置器已经想系统索要了多少的内存块
  51. 	static size_t heap_size;
  52.  
  53. 	// 函数功能：向空间配置器索要空间
  54. 	// 参数n: 用户所需空间字节数
  55. 	// 返回值：返回空间的首地址
  56. 	static void* allocate(size_t n)
  57. 	{
  58. 		obj* __VOLATILE* my_free_list;
  59. 		obj* __RESTRICT result;
  60. 		// 检测用户所需空间释放超过128(即是否为小块内存)
  61. 		if (n > (size_t)__MAX_BYTES)
  62. 		{
  63. 			// 不是小块内存交由一级空间配置器处理
  64. 			return (malloc_alloc::allocate(n));
  65. 		}
  66.  
  67. 		// 根据用户所需字节找到对应的桶号
  68. 		my_free_list = free_list + FREELIST_INDEX(n);
  69. 		result = *my_free_list;
  70.  
  71. 		// 如果该桶中没有内存块时，向该桶中补充空间
  72. 		if (result == 0)
  73. 		{
  74. 			// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
  75. 			void* r = refill(ROUND_UP(n));
  76.  
  77. 			return r;
  78. 		}
  79.  
  80. 		// 维护桶中剩余内存块的链式关系
  81. 		*my_free_list = result->free_list_link;
  82.  
  83. 		return (result);
  84. 	};
  85.  
  86.     // 函数功能：向哈希桶中补充空间
  87. 	// 参数n：小块内存字节数
  88. 	// 返回值：首个小块内存的首地址
  89. 	template <int inst>
  90. 	void* __default_alloc_template<inst>::refill(size_t n)
  91. 	{
  92. 		// 一次性向内存池索要20个n字节的小块内存
  93. 		int nobjs = 20;
  94. 		char* chunk = chunk_alloc(n, nobjs);
  95.  
  96. 		obj** my_free_list;
  97. 		obj* result;
  98. 		obj* current_obj, * next_obj;
  99. 		int i;
  100. 		// 如果只要了一块，直接返回给用户使用
  101. 		if (1 == nobjs)
  102. 			return(chunk);
  103.  
  104. 		// 找到对应的桶号
  105. 		my_free_list = free_list + FREELIST_INDEX(n);
  106. 		// 将第一块返回值用户，其他块连接在对应的桶中
  107. 		result = (obj*)chunk;
  108. 		*my_free_list = next_obj = (obj*)(chunk + n);
  109. 		for (i = 1; ; i++)
  110. 		{
  111. 			current_obj = next_obj;
  112. 			next_obj = (obj*)((char*)next_obj + n);
  113. 			if (nobjs - 1 == i)
  114. 			{
  115. 				current_obj->free_list_link = 0;
  116. 				break;
  117. 			}
  118. 			else
  119. 			{
  120. 				current_obj->free_list_link = next_obj;
  121. 			}
  122. 		}
  123.  
  124. 		return(result);
  125. 	}
  126.  
  127. };

4. 向内存池中索要空间

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __default_alloc_template
  8. {
  9. private:
  10. 	enum 
  11. 	{ 
  12. 		__ALIGN = 8 
  13. 	}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
  14. 	enum 
  15. 	{ 
  16. 		__MAX_BYTES = 128 
  17. 	}; // 大小内存块的分界线
  18. 	enum 
  19. 	{ 
  20. 		__NFREELISTS = __MAX_BYTES / __ALIGN 
  21. 	}; // 采用哈希桶保存小块内存时所需桶的个数
  22.  
  23. 	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
  24. 	static size_t ROUND_UP(size_t bytes)
  25. 	{
  26. 		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
  27. 	}
  28.  
  29. private:
  30. 	// 用联合体来维护链表结构
  31. 	union obj
  32. 	{
  33. 		union obj* free_list_link;
  34. 		char client_data[1]; /* The client sees this. */
  35. 	};
  36.  
  37. private:
  38. 	static obj* free_list[__NFREELISTS];
  39.  
  40. 	// 哈希函数，根据用户提供字节数找到对应的桶号
  41. 	static size_t FREELIST_INDEX(size_t bytes)
  42. 	{
  43. 		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
  44. 	}
  45.  
  46. 	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
  47. 	static char* start_free;
  48. 	static char* end_free;
  49.  
  50. 	// 用来记录该空间配置器已经想系统索要了多少的内存块
  51. 	static size_t heap_size;
  52.  
  53. 	// 函数功能：向空间配置器索要空间
  54. 	// 参数n: 用户所需空间字节数
  55. 	// 返回值：返回空间的首地址
  56. 	static void* allocate(size_t n)
  57. 	{
  58. 		obj* __VOLATILE* my_free_list;
  59. 		obj* __RESTRICT result;
  60. 		// 检测用户所需空间释放超过128(即是否为小块内存)
  61. 		if (n > (size_t)__MAX_BYTES)
  62. 		{
  63. 			// 不是小块内存交由一级空间配置器处理
  64. 			return (malloc_alloc::allocate(n));
  65. 		}
  66.  
  67. 		// 根据用户所需字节找到对应的桶号
  68. 		my_free_list = free_list + FREELIST_INDEX(n);
  69. 		result = *my_free_list;
  70.  
  71. 		// 如果该桶中没有内存块时，向该桶中补充空间
  72. 		if (result == 0)
  73. 		{
  74. 			// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
  75. 			void* r = refill(ROUND_UP(n));
  76.  
  77. 			return r;
  78. 		}
  79.  
  80. 		// 维护桶中剩余内存块的链式关系
  81. 		*my_free_list = result->free_list_link;
  82.  
  83. 		return (result);
  84. 	};
  85.  
  86.     // 函数功能：向哈希桶中补充空间
  87. 	// 参数n：小块内存字节数
  88. 	// 返回值：首个小块内存的首地址
  89. 	template <int inst>
  90. 	void* __default_alloc_template<inst>::refill(size_t n)
  91. 	{
  92. 		// 一次性向内存池索要20个n字节的小块内存
  93. 		int nobjs = 20;
  94. 		char* chunk = chunk_alloc(n, nobjs);
  95.  
  96. 		obj** my_free_list;
  97. 		obj* result;
  98. 		obj* current_obj, * next_obj;
  99. 		int i;
  100. 		// 如果只要了一块，直接返回给用户使用
  101. 		if (1 == nobjs)
  102. 			return(chunk);
  103.  
  104. 		// 找到对应的桶号
  105. 		my_free_list = free_list + FREELIST_INDEX(n);
  106. 		// 将第一块返回值用户，其他块连接在对应的桶中
  107. 		result = (obj*)chunk;
  108. 		*my_free_list = next_obj = (obj*)(chunk + n);
  109. 		for (i = 1; ; i++)
  110. 		{
  111. 			current_obj = next_obj;
  112. 			next_obj = (obj*)((char*)next_obj + n);
  113. 			if (nobjs - 1 == i)
  114. 			{
  115. 				current_obj->free_list_link = 0;
  116. 				break;
  117. 			}
  118. 			else
  119. 			{
  120. 				current_obj->free_list_link = next_obj;
  121. 			}
  122. 		}
  123.  
  124. 		return(result);
  125. 	}
  126.  
  127.     template <int inst>
  128. 	char* __default_alloc_template<inst>::chunk_alloc(size_t size, int&
  129. 		nobjs)
  130. 	{
  131. 		// 计算nobjs个size字节内存块的总大小以及内存池中剩余空间总大小
  132. 		char* result;
  133. 		size_t total_bytes = size * nobjs;
  134. 		size_t bytes_left = end_free - start_free;
  135. 		// 如果内存池可以提供total_bytes字节，返回
  136. 		if (bytes_left >= total_bytes)
  137. 		{
  138. 			result = start_free;
  139. 			start_free += total_bytes;
  140.  
  141. 			return(result);
  142. 		}
  143. 		else if (bytes_left >= size)
  144. 		{
  145. 			// nobjs块无法提供，但是至少可以提供1块size字节内存块，提供后返回
  146. 			nobjs = bytes_left / size;
  147. 			total_bytes = size * nobjs;
  148. 			result = start_free;
  149. 			start_free += total_bytes;
  150.  
  151. 			return(result);
  152. 		}
  153. 		else
  154. 		{
  155. 			// 内存池空间不足，连一块小块村内都不能提供
  156. 			// 向系统堆求助，往内存池中补充空间
  157. 			// 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
  158. 			size_t bytes_to_get = 2 * total_bytes + 
  159. 				ROUND_UP(heap_size >> 4);
  161. 			// 如果内存池有剩余空间(该空间一定是8的整数倍)，将该空间挂到对应哈希桶中
  162. 			if (bytes_left > 0)
  163. 			{
  164. 				// 找对用哈希桶，将剩余空间挂在其上
  165. 				obj** my_free_list = free_list +
  166. 					FREELIST_INDEX(bytes_left);
  167. 				((obj*)start_free)->free_list_link = *my_free_list;
  168. 				*my_ree_list = (obj*)start_free;
  169. 			}
  170.  
  171. 			// 通过系统堆向内存池补充空间，如果补充成功，递归继续分配
  172. 			start_free = (char*)malloc(bytes_to_get);
  173. 			if (0 == start_free)
  174. 			{
  175. 				// 通过系统堆补充空间失败，在哈希桶中找是否有没有使用的较大的内存块
  176. 				int i;
  177. 				obj** my_free_list, * p;
  178. 				for (i = size; i <= __MAX_BYTES; i += __ALIGN)
  179. 				{
  180. 					my_free_list = free_list + FREELIST_INDEX(i);
  181. 					p = *my_free_list;
  182.  
  183. 					// 如果有，将该内存块补充进内存池，递归继续分配
  184. 					if (0 != p)
  185. 					{
  186. 						*my_free_list = p->free_list_link;
  187. 						start_free = (char*)p;
  188. 						end_free = start_free + i;
  189.  
  190. 						return(chunk_alloc(size, nobjs));
  191. 					}
  192. 				}
  193.  
  194. 				// 山穷水尽，只能向一级空间配置器求助
  195. 				// 注意：此处一定要将end_free置空，因为一级空间配置器一旦抛异常就会出问题
  196. 				end_free = 0;
  197. 				start_free = (char*)malloc_alloc::allocate(bytes_to_get);
  198. 			}
  199.  
  200. 			// 通过系统堆向内存池补充空间成功，更新信息并继续分配
  201. 			heap_size += bytes_to_get;
  202. 			end_free = start_free + bytes_to_get;
  203.  
  204. 			return(chunk_alloc(size, nobjs));
  205. 		}
  206. 	}
  207.  
  208. };

3.2.4 -> SGI-STL二级空间配置器之空间回收

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template <int inst>
  7. class __default_alloc_template
  8. {
  9. private:
  10. 	enum 
  11. 	{ 
  12. 		__ALIGN = 8 
  13. 	}; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
  14. 	enum 
  15. 	{ 
  16. 		__MAX_BYTES = 128 
  17. 	}; // 大小内存块的分界线
  18. 	enum 
  19. 	{ 
  20. 		__NFREELISTS = __MAX_BYTES / __ALIGN 
  21. 	}; // 采用哈希桶保存小块内存时所需桶的个数
  22.  
  23. 	// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
  24. 	static size_t ROUND_UP(size_t bytes)
  25. 	{
  26. 		return (((bytes)+__ALIGN - 1) & ~(__ALIGN - 1));
  27. 	}
  28.  
  29. private:
  30. 	// 用联合体来维护链表结构
  31. 	union obj
  32. 	{
  33. 		union obj* free_list_link;
  34. 		char client_data[1]; /* The client sees this. */
  35. 	};
  36.  
  37. private:
  38. 	static obj* free_list[__NFREELISTS];
  39.  
  40. 	// 哈希函数，根据用户提供字节数找到对应的桶号
  41. 	static size_t FREELIST_INDEX(size_t bytes)
  42. 	{
  43. 		return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
  44. 	}
  45.  
  46. 	// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
  47. 	static char* start_free;
  48. 	static char* end_free;
  49.  
  50. 	// 用来记录该空间配置器已经想系统索要了多少的内存块
  51. 	static size_t heap_size;
  52.  
  53. 	// 函数功能：向空间配置器索要空间
  54. 	// 参数n: 用户所需空间字节数
  55. 	// 返回值：返回空间的首地址
  56. 	static void* allocate(size_t n)
  57. 	{
  58. 		obj* __VOLATILE* my_free_list;
  59. 		obj* __RESTRICT result;
  60. 		// 检测用户所需空间释放超过128(即是否为小块内存)
  61. 		if (n > (size_t)__MAX_BYTES)
  62. 		{
  63. 			// 不是小块内存交由一级空间配置器处理
  64. 			return (malloc_alloc::allocate(n));
  65. 		}
  66.  
  67. 		// 根据用户所需字节找到对应的桶号
  68. 		my_free_list = free_list + FREELIST_INDEX(n);
  69. 		result = *my_free_list;
  70.  
  71. 		// 如果该桶中没有内存块时，向该桶中补充空间
  72. 		if (result == 0)
  73. 		{
  74. 			// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
  75. 			void* r = refill(ROUND_UP(n));
  76.  
  77. 			return r;
  78. 		}
  79.  
  80. 		// 维护桶中剩余内存块的链式关系
  81. 		*my_free_list = result->free_list_link;
  82.  
  83. 		return (result);
  84. 	};
  85.  
  86. 	// 函数功能：向哈希桶中补充空间
  87. 	// 参数n：小块内存字节数
  88. 	// 返回值：首个小块内存的首地址
  89. 	template <int inst>
  90. 	void* __default_alloc_template<inst>::refill(size_t n)
  91. 	{
  92. 		// 一次性向内存池索要20个n字节的小块内存
  93. 		int nobjs = 20;
  94. 		char* chunk = chunk_alloc(n, nobjs);
  95.  
  96. 		obj** my_free_list;
  97. 		obj* result;
  98. 		obj* current_obj, * next_obj;
  99. 		int i;
  100. 		// 如果只要了一块，直接返回给用户使用
  101. 		if (1 == nobjs)
  102. 			return(chunk);
  103.  
  104. 		// 找到对应的桶号
  105. 		my_free_list = free_list + FREELIST_INDEX(n);
  106. 		// 将第一块返回值用户，其他块连接在对应的桶中
  107. 		result = (obj*)chunk;
  108. 		*my_free_list = next_obj = (obj*)(chunk + n);
  109. 		for (i = 1; ; i++)
  110. 		{
  111. 			current_obj = next_obj;
  112. 			next_obj = (obj*)((char*)next_obj + n);
  113. 			if (nobjs - 1 == i)
  114. 			{
  115. 				current_obj->free_list_link = 0;
  116. 				break;
  117. 			}
  118. 			else
  119. 			{
  120. 				current_obj->free_list_link = next_obj;
  121. 			}
  122. 		}
  123.  
  124. 		return(result);
  125. 	}
  126.  
  127. 	template <int inst>
  128. 	char* __default_alloc_template<inst>::chunk_alloc(size_t size, int&
  129. 		nobjs)
  130. 	{
  131. 		// 计算nobjs个size字节内存块的总大小以及内存池中剩余空间总大小
  132. 		char* result;
  133. 		size_t total_bytes = size * nobjs;
  134. 		size_t bytes_left = end_free - start_free;
  135. 		// 如果内存池可以提供total_bytes字节，返回
  136. 		if (bytes_left >= total_bytes)
  137. 		{
  138. 			result = start_free;
  139. 			start_free += total_bytes;
  140.  
  141. 			return(result);
  142. 		}
  143. 		else if (bytes_left >= size)
  144. 		{
  145. 			// nobjs块无法提供，但是至少可以提供1块size字节内存块，提供后返回
  146. 			nobjs = bytes_left / size;
  147. 			total_bytes = size * nobjs;
  148. 			result = start_free;
  149. 			start_free += total_bytes;
  150.  
  151. 			return(result);
  152. 		}
  153. 		else
  154. 		{
  155. 			// 内存池空间不足，连一块小块村内都不能提供
  156. 			// 向系统堆求助，往内存池中补充空间
  157. 			// 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
  158. 			size_t bytes_to_get = 2 * total_bytes + 
  159. 				ROUND_UP(heap_size >> 4);
  161. 			// 如果内存池有剩余空间(该空间一定是8的整数倍)，将该空间挂到对应哈希桶中
  162. 			if (bytes_left > 0)
  163. 			{
  164. 				// 找对用哈希桶，将剩余空间挂在其上
  165. 				obj** my_free_list = free_list +
  166. 					FREELIST_INDEX(bytes_left);
  167. 				((obj*)start_free)->free_list_link = *my_free_list;
  168. 				*my_ree_list = (obj*)start_free;
  169. 			}
  170.  
  171. 			// 通过系统堆向内存池补充空间，如果补充成功，递归继续分配
  172. 			start_free = (char*)malloc(bytes_to_get);
  173. 			if (0 == start_free)
  174. 			{
  175. 				// 通过系统堆补充空间失败，在哈希桶中找是否有没有使用的较大的内存块
  176. 				int i;
  177. 				obj** my_free_list, * p;
  178. 				for (i = size; i <= __MAX_BYTES; i += __ALIGN)
  179. 				{
  180. 					my_free_list = free_list + FREELIST_INDEX(i);
  181. 					p = *my_free_list;
  182.  
  183. 					// 如果有，将该内存块补充进内存池，递归继续分配
  184. 					if (0 != p)
  185. 					{
  186. 						*my_free_list = p->free_list_link;
  187. 						start_free = (char*)p;
  188. 						end_free = start_free + i;
  189.  
  190. 						return(chunk_alloc(size, nobjs));
  191. 					}
  192. 				}
  193.  
  194. 				// 山穷水尽，只能向一级空间配置器求助
  195. 				// 注意：此处一定要将end_free置空，因为一级空间配置器一旦抛异常就会出问题
  196. 				end_free = 0;
  197. 				start_free = (char*)malloc_alloc::allocate(bytes_to_get);
  198. 			}
  199.  
  200. 			// 通过系统堆向内存池补充空间成功，更新信息并继续分配
  201. 			heap_size += bytes_to_get;
  202. 			end_free = start_free + bytes_to_get;
  203.  
  204. 			return(chunk_alloc(size, nobjs));
  205. 		}
  206. 	}
  207.  
  208. 	// 函数功能：用户将空间归还给空间配置器
  209. 	// 参数：p空间首地址   n空间总大小
  210. 	static void deallocate(void* p, size_t n)
  211. 	{
  212. 		obj* q = (obj*)p;
  213. 		obj** my_free_list;
  214. 		// 如果空间不是小块内存，交给一级空间配置器回收
  215. 		if (n > (size_t)__MAX_BYTES)
  216. 		{
  217. 			malloc_alloc::deallocate(p, n);
  218.  
  219. 			return;
  220. 		}
  221. 		// 找到对应的哈希桶，将内存挂在哈希桶中
  222. 		my_free_list = free_list + FREELIST_INDEX(n);
  223. 		q->free_list_link = *my_free_list;
  224. 		*my_free_list = q;
  225. 	}
  226.  
  227. };

3.3 -> 空间配置器的默认选择

SGI-STL默认使用一级还是二级空间配置器，通过USE_MALLOC宏进行控制：

  1. #ifdef __USE_MALLOC
  2. typedef malloc_alloc alloc;
  3. typedef malloc_alloc single_client_alloc;
  4. #else
  5. // 二级空间配置器定义
  6. #endif

在SGI-STL中该宏没有定义，因此：默认情况下SGI-STL使用二级空间配置器。

3.4 -> 空间配置器的再次封装

在C++中，用户所需空间可能是任意类型的，有单个对象空间，有连续空间每次让用户自己计算所需空间总大小不是很友好，因此SGI-STL将空间配置器重新再封装了一层：

  1. // T: 元素类型
  2. // Alloc: 空间配置器
  3. // 注意：该类只负责申请与归还对象的空间，不负责空间中对象的构造与析构
  4. template<class T, class Alloc>
  5. class simple_alloc
  6. {
  7. public:
  8. 	// 申请n个T类型对象大小的空间
  9. 	static T* allocate(size_t n)
  10. 	{
  11. 		return 0 == n ? 0 : (T*)Alloc::allocate(n * sizeof(T));
  12. 	}
  13.  
  14. 	// 申请一个T类型对象大小的空间
  15. 	static T* allocate(void)
  16. 	{
  17. 		return (T*)Alloc::allocate(sizeof(T));
  18. 	}
  19.  
  20. 	// 释放n个T类型对象大小的空间
  21. 	static void deallocate(T* p, size_t n)
  22. 	{
  23. 		if (0 != n)
  24. 			Alloc::deallocate(p, n * sizeof(T));
  25. 	}
  26.  
  27. 	// 释放一个T类型对象大小的空间
  28. 	static void deallocate(T* p)
  29. 	{
  30. 		Alloc::deallocate(p, sizeof(T));
  31. 	}
  32. };

3.5 -> 对象的构造与释放

一切为了效率考虑。SGI-STL决定将空间申请释放和对象的构造析构两个过程分离开，因为有些对象的构造不需要调用析构函数，销毁时不需要调用析构函数，将该过程分离开可以提高程序的性能：

  1. // 归还空间时，先先调用该函数将对象中资源清理掉
  2. template <class T>
  3. inline void destroy(T* pointer)
  4. {
  5. 	pointer->~T();
  6. }
  7.  
  8. // 空间申请好后调用该函数：利用placement-new完成对象的构造
  9. template <class T1, class T2>
  10. inline void construct(T1* p, const T2& value)
  11. {
  12. 	new (p) T1(value);
  13. }

注意：

  1. 在释放对象时，需要根据对象的类型确定是否调用析构函数(类型萃取)。
  2. 对象的类型可以通过迭代器萃取到。

4 -> 与容器结合

给出list与空间配置器的结合例子：

  1. template <class T, class Alloc>
  2. class list
  3. {
  4. 	// ...
  5. 	// 实例化空间配置器
  6. 	typedef simple_alloc<list_node, Alloc> list_node_allocator;
  7. 	// ...
  8.  
  9. protected:
  10. 	link_type get_node()
  11. 	{
  12. 		// 调用空间配置器接口先申请节点的空间
  13. 		return list_node_allocator::allocate();
  14. 	}
  15.  
  16. 	// 将节点归还给空间配置器
  17. 	void put_node(link_type p)
  18. 	{
  19. 		list_node_allocator::deallocate(p);
  20. 	}
  21.  
  22. 	// 创建节点：1. 申请空间 2. 完成节点构造
  23. 	link_type create_node(const T& x)
  24. 	{
  25. 		link_type p = get_node();
  26. 		construct(&p->data, x);
  27. 		return p;
  28. 	}
  29.  
  30. 	// 销毁节点： 1. 调用析构函数清理节点中资源 2. 将节点空间归还给空间配置器
  31. 	void destroy_node(link_type p)
  32. 	{
  33. 		destroy(&p->data);
  34. 		put_node(p);
  35. 	}
  36.  
  37. 	// ...
  38. 	iterator insert(iterator position, const T& x)
  39. 	{
  40. 		link_type tmp = create_node(x);
  41. 		tmp->next = position.node;
  42. 		tmp->prev = position.node->prev;
  43. 		(link_type(position.node->prev))->next = tmp;
  44. 		position.node->prev = tmp;
  45.  
  46. 		return tmp;
  47. 	}
  48.  
  49. 	iterator erase(iterator position)
  50. 	{
  51. 		link_type next_node = link_type(position.node->next);
  52. 		link_type prev_node = link_type(position.node->prev);
  53. 		prev_node->next = next_node;
  54. 		next_node->prev = prev_node;
  55. 		destroy_node(position.node);
  56.  
  57. 		return iterator(next_node);
  58. 	}
  59. 	// ...
  60. };

感谢各位大佬支持！！！

互三啦！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/976536
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号