• C++项目：【高并发内存池】

    文章目录

    一、项目介绍

    二、什么是内存池

    1.池化技术

    2.内存池

    3.内存池主要解决的问题

    4.malloc

    三、定长的内存池

    四、高并发内存池整体框架设计

    1.高并发内存池--thread cache

    1.1申请内存：

    1.2释放内存：

    1.3用TLS实现thread cache无锁访问

    1.4thread cache代码框架：

    1.5自由链表的哈希桶跟对象大小的映射关系

    2.高并发内存池--central cache

    1.1申请内存：

    1.2释放内存：

    1.3central cache代码框架：

    1.4以页为单位的大内存管理Span的定义及Spanlist定义

    1.5慢开始反馈调节算法 

    3.高并发内存池--page cache

    1.1申请内存：

    1.2释放内存：

    1.3page cache代码框架：

    五、封装申请内存函数

    六、详解内存释放

    1.thread cache回收内存

    2.central cache回收内存

    3.page cache回收内存

    七、封装释放内存函数

    八、使用定长内存池优化定长对象的申请

    九、多线程并发环境下，与malloc进行申请和释放内存效率对比

    十、性能瓶颈分析

    十一、使用tcmalloc源码中实现基数树进行优化

    1.介绍基数树

    2.优化代码

    3.为什么读取基数树映射关系时不需要加锁？

    4.再次对比malloc进行测试

    十二、打包成动静态库

    十三、项目源码

    一、项目介绍

            当前项目是实现一个高并发的内存池，他的原型是google的一个开源项目tcmalloc，tcmalloc全称
    Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替代系统的内存分配相关的函数（malloc、free）

    • tcmalloc的知名度也是非常高的，不少公司都在用它，比如Go语言就直接用它做了自己的内存分配器。
    • 该项目就是把tcmalloc中最核心的框架简化后拿出来，模拟实现出一个mini版的高并发内存池，目的就是学习tcmalloc的精华。
    • 该项目主要涉及C/C++、数据结构（链表、哈希桶）、操作系统内存管理、单例模式、多线程、互斥锁等方面的技术。

    二、什么是内存池

    1.池化技术

            所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次申请该资源都有较大的开销，不如提前申请好了，这样使用时就会变得非常快捷，大大提高程序运行效率。

            在计算机中，有很多使用“池”这种技术的地方，除了内存池，还有连接池、线程池、对象池等。以服务器上的线程池为例，它的主要思想是：先启动若干数量的线程，让它们处于睡眠状态，当接收到客户端的请求时，唤醒池中某个睡眠的线程，让它来处理客户端的请求，当处理完这个请求，线程又进入睡眠状态。

    2.内存池

            内存池是指程序预先从操作系统申请一块足够大内存，此后，当程序中需要申请内存的时候，不是直接向操作系统申请，而是直接从内存池中获取；同理，当程序释放内存的时候，并不真正将内存返回给操作系统，而是返回内存池。当程序退出(或者特定时间)时，内存池才将之前申请的内存真正释放。

    3.内存池主要解决的问题

            内存池主要解决的就是效率的问题，它能够避免让程序频繁的向系统申请和释放内存。其次，内存池作为系统的内存分配器，还需要尝试解决内存碎片的问题。

    内存碎片分为内部碎片和外部碎片：

    • 外部碎片是一些空闲的小块内存区域，由于这些内存空间不连续，以至于合计的内存足够，但是不能满足一些内存分配申请需求。

    • 内部碎片是由于一些对齐的需求，导致分配出去的空间中一些内存无法被利用。

    注意： 内存池尝试解决的是外部碎片的问题，同时也尽可能的减少内部碎片的产生。

    4.malloc

    C/C++中我们要动态申请内存并不是直接去堆申请的，而是通过malloc函数去申请的，包括C++中的new实际上也是封装了malloc函数的。

    我们申请内存块时是先调用malloc，malloc再去向操作系统申请内存。malloc实际就是一个内存池，malloc相当于向操作系统“批发”了一块较大的内存空间，然后“零售”给程序用，当全部“售完”或程序有大量的内存需求时，再根据实际需求向操作系统“进货”。malloc的实现方式有很多种，一般不同编译器平台用的都是不同的。比如windows的vs系列用的微软自己写的一套，linux gcc用的glibc中的ptmalloc。

    三、定长的内存池

    作为程序员(C/C++)我们知道申请内存使用的是malloc，malloc其实就是一个通用的大众货，什么场景下都可以用，但是什么场景下都可以用就意味着什么场景下都不会有很高的性能，下面我们就先来设计一个定长内存池做个开胃菜，当然这个定长内存池在我们后面的高并发内存池中也是有价值的，所以学习他目的有两层，先熟悉一下简单内存池是如何控制的，第二他会作为我们后面内存池的一个基础组件。

    如何实现定长？

            在实现定长内存池时要做到“定长”有很多种方法，比如我们可以使用非类型模板参数，使得在该内存池中申请到的对象的大小都是N。

    1. template<size_t N>
    2. class ObjectPool
    3. {};

            此外，定长内存池也叫做对象池，在创建对象池时，对象池可以根据传入的对象类型的大小来实现“定长”，因此我们可以通过使用模板参数来实现“定长”，比如创建定长内存池时传入的对象类型是int，那么该内存池就只支持4字节大小内存的申请和释放。

    1. template<class T>
    2. class ObjectPool
    3. {};

    如何直接向堆申请空间？

            既然是内存池，那么我们首先得向系统申请一块内存空间，然后对其进行管理。要想直接向堆申请内存空间，在Windows下，可以调用VirtualAlloc函数；在Linux下，可以调用brk或mmap函数。

    1. #ifdef _WIN32
    2. 	#include 
    3. #else
    4. 	//...
    5. #endif
    6.  
    7. //直接去堆上申请按页申请空间
    8. inline static void* SystemAlloc(size_t kpage)
    9. {
    10. #ifdef _WIN32
    11. 	void* ptr = VirtualAlloc(0, kpage<<13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    12. #else
    13. 	// linux下brk mmap等
    14. #endif
    15. 	if (ptr == nullptr)
    16. 		throw std::bad_alloc();
    17. 	return ptr;
    18. }

            这里我们可以通过条件编译将对应平台下向堆申请内存的函数进行封装，此后我们就不必再关心当前所在平台，当我们需要直接向堆申请内存时直接调用我们封装后的SystemAlloc函数即可。 

    定长内存池中应该包含哪些成员变量？

    对于向堆申请到的大块内存，我们可以用一个指针来对其进行管理，但仅用一个指针肯定是不够的，我们还需要用一个变量来记录这块内存的长度。

      由于此后我们需要将这块内存进行切分，为了方便切分操作，指向这块内存的指针最好是字符指针，因为指针的类型决定了指针向前或向后走一步有多大距离，对于字符指针来说，当我们需要向后移动n个字节时，直接对字符指针进行加n操作即可。

            其次，释放回来的定长内存块也需要被管理，我们可以将这些释放回来的定长内存块链接成一个链表，这里我们将管理释放回来的内存块的链表叫做自由链表，为了能找到这个自由链表，我们还需要一个指向自由链表的指针。

    因此，定长内存池当中包含三个成员变量：

    • _memory：指向大块内存的指针。
    • _remainBytes：大块内存切分过程中剩余字节数。
    • _freeList：还回来过程中链接的自由链表的头指针。

    内存池如何管理释放的对象？

            对于还回来的定长内存块，我们可以用自由链表将其链接起来，但我们并不需要为其专门定义链式结构，我们可以让内存块的前4个字节（32位平台）或8个字节（64位平台）作为指针，存储后面内存块的起始地址即可。

      因此在向自由链表插入被释放的内存块时，先让该内存块的前4个字节或8个字节存储自由链表中第一个内存块的地址，然后再让 _freeList 指向该内存块即可，也就是一个简单的链表头插操作。

    这里有一个有趣问题：如何让一个指针在32位平台下解引用后能向后访问4个字节，在64位平台下解引用后能向后访问8个字节？

      首先我们得知道，32位平台下指针的大小是4个字节，64位平台下指针的大小是8个字节。而指针指向数据的类型，决定了指针解引用后能向后访问的空间大小，因此我们这里需要的是一个指向指针的指针，这里使用二级指针就行了。

      当我们需要访问一个内存块的前4 or 8个字节时，我们可以将该内存块的地址先强转为二级指针，由于二级指针存储的是一级指针的地址，二级指针解引用能向后访问一个指针的大小，因此在32位平台下访问的就是4个字节，在64位平台下访问的就是8个字节，此时我们访问到了该内存块的前4 or 8个字节。

    1. // 获取内存对象中存储的头4 or 8字节值，即链接的下一个对象的地址
    2. void*& NextObj(void* ptr)
    3. {
    4. 	return (*(void**)ptr);
    5. }

    需要注意的是，在释放对象时，我们应该显示调用该对象的析构函数清理该对象，因为该对象可能还管理着其他某些资源，如果不对其进行清理那么这些资源将无法被释放，就会导致内存泄漏。

    1. //释放对象
    2. void Delete(T* obj)
    3. {
    4. 	//显示调用T的析构函数清理对象
    5. 	obj->~T();
    6.  
    7. 	//将释放的对象头插到自由链表
    8. 	NextObj(obj) = _freeList;
    9. 	_freeList = obj;
    10. }

    内存池如何为我们申请对象？

            当我们申请对象时，内存池应该优先把还回来的内存块对象再次重复利用，因此如果自由链表当中有内存块的话，就直接从自由链表头删一个内存块进行返回即可。

    如果自由链表当中没有内存块，那么我们就在大块内存中切出定长的内存块进行返回，当内存块切出后及时更新_memory指针的指向，以及_remainBytes的值即可。

            需要特别注意的是，由于当内存块释放时我们需要将内存块链接到自由链表当中，因此我们必须保证切出来的对象至少能够存储得下一个地址，所以当对象的大小小于当前所在平台指针的大小时，需要按指针的大小进行内存块的切分。

      此外，当大块内存已经不足以切分出一个对象时，我们就应该调用我们封装的SystemAlloc函数，再次向堆申请一块内存空间，此时也要注意及时更新_memory指针的指向，以及_remainBytes的值。

    1. // 申请内存
    2. T* New()
    3. {
    4. 	T* obj = nullptr;
    5.  
    6. 	// 优先把还回来内存块对象，再次重复利用
    7. 	if (_freeList != nullptr)
    8. 	{
    9. 		obj = (T*)_freeList;
    10. 		_freeList = NextObj(_freeList);
    11. 	}
    12. 	else
    13. 	{
    14. 		// 剩余内存不够一个对象大小时，则重新开一大块空间
    15. 		if (_remainBytes < sizeof(T))
    16. 		{
    17. 			_remainBytes = 128 * 1024;
    18. 			_memory = (char*)SystemAlloc(_remainBytes >> 13); // _memory = (char*)malloc(_remainBytes);
    19.  
    20. 			if (_memory == nullptr)
    21. 			{
    22. 				// 如果申请失败，就抛异常
    23. 				throw std::bad_alloc();
    24. 			}
    25. 		}
    26.  
    27. 		obj = (T*)_memory;
    28. 		size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T); // 如果申请的空间小于一个指针的大小，就直接给一个指针的大小，这样当内存还回来的时候，就能存下一个指针了
    29. 		_memory += objSize;
    30. 		_remainBytes -= objSize;
    31. 	}
    32.  
    33. 	// 定位new，显示调用T的构造函数的初始化
    34. 	new(obj)T;
    35.  
    36. 	return obj;
    37. }

     需要注意的是，与释放对象时需要显示调用该对象的析构函数一样，当内存块切分出来后，我们也应该使用定位new，显示调用该对象的构造函数对其进行初始化。

    定长内存池整体代码如下：

    1. template<class T>
    2. class ObjectPool
    3. {
    4. public:
    5. 	// 申请内存
    6. 	T* New()
    7. 	{
    8. 		T* obj = nullptr;
    9.  
    10. 		// 优先把还回来内存块对象，再次重复利用
    11. 		if (_freeList != nullptr)
    12. 		{
    13. 			obj = (T*)_freeList;
    14. 			_freeList = NextObj(_freeList);
    15. 		}
    16. 		else
    17. 		{
    18. 			// 剩余内存不够一个对象大小时，则重新开一大块空间
    19. 			if (_remainBytes < sizeof(T))
    20. 			{
    21. 				_remainBytes = 128 * 1024;
    22. 				_memory = (char*)SystemAlloc(_remainBytes >> 13); // _memory = (char*)malloc(_remainBytes);
    23.  
    24. 				if (_memory == nullptr)
    25. 				{
    26. 					// 如果申请失败，就抛异常
    27. 					throw std::bad_alloc();
    28. 				}
    29. 			}
    30.  
    31. 			obj = (T*)_memory;
    32. 			size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T); // 如果申请的空间小于一个指针的大小，就直接给一个指针的大小，这样当内存还回来的时候，就能存下一个指针了
    33. 			_memory += objSize;
    34. 			_remainBytes -= objSize;
    35. 		}
    36.  
    37. 		// 定位new，显示调用T的构造函数的初始化
    38. 		new(obj)T;
    39.  
    40. 		return obj;
    41. 	}
    42.  
    43. 	// 还回内存
    44. 	void Delete(T* obj)
    45. 	{
    46. 		// 显示调用析构函数
    47. 		obj->~T();
    48.  
    49. 		// 头插（这里第一次和第n次都可以用头插的方法）
    50. 		NextObj(obj) = _freeList; 
    51. 		_freeList = obj; 
    52. 	}
    53. private:
    54. 	char* _memory = nullptr;   // 指向大块内存的指针
    55. 	size_t _remainBytes = 0;   // 大块内存在切分过程中剩余的字节数
    56.  
    57. 	void* _freeList = nullptr; // 还回来过程中链接的自由链表的头指针
    58. };

    性能对比

    下面我们将实现的定长内存池和malloc/free进行性能对比，测试代码如下：

    1. struct TreeNode
    2. {
    3. 	int _val;
    4. 	TreeNode* _left;
    5. 	TreeNode* _right;
    6. 	TreeNode()
    7. 		:_val(0)
    8. 		, _left(nullptr)
    9. 		, _right(nullptr)
    10. 	{}
    11. };
    12.  
    13. void TestObjectPool()
    14. {
    15. 	// 申请释放的轮次
    16. 	const size_t Rounds = 3;
    17. 	// 每轮申请释放多少次
    18. 	const size_t N = 1000000;
    19. 	std::vector v1;
    20. 	v1.reserve(N);
    21.  
    22. 	//malloc和free
    23. 	size_t begin1 = clock();
    24. 	for (size_t j = 0; j < Rounds; ++j)
    25. 	{
    26. 		for (int i = 0; i < N; ++i)
    27. 		{
    28. 			v1.push_back(new TreeNode);
    29. 		}
    30. 		for (int i = 0; i < N; ++i)
    31. 		{
    32. 			delete v1[i];
    33. 		}
    34. 		v1.clear();
    35. 	}
    36. 	size_t end1 = clock();
    37.  
    38. 	//定长内存池
    39. 	ObjectPool TNPool;
    40. 	std::vector v2;
    41. 	v2.reserve(N);
    42. 	size_t begin2 = clock();
    43. 	for (size_t j = 0; j < Rounds; ++j)
    44. 	{
    45. 		for (int i = 0; i < N; ++i)
    46. 		{
    47. 			v2.push_back(TNPool.New());
    48. 		}
    49. 		for (int i = 0; i < N; ++i)
    50. 		{
    51. 			TNPool.Delete(v2[i]);
    52. 		}
    53. 		v2.clear();
    54. 	}
    55. 	size_t end2 = clock();
    56.  
    57. 	cout << "new cost time:" << end1 - begin1 << endl;
    58. 	cout << "object pool cost time:" << end2 - begin2 << endl;
    59. }

            在代码中，我们先用new申请若干个TreeNode对象，然后再用delete将这些对象再释放，通过clock函数得到整个过程消耗的时间。（new和delete底层就是封装的malloc和free）

      然后再重复该过程，只不过将其中的new和delete替换为定长内存池当中的New和Delete，此时再通过clock函数得到该过程消耗的时间。  

          可以看到在这个过程中，定长内存池消耗的时间比malloc/free消耗的时间要短。这就是因为malloc是一个通用的内存池，而定长内存池是专门针对申请定长对象而设计的，因此在这种特殊场景下定长内存池的效率更高，正所谓“尺有所短，寸有所长”。

    四、高并发内存池整体框架设计

    现代很多的开发环境都是多核多线程，在申请内存的场景下，必然存在激烈的锁竞争问题。malloc本身其实已经很优秀，那么我们项目的原型tcmalloc就是在多线程高并发的场景下更胜一筹，所以这次我们实现的内存池需要考虑以下几方面的问题。

    1. 性能问题。
    2. 多线程环境下，锁竞争问题。
    3. 内存碎片问题。

    concurrent memory pool主要由以下3个部分构成：

    1. thread cache：线程缓存是每个线程独有的，用于小于256KB的内存的分配，线程从这里申请内存不需要加锁，每个线程独享一个cache，这也就是这个并发线程池高效的地方。
    2. central cache：中心缓存是所有线程所共享，thread cache是按需从central cache中获取的对象。central cache合适的时机回收thread cache中的对象，避免一个线程占用了太多的内存，而其他线程的内存吃紧，达到内存分配在多个线程中更均衡的按需调度的目的。central cache是存在竞争的，所以从这里取内存对象是需要加锁，首先这里用的是桶锁，其次只有thread cache的没有内存对象时才会找central cache，所以这里竞争不会很激烈。
    3. page cache：页缓存是在central cache缓存上面的一层缓存，存储的内存是以页为单位存储及分配的，central cache没有内存对象时，从page cache分配出一定数量的page，并切割成定长大小的小块内存，分配给central cache。当一个span的几个跨度页的对象都回收以后，page cache会回收central cache满足条件的span对象，并且合并相邻的页，组成更大的页，缓解内存碎片的问题。

    1.高并发内存池--thread cache

    thread cache是哈希桶结构，每个桶是一个按桶位置映射大小的内存块对象的自由链表。每个线程都会有一个thread cache对象，这样每个线程在这里获取对象和释放对象时是无锁的。

    1.1申请内存：

    1. 当内存申请size<=256KB，先获取到线程本地存储的thread cache对象，计算size映射的哈希桶自由链表下标i。
    2. 如果自由链表_freeLists[i]中有对象，则直接Pop一个内存对象返回。
    3. 如果_freeLists[i]中没有对象时，则批量从central cache中获取一定数量的对象，插入到自由链表并返回一个对象。

    1.2释放内存：

    1. 当释放内存小于256k时将内存释放回thread cache，计算size映射自由链表桶位置i，将对象Push到_freeLists[i]。
    2. 当链表的长度过长，则回收一部分内存对象到central cache。

    1.3用TLS实现thread cache无锁访问

      每个线程都有一个自己独享的thread cache，那应该如何创建这个thread cache呢？我们不能将这个thread cache创建为全局的，因为全局变量是所有线程共享的，这样就不可避免的需要锁来控制，增加了控制成本和代码复杂度。

      要实现每个线程无锁的访问属于自己的thread cache，我们需要用到线程局部存储TLS(Thread Local Storage)，这是一种变量的存储方法，使用该存储方法的变量在它所在的线程是全局可访问的，但是不能被其他线程访问到，这样就保持了数据的线程独立性。

    1. //TLS - Thread Local Storage
    2. static _declspec(thread) ThreadCache* pTLSThreadCache = nullptr;

      但不是每个线程被创建时就立马有了属于自己的thread cache，而是当该线程调用相关申请内存的接口时才会创建自己的thread cache，因此在申请内存的函数中会包含以下逻辑。

    1. //通过TLS，每个线程无锁的获取自己专属的ThreadCache对象
    2. if (pTLSThreadCache == nullptr)
    3. {
    4. 	pTLSThreadCache = new ThreadCache;
    5. }

    1.4thread cache代码框架：

    1. class ThreadCache
    2. {
    3. public:
    4. 	// 申请内存对象
    5. 	void* Allocate(size_t size);
    6.  
    7. 	// 释放内存对象
    8. 	void Deallocate(void* ptr, size_t size);
    9.  
    10. 	// 从中心缓存获取对象
    11. 	void* FetchFromCentralCache(size_t index, size_t size);
    12.  
    13. 	// 释放对象时，链表过长时，回收内存回到中心缓存
    14. 	void ListTooLong(FreeList& list, size_t size);
    15. private:
    16. 	FreeList _freeLists[NFREELIST]; // 存储自由链表的哈希表
    17. };
    18.  
    19. // TLS thread local storage
    20. static _declspec(thread) ThreadCache* pTLSThreadCache = nullptr; // 用TLS保证每个线程独享一个thread cache
    21.  
    22.  
    23.  
    24. // 管理切分好的小对象的自由链表
    25. class FreeList
    26. {
    27. public:
    28. 	// 插入对象
    29. 	void Push(void* obj)
    30. 	{
    31. 		assert(obj);
    32.  
    33. 		// 头插
    34. 		NextObj(obj) = _freeList; // 用obj头4个(或8个)字节存储下一个节点的地址
    35. 		_freeList = obj;
    36.  
    37. 		++_size;
    38. 	}
    39.  
    40. 	// 给n个连续对象进行插入
    41. 	// start->node->....->node->end
    42. 	void PushRange(void* start, void* end, size_t n)
    43. 	{
    44. 		NextObj(end) = _freeList;
    45. 		_freeList = start;
    46.  
    47. 		_size += n;
    48. 	}
    49.  
    50. 	// 将n个连续对象进行弹出
    51. 	// start->node->....->node->end
    52. 	void PopRange(void*& start, void*& end, size_t n)
    53. 	{
    54. 		assert(n <= _size);
    55. 		
    56. 		start = _freeList;
    57. 		end = start;
    58.  
    59. 		for (size_t i = 0; i < n - 1; ++i)
    60. 		{
    61. 			end = NextObj(end);
    62. 		}
    63.  
    64. 		_freeList = NextObj(end);
    65. 		NextObj(end) = nullptr;
    66. 		_size -= n;
    67. 	}
    68.  
    69. 	// 弹出对象
    70. 	void* Pop()
    71. 	{
    72. 		assert(_freeList);
    73.  
    74. 		// 头删
    75. 		void* obj = _freeList;
    76. 		_freeList = NextObj(obj);
    77. 		--_size;
    78.  
    79. 		return obj;
    80. 	}
    81.  
    82. 	// 判断自由链表是否为空
    83. 	bool Empty()
    84. 	{
    85. 		return _freeList == nullptr;
    86. 	}
    87.  
    88. 	size_t& MaxSize()
    89. 	{
    90. 		return _maxSize;
    91. 	}
    92.  
    93. 	size_t Size()
    94. 	{
    95. 		return _size;
    96. 	}
    97.  
    98. private:
    99. 	void* _freeList = nullptr;
    100. 	size_t _maxSize = 1; // 当前自由链表节点的个数上限
    101. 	size_t _size = 0;	 // 记录自由链表当前节点的个数
    102. };

    1.5自由链表的哈希桶跟对象大小的映射关系

    thread cache支持小于等于256KB内存的申请，如果我们将每种字节数的内存块都用一个自由链表进行管理的话，那么此时我们就需要20多万个自由链表，光是存储这些自由链表的头指针就需要消耗大量内存，这显然是得不偿失的。

    这时我们可以选择做一些平衡的牺牲，让这些字节数按照某种规则进行对齐。

    如何进行对齐？

    首先，这些内存块是会被链接到自由链表上的，因此一开始肯定是按8字节进行对齐是最合适的，因为我们必须保证这些内存块，无论是在32位平台下还是64位平台下，都至少能够存储得下一个指针。

      但如果所有的字节数都按照8字节进行对齐的话，那么我们就需要建立256 × 1024 ÷ 8 = 32768个桶，这个数量还是比较多的，实际上我们可以让不同范围的字节数按照不同的对齐数进行对齐，具体对齐方式如下：

    字节数对齐数哈希桶下标
    [ 1，128 ]8[ 0，16 )
    [ 128+1，1024 ]16[ 16，72 )
    [ 1024+1，8×1024 ]128[ 72，128 )
    [ 8×1024+1，64×1024 ]1024[ 128，184 )
    [ 64×1024+1，256×1024 ]8×1024[ 184，208 )

    但此时由于对齐的原因，就可能会产生一些碎片化的内存无法被利用，比如线程只申请了6字节的内存，而thread cache却直接给了8字节的内存，这多给出的2字节就无法被利用，导致了一定程度的空间浪费，这些因为某些对齐原因导致无法被利用的内存，就是内存碎片中的内部碎片。

    计算空间浪费率：空间浪费率 = 浪费的字节数 ÷ 对齐后的字节数

    虽然对齐产生的内碎片会引起一定程度的空间浪费，但按照上面的对齐规则，我们可以将浪费率控制到百分之十左右。需要说明的是，1~128这个区间我们不做讨论，因为1字节就算是对齐到2字节也有百分之五十的浪费率，这里我们就从第二个区间开始进行计算。

    根据上面的公式，我们要得到某个区间的最大浪费率，就应该让分子取到最大，让分母取到最小。比如[ 1024+1，8×1024 ]这个区间，该区域的对齐数是128，那么最大浪费的字节数就是127，而最小对齐后的字节数就是这个区间内的前128个数所对齐到的字节数，也就是1152，那么该区间的最大浪费率也就是127 ÷ 1152 ≈ 11.02% 。同样的道理，后面两个区间的最大浪费率分别是1023 ÷ 9216 ≈ 11.10% 和 8191 ÷ 73728 ≈ 11.11%。

    1. // 小于等于MAX_BYTES，就找thread cache申请
    2. // 大于MAX_BYTES，就直接找page cache或者系统堆申请
    3. static const size_t MAX_BYTES = 256 * 1024; // ThreadCache最多可以分配的空间为256kb
    4. static const size_t NFREELIST = 208;		// thread cache 和 central cache自由链表哈希桶的表大小
    5. static const size_t NPAGES = 129;			// page cache 管理span list哈希表大小（一个page chache中一个span最大能有129页）
    6. static const size_t PAGE_SHIFT = 13;		// 页大小转换偏移, 即一页定义为2^13,也就是8KB
    7.  
    8. // 页编号类型，32位下是4byte类型，64位下是8byte类型
    9. #ifdef _WIN32
    10. typedef size_t PageID;
    11. #else
    12. typedef unsigned long long PageID;
    13. #endif // _WIN32
    14.  
    15. // 获取内存对象中存储的头4 or 8字节值，即链接的下一个对象的地址
    16. inline void*& NextObj(void* obj)
    17. {
    18.     return *((void**)obj);
    19. }
    20.  
    21. // 计算对象大小的对齐映射规则
    22. class SizeClass
    23. {
    24. public:
    25. 	// 整体控制在最多10%左右的内碎片浪费
    26. 	// [1,128]					8byte对齐			freelist[0,16)
    27. 	// [128+1,1024]				16byte对齐			freelist[16,72)
    28. 	// [1024+1,8*1024]			128byte对齐			freelist[72,128)
    29. 	// [8*1024+1,64*1024]		1024byte对齐			freelist[128,184)
    30. 	// [64*1024+1,256*1024]		8*1024byte对齐		freelist[184,208)
    31.  
    32. 	// 参数：对象大小bytes，对齐数AlignNum
    33. 	static inline size_t _RoundUp(size_t bytes, size_t AlignNum)
    34. 	{
    35. 		// 原理：对象为任何大小，都先加上他对应的(对齐数-1），然后再抹去多加出来的
    36. 		// 例如：bytes=7,AlignNum=8，7+(8-1)=15，然后抹去多加出来的6，也就是15-6=8
    37. 		return (bytes + AlignNum - 1) & ~(AlignNum - 1);
    38. 	}
    39. 	
    40. 	// 计算对齐后对象的大小
    41. 	static inline size_t RoundUp(size_t size)
    42. 	{
    43. 		if (size <= 128)
    44. 		{
    45. 			return _RoundUp(size, 8);
    46. 		}
    47. 		else if (size <= 1024)
    48. 		{
    49. 			return _RoundUp(size, 16);
    50. 		}
    51. 		else if (size <= 8 * 1024)
    52. 		{
    53. 			return _RoundUp(size, 128);
    54. 		}
    55. 		else if (size <= 64 * 1024)
    56. 		{
    57. 			return _RoundUp(size, 1024);
    58. 		}
    59. 		else if (size <= 256 * 1024)
    60. 		{
    61. 			return _RoundUp(size, 8 * 1024);
    62. 		}
    63. 		else
    64. 		{
    65. 			return _RoundUp(size, 1 << PAGE_SHIFT);
    66. 		}
    67. 	}
    68.  
    69. 	// 参数：对象大小bytes，其对应的对齐数转化成2的align_shift次方
    70. 	static inline size_t _Index(size_t bytes, size_t align_shift)
    71. 	{
    72. 		return ((bytes + (1 << align_shift) - 1) >> align_shift) - 1;
    73. 	}
    74.  
    75. 	// 计算映射的哪一个自由链表桶
    76. 	static inline size_t Index(size_t bytes)
    77. 	{
    78. 		assert(bytes <= MAX_BYTES);
    79.  
    80. 		// 每个区间有多少个链
    81. 		static int group_array[4] = { 16, 56, 56, 56 };
    82. 		if (bytes <= 128) {
    83. 			return _Index(bytes, 3);
    84. 		}
    85. 		else if (bytes <= 1024) {
    86. 			return _Index(bytes - 128, 4) + group_array[0];
    87. 		}
    88. 		else if (bytes <= 8 * 1024) {
    89. 			return _Index(bytes - 1024, 7) + group_array[1] + group_array[0];
    90. 		}
    91. 		else if (bytes <= 64 * 1024) {
    92. 			return _Index(bytes - 8 * 1024, 10) + group_array[2] + group_array[1]
    93. 				+ group_array[0];
    94. 		}
    95. 		else if (bytes <= 256 * 1024) {
    96. 			return _Index(bytes - 64 * 1024, 13) + group_array[3] +
    97. 				group_array[2] + group_array[1] + group_array[0];
    98. 		}
    99. 		else {
    100. 			assert(false);
    101. 		}
    102. 		return -1;
    103. 	}
    104.  
    105. 	// thread cache一次从中心缓存获取多少个size大小对象的上限数
    106. 	static size_t NumMoveSize(size_t size)
    107. 	{
    108. 		assert(size > 0);
    109.  
    110. 		// [2, 512]，一次批量移动多少个对象的(慢启动)上限值
    111. 		// 小对象一次批量上限高
    112. 		// 大对象一次批量上限低
    113.  
    114. 		int num = MAX_BYTES / size;
    115. 		if (num < 2)
    116. 			num = 2;
    117.  
    118. 		if (num > 512)
    119. 			num = 512;
    120. 		return num;
    121. 	}
    122.  
    123. 	// 计算一次向系统获取几个页
    124. 	// 单个对象 8byte 
    125. 	// ...
    126. 	// 单个对象 256KB
    127. 	static size_t NumMovePage(size_t size)
    128. 	{
    129. 		size_t num = NumMoveSize(size);
    130. 		size_t npage = num * size; // 先算出总的字节数
    131. 	
    132. 		npage >>= PAGE_SHIFT;	   // 再算出需要的页数
    133. 		if (npage == 0)
    134. 			npage = 1;
    135. 		
    136. 		return npage;
    137. 	}
    138. };

    2.高并发内存池--central cache

            central cache也是一个哈希桶结构，他的哈希桶的映射关系跟thread cache是一样的。不同的是他的每个哈希桶位置挂是SpanList链表结构，不过每个映射桶下面的span中的大内存块被按映射关系切成了一个个小内存块对象挂在span的自由链表中。

            central cache在加锁时并不是将整个central cache全部锁上了，central cache在加锁时用的是桶锁，也就是说每个桶都有一个锁。此时只有当多个线程同时访问central cache的同一个桶时才会存在锁竞争，如果是多个线程同时访问central cache的不同桶就不会存在锁竞争。

    1.1申请内存：

    1. 当thread cache中没有内存时，就会批量向central cache申请一些内存对象，这里的批量获取对象的数量使用了类似网络tcp协议拥塞控制的慢开始算法；central cache也有一个哈希映射的spanlist，spanlist中挂着span，从span中取出对象给thread cache，这个过程是需要加锁的，不过这里使用的是一个桶锁，尽可能提高效率。
    2. central cache映射的spanlist中所有span的都没有内存以后，则需要向page cache申请一个新的span对象，拿到span以后将span管理的内存按大小切好作为自由链表链接到一起。然后从span中取对象给thread cache。
    3. central cache的中挂的span中use_count记录分配了多少个对象出去，分配一个对象给thread cache，就++use_count。

    1.2释放内存：

    1. 当thread_cache过长或者线程销毁，则会将内存释放回central cache中的，释放回来时--use_count。当use_count减到0时则表示所有对象都回到了span，则将span释放回page cache，page cache中会对前后相邻的空闲页进行合并。

    1.3central cache代码框架：

    每个线程都有一个属于自己的thread cache，我们是用TLS来实现每个线程无锁的访问属于自己的thread cache的。而central cache和page cache在整个进程中只有一个，对于这种只能创建一个对象的类，我们可以将其设置为单例模式。

      单例模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。单例模式又分为饿汉模式和懒汉模式，懒汉模式相对较复杂，我们这里使用饿汉模式就足够了。

    1. // 设计成单例模式，因为全局只有这一个CentralCache
    2. class CentralCache
    3. {
    4. public:
    5. 	static CentralCache* GetInstance()
    6. 	{
    7. 		return &_sInst;
    8. 	}
    9.  
    10. 	// 获取一个非空的span
    11. 	Span* GetOneSpan(SpanList& list, size_t size);
    12.  
    13. 	// 从中心缓存获取一定数量的对象给thread cache
    14. 	size_t FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size);
    15.  
    16. 	// 将一定数量的对象释放到span跨度
    17. 	void ReleaseListToSpans(void* start, size_t size);
    18. private:
    19. 	SpanList _spanLists[NFREELIST]; // 结构与thread cache一样
    20. private:
    21. 	CentralCache()
    22. 	{}
    23.  
    24. 	CentralCache(const CentralCache&) = delete;
    25.  
    26. 	static CentralCache _sInst;
    27. };

    1.4以页为单位的大内存管理Span的定义及Spanlist定义

    Span的结构

    1. // Span管理一个跨度的大块内存
    2. // 管理以页为单位的大块内存
    3. // 管理多个连续页大块内存跨度结构
    4. struct Span
    5. {
    6. 	PAGE_ID _pageId = 0;			// 大块内存起始页的页号（在32位下，4g内存被分成2^19个页，假如一个页8k）
    7. 	size_t _n = 0;				// 页的数量
    8.  
    9. 	Span* _next = nullptr;	    // 双向链表的结构
    10. 	Span* _prev = nullptr;
    11.  
    12. 	size_t _objSize = 0;		// 切好的小对象的大小
    13. 	size_t _useCount = 0;		// 切好小块内存，被分配个thread cache的计数
    14. 	void* _freeList = nullptr;  // 切好的小块内存的自由链表
    15. 	
    16. 	bool _isUse = false;		// 当前span是否在被使用
    17. };

    介绍Span的页号（_pageId）

            对于span管理的以页为单位的大块内存，我们需要知道这块内存具体在哪一个位置，便于之后page cache进行前后页的合并，因此span结构当中会记录所管理大块内存起始页的页号。

      至于每一个span管理的到底是多少个页，这并不是固定的，需要根据多方面的因素来控制，因此span结构当中有一个_n成员，该成员就代表着该span管理的页的数量。

      此外，每个span管理的大块内存，都会被切成相应大小的内存块挂到当前span的自由链表中，比如8Byte哈希桶中的span，会被切成一个个8Byte大小的内存块挂到当前span的自由链表中，因此span结构中需要存储切好的小块内存的自由链表。

    页号的类型是什么？

            每个程序运行起来后都有自己的进程地址空间，在32位平台下，进程地址空间的大小是2^32；而在64位平台下，进程地址空间的大小就是2^64。

            页的大小一般是4K或者8K，我们以8K为例。在32位平台下，进程地址空间就可以被分成2^32 ÷ 2^13 = 2^19个页；在64位平台下，进程地址空间就可以被分成2^64 ÷ 2^13 = 2^51个页。页号本质与地址是一样的，它们都是一个编号，只不过地址是以一个字节为一个单位，而页是以多个字节为一个单位。

            由于页号在64位平台下的取值范围是 [0, 2^51]，因此我们不能简单的用一个无符号整型来存储页号，这时我们需要借助条件编译来解决这个问题。

    1. #ifdef _WIN64
    2. 	typedef unsigned long long PAGE_ID;
    3. #elif _WIN32
    4. 	typedef size_t PAGE_ID;
    5. #else
    6. 	//linux
    7. #endif

    注意：在32位下，_WIN32有定义，_WIN64没有定义；而在64位下，_WIN32和_WIN64都有定义。因此在条件编译时，我们应该先判断_WIN64是否有定义，再判断_WIN32是否有定义。

     介绍Span的_useCount

            span结构当中的_useCount成员记录的就是，当前span中切好的小块内存，被分配给thread cache的计数，当某个span的_useCount计数变为0时，代表当前span切出去的内存块对象全部还回来了，此时central cache就可以将这个span再还给page cache。

    双链表结构的Spanlist

            每个桶当中的span是以双链表的形式组织起来的，当我们需要将某个span归还给page cache时，就可以很方便的将该span从双链表结构中移出。如果用单链表结构的话就比较麻烦了，因为单链表在删除时，需要知道当前结点的前一个结点。 

    1. // 带头双向循环链表
    2. class SpanList
    3. {
    4. public:
    5. 	SpanList()
    6. 	{
    7. 		_head = new Span;
    8. 		_head->_next = _head;
    9. 		_head->_prev = _head;
    10. 	}
    11.  
    12. 	Span* Begin()
    13. 	{
    14. 		return _head->_next;
    15. 	}
    16.  
    17. 	Span* End()
    18. 	{
    19. 		return _head;
    20. 	}
    21.  
    22. 	bool Empty()
    23. 	{
    24. 		return _head->_next == _head;
    25. 	}
    26.  
    27. 	void PushFront(Span* span)
    28. 	{
    29. 		Insert(Begin(), span);
    30. 	}
    31.  
    32. 	Span* PopFront()
    33. 	{
    34. 		Span* front = _head->_next;
    35. 		Erase(front);
    36. 		return front;
    37. 	}
    38.  
    39. 	// 在pos前面插入newSpan
    40. 	void Insert(Span* pos, Span* newSpan)
    41. 	{
    42. 		assert(pos);
    43. 		assert(newSpan);
    44.  
    45. 		Span* prev = pos->_prev;
    46.  
    47. 		// prev <-> newSpan <-> pos
    48. 		prev->_next = newSpan;
    49. 		newSpan->_prev = prev;
    50. 		newSpan->_next = pos;
    51. 		pos->_prev = newSpan;
    52. 	}
    53.  
    54. 	void Erase(Span* pos)
    55. 	{
    56. 		assert(pos);
    57. 		assert(pos != _head);
    58.  
    59. 		Span* prev = pos->_prev;
    60. 		Span* next = pos->_next;
    61.  
    62. 		prev->_next = next;
    63. 		next->_prev = prev;
    64. 	}
    65. private:
    66. 	Span* _head;
    67. public:
    68. 	std::mutex _mtx; // 桶锁
    69. };

     注意：从双链表删除的span会还给下一层的page cache，相当于只是把这个span从双链表中移除，因此不需要对删除的span进行delete操作。

    1.5慢开始反馈调节算法 

            当thread cache向central cache申请内存时，central cache应该给出多少个对象呢？这是一个值得思考的问题，如果central cache给的太少，那么thread cache在短时间内用完了又会来申请；但如果一次性给的太多了，可能thread cache用不完也就浪费了。

      鉴于此，我们这里采用了一个慢开始反馈调节算法。当thread cache向central cache申请内存时，如果申请的是较小的对象，那么可以多给一点，但如果申请的是较大的对象，就可以少给一点。

      通过下面这个函数，我们就可以根据所需申请的对象的大小计算出具体给出的对象个数，并且可以将给出的对象个数控制到2~512个之间。也就是说，就算thread cache要申请的对象再小，我最多一次性给出512个对象；就算thread cache要申请的对象再大，我至少一次性给出2个对象。

    1. //管理对齐和映射等关系
    2. class SizeClass
    3. {
    4. public:
    5. 	// thread cache一次从中心缓存获取多少个size大小对象的上限数
    6. 	static size_t NumMoveSize(size_t size)
    7. 	{
    8. 		assert(size > 0);
    9.  
    10. 		// [2, 512]，一次批量移动多少个对象的(慢启动)上限值
    11. 		// 小对象一次批量上限高
    12. 		// 大对象一次批量上限低
    13.  
    14. 		int num = MAX_BYTES / size;
    15. 		if (num < 2)
    16. 			num = 2;
    17.  
    18. 		if (num > 512)
    19. 			num = 512;
    20. 		return num;
    21. 	}
    22. };

            但就算申请的是小对象，一次性给出512个也是比较多的，基于这个原因，我们可以在FreeList结构中增加一个叫做_maxSize的成员变量，该变量的初始值设置为1，并且提供一个公有成员函数用于获取这个变量。也就是说，现在thread cache中的每个自由链表都会有一个自己的_maxSize。

    1. //管理切分好的小对象的自由链表
    2. class FreeList
    3. {
    4. public:
    5. 	size_t& MaxSize()
    6. 	{
    7. 		return _maxSize;
    8. 	}
    9.  
    10. private:
    11. 	void* _freeList = nullptr; //自由链表
    12. 	size_t _maxSize = 1;
    13. };

            此时当thread cache申请对象时，我们会比较_maxSize和计算得出的值，取出其中的较小值作为本次申请对象的个数。此外，如果本次采用的是_maxSize的值，那么还会将thread cache中该自由链表的_maxSize的值进行加一。

      因此，thread cache第一次向central cache申请某大小的对象时，申请到的都是一个，但下一次thread cache再向central cache申请同样大小的对象时，因为该自由链表中的_maxSize增加了，最终就会申请到两个。直到该自由链表中_maxSize的值，增长到超过计算出的值后就不会继续增长了，此后申请到的对象个数就是计算出的个数。

    3.高并发内存池--page cache

    1.1申请内存：

    1. 当central cache向page cache申请内存时，page cache先检查对应位置有没有span，如果没有则向更大页寻找一个span，如果找到则分裂成两个。比如：申请的是4页page，4页page后面没有挂span，则向后面寻找更大的span，假设在10页page位置找到一个span，则将10页pagespan分裂为一个4页page span和一个6页page span。
    2. 如果找到_spanList[128]都没有合适的span，则向系统使用mmap、brk或者是VirtualAlloc等方式申请128页page span挂在自由链表中，再重复1中的过程。
    3. 需要注意的是central cache和page cache 的核心结构都是spanlist的哈希桶，但是他们是有本质区别的，central cache中哈希桶，是按跟thread cache一样的大小对齐关系映射的，他的spanlist中挂的span中的内存都被按映射关系切好链接成小块内存的自由链表。而page cache 中的spanlist则是按下标桶号映射的，也就是说第i号桶中挂的span都是i页内存。

    1.2释放内存：

    1. 如果central cache释放回一个span，则依次寻找span的前后page id的没有在使用的空闲span，看是否可以合并，如果合并继续向前寻找。这样就可以将切小的内存合并收缩成大的span，减少内存碎片。

    1.3page cache代码框架：

    1. // 1.page cache是一个以页为单位的span自由链表
    2. // 2.为了保证全局只有唯一的page cache，这个类被设计成了单例模式
    3. class PageCache
    4. {
    5. public:
    6. 	static PageCache* GetInstance()
    7. 	{
    8. 		return &_sInst;
    9. 	}
    10.  
    11. 	// 获取从对象到span的映射
    12. 	Span* MapObjectToSpan(void* obj);
    13.  
    14. 	// 释放空闲span回到Pagecache，并合并相邻的span
    15. 	void ReleaseSpanToPageCache(Span* span);
    16.  
    17. 	// 获取一个k页的span
    18. 	Span* NewSpan(size_t k);
    19.  
    20. 	std::mutex _pageMtx; // 全局大锁（这里与central cache不一样）
    21. private:
    22. 	SpanList _spanLists[NPAGES];
    23. 	ObjectPool _spanPool; // 用自己写的方法申请定长span
    24.  
    25. 	std::unordered_map _idSpanMap;  // 页号和span的映射
    26. 	
    27. 	PageCache()
    28. 	{}
    29. 	PageCache(const PageCache&) = delete;
    30.  
    31. 	static PageCache _sInst; 
    32. };

    五、封装申请内存函数

    ConcurrentAlloc函数

            在将thread cache、central cache以及page cache的申请流程写通了之后，我们就可以向外提供一个ConcurrentAlloc函数，用于申请内存块。每个线程第一次调用该函数时会通过TLS获取到自己专属的thread cache对象，然后每个线程就可以通过自己对应的thread cache申请对象了。

    1. static void* ConcurrentAlloc(size_t size)
    2. {
    3. 	//通过TLS，每个线程无锁的获取自己专属的ThreadCache对象
    4. 	if (pTLSThreadCache == nullptr)
    5. 	{
    6. 		pTLSThreadCache = new ThreadCache;
    7. 	}
    8. 	return pTLSThreadCache->Allocate(size);
    9. }

    注意：编译时会出现的问题，在C++的algorithm头文件中有一个min函数，这是一个函数模板，而在Windows.h头文件中也有一个min，这是一个宏。由于调用函数模板时需要进行参数类型的推演，因此当我们调用min函数时，编译器会优先匹配Windows.h当中以宏的形式实现的min，此时当我们以std::min的形式调用min函数时就会产生报错，这就是没有用命名空间进行封装的坏处，这时我们只能选择将std::去掉，让编译器调用Windows.h当中的min。

    大于256KB的大块内存申请问题

            之前说到，每个线程的thread cache是用于申请小于等于256KB的内存的，而对于大于256KB的内存，我们可以考虑直接向page cache申请，但page cache中最大的页也就只有128页，因此如果是大于128页的内存申请，就只能直接向堆申请了。

    申请内存的大小申请方式
    x <= 256KB(32页)向thread cache申请
    32页 < x <= 128页向page cache申请
    x > 128页向堆申请
    当申请的内存大于256KB时，虽然不是从thread cache进行获取，但在分配内存时也是需要进行向上对齐的，对于大于256KB的内存我们可以直接按页进行对齐。

      当申请对象的大小大于256KB时，就不用向thread cache申请了，这时先计算出按页对齐后实际需要申请的页数，然后通过调用NewSpan申请指定页数的span即可。

    1. static void* ConcurrentAlloc(size_t size)
    2. {
    3. 	if (size > MAX_BYTES) //大于256KB的内存申请
    4. 	{
    5. 		//计算出对齐后需要申请的页数
    6. 		size_t alignSize = SizeClass::RoundUp(size);
    7. 		size_t kPage = alignSize >> PAGE_SHIFT;
    8.  
    9. 		//向page cache申请kPage页的span
    10. 		PageCache::GetInstance()->_pageMtx.lock();
    11. 		Span* span = PageCache::GetInstance()->NewSpan(kPage);
    12. 		PageCache::GetInstance()->_pageMtx.unlock();
    13.  
    14. 		void* ptr = (void*)(span->_pageId << PAGE_SHIFT);
    15. 		return ptr;
    16. 	}
    17. 	else
    18. 	{
    19. 		//通过TLS，每个线程无锁的获取自己专属的ThreadCache对象
    20. 		if (pTLSThreadCache == nullptr)
    21. 		{
    22. 			pTLSThreadCache = new ThreadCache;
    23. 		}
    24. 		//cout << std::this_thread::get_id() << ":" << pTLSThreadCache << endl;
    25.  
    26. 		return pTLSThreadCache->Allocate(size);
    27. 	}
    28. }

    六、详解内存释放

    1.thread cache回收内存

            当某个线程申请的对象不用了，可以将其释放给thread cache，然后thread cache将该对象插入到对应哈希桶的自由链表当中即可。

      但是随着线程不断的释放，对应自由链表的长度也会越来越长，这些内存堆积在一个thread cache中就是一种浪费，我们应该将这些内存还给central cache，这样一来，这些内存对其他线程来说也是可申请的，因此当thread cache某个桶当中的自由链表太长时我们可以进行一些处理。

      如果thread cache某个桶当中自由链表的长度超过它一次批量向central cache申请的对象个数，那么此时我们就要把该自由链表当中的这些对象还给central cache。

    1. void ThreadCache::Deallocate(void* ptr, size_t size)
    2. {
    3. 	assert(ptr);
    4. 	assert(size <= MAX_BYTES);
    5.  
    6. 	// 找对应映射的自由链表桶，将对象插入进去
    7. 	size_t index = SizeClass::Index(size);
    8. 	_freeLists[index].Push(ptr);
    9.  
    10. 	// 当链表长度大于一次批量申请的内存时就开始还一段list给central cache
    11. 	if (_freeLists[index].Size() >= _freeLists[index].MaxSize())
    12. 	{
    13. 		ListTooLong(_freeLists[index], size);
    14. 	}
    15. }

            当自由链表的长度大于一次批量申请的对象时，我们具体的做法就是，从该自由链表中取出一次批量个数的对象，然后将取出的这些对象还给central cache中对应的span即可。

    1. // 释放对象时，链表过长时，回收内存回到中心缓存
    2. void ThreadCache::ListTooLong(FreeList& list, size_t size)
    3. {
    4. 	void* start = nullptr;
    5. 	void* end = nullptr;
    6.     
    7.     //从list中取出一次批量个数的对象
    8. 	list.PopRange(start, end, list.MaxSize());
    9.     
    10.     //将取出的对象还给central cache中对应的span
    11. 	CentralCache::GetInstance()->ReleaseListToSpans(start, size);
    12. }

            从上述代码可以看出，FreeList类需要支持用Size函数获取自由链表中对象的个数，还需要支持用PopRange函数从自由链表中取出指定个数的对象。因此我们需要给FreeList类增加一个对应的PopRange函数，然后再增加一个_size成员变量，该成员变量用于记录当前自由链表中对象的个数，当我们向自由链表插入或删除对象时，都应该更新_size的值。

    1. // 管理切分好的小对象的自由链表
    2. class FreeList
    3. {
    4. private:
    5. 	void* _freeList = nullptr;
    6. 	size_t _maxSize = 1; // 当前自由链表节点的个数上限
    7. 	size_t _size = 0;	 // 记录自由链表当前节点的个数
    8. };

    2.central cache回收内存

            当thread cache中某个自由链表太长时，会将自由链表当中的这些对象还给central cache中的span。

      但是需要注意的是，还给central cache的这些对象不一定都是属于同一个span的。central cache中的每个哈希桶当中可能都不止一个span，因此当我们计算出还回来的对象应该还给central cache的哪一个桶后，还需要知道这些对象到底应该还给这个桶当中的哪一个span。

    如何根据对象的地址得到对象所在的页号？

            首先我们必须理解的是，某个页当中的所有地址除以页的大小都等该页的页号。比如我们这里假设一页的大小是100，那么地址0~99都属于第0页，它们除以100都等于0，而地址100~199都属于第1页，它们除以100都等于1。

    如何找到一个对象对应的span？

      虽然我们现在可以通过对象的地址得到其所在的页号，但是我们还是不能知道这个对象到底属于哪一个span。因为一个span管理的可能是多个页。

      为了解决这个问题，我们可以建立页号和span之间的映射。由于这个映射关系在page cache进行span的合并时也需要用到，因此我们直接将其存放到page cache里面。

    1. //单例模式
    2. class PageCache
    3. {
    4. public:
    5. 	//获取从对象到span的映射
    6. 	Span* MapObjectToSpan(void* obj);
    7. private:
    8. 	std::unordered_map _idSpanMap; // 页号和span的映射
    9. };

      每当page cache分配span给central cache时，都需要记录一下页号和span之间的映射关系。此后当thread cache还对象给central cache时，才知道应该具体还给哪一个span。

      因此当central cache在调用NewSpan接口向page cache申请k页的span时，page cache在返回这个k页的span给central cache之前，应该建立这k个页号与该span之间的映射关系。

    1. // 获取一个k页的span
    2. Span* PageCache::NewSpan(size_t k)
    3. {
    4. 	assert(k > 0);
    5.  
    6. 	// 大于128页的直接向堆申请
    7. 	if (k > NPAGES - 1)
    8. 	{
    9. 		void* ptr = SystemAlloc(k);
    10. 		Span* span = _spanPool.New(); //Span* span = new Span;
    11. 		span->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
    12. 		span->_n = k;
    13.  
    14. 		_idSpanMap[span->_pageId] = span;
    15.  
    16. 		return span;
    17. 	}
    18. 		
    19. 	// 先检查第k个桶里面有没有span
    20. 	if (!_spanLists[k].Empty())
    21. 	{
    22. 		Span* kSpan = _spanLists[k].PopFront();
    23.  
    24. 		// 建立id和span的映射，方便central cache回收小块内存时，查找对应的span
    25. 		for (PAGE_ID i = 0; i < kSpan->_n; ++i)
    26. 		{
    27. 			_idSpanMap[kSpan->_pageId + i] = kSpan;
    28. 		}
    29.  
    30. 		return kSpan;
    31. 	}
    32.  
    33. 	// 检查一下后面的桶里面有没有span，如果有，可以把它进行切分（将n页的span切分成1个k页的span和1个n-k页的span）
    34. 	for (size_t i = k + 1; i < NPAGES; ++i)
    35. 	{
    36. 		if (!_spanLists[i].Empty())
    37. 		{
    38. 			Span* nSpan = _spanLists[i].PopFront();
    39. 			Span* kSpan = _spanPool.New(); // Span* kSpan = new Span;
    40.  
    41. 			// 在nSpan的头部切一个k页下来
    42. 			// k页的span返回
    43. 			// nSpan再挂到对应新的映射位置
    44. 			kSpan->_pageId = nSpan->_pageId;
    45. 			kSpan->_n = k;
    46.  
    47. 			nSpan->_pageId += k;
    48. 			nSpan->_n -= k;
    49.  
    50. 			_spanLists[nSpan->_n].PushFront(nSpan); // 最后将剩下的n-k页的span挂到它对应的位置
    51. 			// 存储nSpan的首尾页号跟nSpan映射，方便page cache回收内存时进行的合并查找
    52. 			//（这里不用存储所有的页号，因为nspan不用切分成小块的thread cache）
    53. 			_idSpanMap[nSpan->_pageId] = nSpan;
    54. 			_idSpanMap[nSpan->_pageId + nSpan->_n - 1] = nSpan;
    55.  
    56. 			// 建立id和span的映射，方便central cache回收小块内存时，查找对应的span
    57. 			for (PAGE_ID i = 0; i < kSpan->_n; ++i)
    58. 			{
    59. 				_idSpanMap[kSpan->_pageId + i] = kSpan;
    60. 			}
    61.  
    62. 			return kSpan;
    63. 		}
    64. 	}
    65.  
    66. 	// 走到这个位置就说明后面没有大页的span了
    67. 	// 这时候就取找堆要一个128页的span
    68. 	Span* bigSpan = _spanPool.New(); // Span* bigSpan = new Span;
    69. 	void* ptr = SystemAlloc(NPAGES - 1);
    70. 	bigSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
    71. 	bigSpan->_n = NPAGES - 1;
    72.  
    73. 	_spanLists[bigSpan->_n].PushFront(bigSpan);
    74.  
    75. 	return NewSpan(k); // 申请完span后再重新调用一次这个函数进行切分，而且还避免了代码重复
    76. }

            此时我们就可以通过对象的地址找到该对象对应的span了，直接将该对象的地址除以页的大小得到页号，然后在unordered_map当中找到其对应的span即可。

    1. //获取从对象到span的映射
    2. Span* PageCache::MapObjectToSpan(void* obj)
    3. {
    4. 	PAGE_ID id = (PAGE_ID)obj >> PAGE_SHIFT; // 先用对象地址算出该对象是第几页
    5. 	auto ret = _idSpanMap.find(id); // 再用这页的页号找到对应是哪一个span
    6. 	if (ret != _idSpanMap.end())
    7. 	{
    8. 		return ret->second;
    9. 	}
    10. 	else
    11. 	{
    12. 		assert(false);
    13. 		return nullptr;
    14. 	}
    15. }

    注意：当我们要通过某个页号查找其对应的span时，该页号与其span之间的映射一定是建立过的，如果此时我们没有在unordered_map当中找到，则说明我们之前的代码逻辑有问题，因此当没有找到对应的span时可以直接用断言结束程序，以表明程序逻辑出错。

    central cache回收内存

      这时当thread cache还对象给central cache时，就可以依次遍历这些对象，将这些对象插入到其对应span的自由链表当中，并且及时更新该span的_usseCount计数即可。

      在thread cache还对象给central cache的过程中，如果central cache中某个span的_useCount减到0时，说明这个span分配出去的对象全部都还回来了，那么此时就可以将这个span再进一步还给page cache。

    1. // 将一定数量的对象释放到span跨度
    2. void CentralCache::ReleaseListToSpans(void* start, size_t size)
    3. {
    4. 	size_t index = SizeClass::Index(size);
    5. 	_spanLists[index]._mtx.lock();
    6.  
    7. 	while (start)
    8. 	{
    9. 		void* next = NextObj(start);
    10.  
    11. 		Span* span = PageCache::GetInstance()->MapObjectToSpan(start);
    12. 		NextObj(start) = span->_freeList;
    13. 		span->_freeList = start;
    14. 		span->_useCount--;
    15.  
    16. 		if (span->_useCount == 0)
    17. 		{
    18. 			// 说明span切分出去的所有小内存都回来了
    19. 			// 这个span就可以再回收给page cache，page cache可以再尝试去做前后页的合并
    20. 			_spanLists[index].Erase(span);
    21. 			span->_freeList = nullptr;
    22. 			span->_next = nullptr;
    23. 			span->_prev = nullptr;
    24. 			
    25. 			// 释放span给page cache时，使用page cache的锁就可以了
    26. 			// 这时把桶锁解掉，因为这个span已经被erase了，其他线程就申请不到这个span了。这样就不会影响其他span的申请与释放
    27. 			_spanLists[index]._mtx.unlock();
    28.  
    29. 			PageCache::GetInstance()->_pageMtx.lock();
    30. 			PageCache::GetInstance()->ReleaseSpanToPageCache(span);
    31. 			PageCache::GetInstance()->_pageMtx.unlock();
    32.  
    33. 			_spanLists[index]._mtx.lock();
    34. 		}
    35.  
    36. 		start = next;
    37. 	}
    38.  
    39. 	_spanLists[index]._mtx.unlock();
    40. }

            注意：如果要把某个span还给page cache，我们需要先将这个span从central cache对应的双链表中移除，然后再将该span的自由链表置空，因为page cache中的span是不需要切分成一个个的小对象的，以及该span的前后指针也都应该置空，因为之后要将其插入到page cache对应的双链表中。但span当中记录的起始页号以及它管理的页数是不能清除的，否则对应内存块就找不到了。

      并且在central cache还span给page cache时也存在锁的问题，此时需要先将central cache中对应的桶锁解掉，然后再加上page cache的大锁之后才能进入page cache进行相关操作，当处理完毕回到central cache时，除了将page cache的大锁解掉，还需要立刻获得central cache对应的桶锁，然后将还未还完对象继续还给central cache中对应的span。

    3.page cache回收内存

            如果central cache中有某个span的_useCount减到0了，那么central cache就需要将这个span还给page cache了。

      这个过程看似是非常简单的，page cache只需将还回来的span挂到对应的哈希桶上就行了。但实际为了缓解内存碎片的问题，page cache还需要尝试将还回来的span与其他空闲的span进行合并。

    page cache进行前后页的合并

      合并的过程可以分为向前合并和向后合并。如果还回来的span的起始页号是num，该span所管理的页数是n。那么在向前合并时，就需要判断第num-1页对应span是否空闲，如果空闲则可以将其进行合并，并且合并后还需要继续向前尝试进行合并，直到不能进行合并为止。而在向后合并时，就需要判断第num+n页对应的span是否空闲，如果空闲则可以将其进行合并，并且合并后还需要继续向后尝试进行合并，直到不能进行合并为止。

      因此page cache在合并span时，是需要通过页号获取到对应的span的，这就是我们要把页号与span之间的映射关系存储到page cache的原因。

      但需要注意的是，当我们通过页号找到其对应的span时，这个span此时可能挂在page cache，也可能挂在central cache。而在合并时我们只能合并挂在page cache的span，因为挂在central cache的span当中的对象正在被其他线程使用。

      可是我们不能通过span结构当中的_useCount成员，来判断某个span到底是在central cache还是在page cache。因为当central cache刚向page cache申请到一个span时，这个span的_useCount就是等于0的，这时可能当我们正在对该span进行切分的时候，page cache就把这个span拿去进行合并了，这显然是不合理的。

      鉴于此，我们可以在span结构中再增加一个_isUse成员，用于标记这个span是否正在被使用，而当一个span结构被创建时我们默认该span是没有被使用的。

    1. //管理以页为单位的大块内存
    2. struct Span
    3. {
    4. 	PAGE_ID _pageId = 0;        //大块内存起始页的页号
    5. 	size_t _n = 0;              //页的数量
    6.  
    7. 	Span* _next = nullptr;      //双链表结构
    8. 	Span* _prev = nullptr;
    9.  
    10. 	size_t _useCount = 0;       //切好的小块内存，被分配给thread cache的计数
    11. 	void* _freeList = nullptr;  //切好的小块内存的自由链表
    12.  
    13. 	bool _isUse = false;        //是否在被使用
    14. };

            因此当central cache向page cache申请到一个span时，需要立即将该span的_isUse改为true。

    span->_isUse = true;

            而当central cache将某个span还给page cache时，也就需要将该span的_isUse改成false。

    span->_isUse = false;

      由于在合并page cache当中的span时，需要通过页号找到其对应的span，而一个span是在被分配给central cache时，才建立的各个页号与span之间的映射关系，因此page cache当中的span也需要建立页号与span之间的映射关系。

      与central cache中的span不同的是，在page cache中，只需建立一个span的首尾页号与该span之间的映射关系。因为当一个span在尝试进行合并时，如果是往前合并，那么只需要通过一个span的尾页找到这个span，如果是向后合并，那么只需要通过一个span的首页找到这个span。也就是说，在进行合并时我们只需要用到span与其首尾页之间的映射关系就够了。

      因此当我们申请k页的span时，如果是将n页的span切成了一个k页的span和一个n-k页的span，我们除了需要建立k页span中每个页与该span之间的映射关系之外，还需要建立剩下的n-k页的span与其首尾页之间的映射关系。

    1. // 获取一个k页的span
    2. Span* PageCache::NewSpan(size_t k)
    3. {
    4. 	assert(k > 0);
    5.  
    6. 	// 大于128页的直接向堆申请
    7. 	if (k > NPAGES - 1)
    8. 	{
    9. 		void* ptr = SystemAlloc(k);
    10. 		Span* span = _spanPool.New(); //Span* span = new Span;
    11. 		span->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
    12. 		span->_n = k;
    13.  
    14. 		_idSpanMap[span->_pageId] = span;
    15.  
    16. 		return span;
    17. 	}
    18. 		
    19. 	// 先检查第k个桶里面有没有span
    20. 	if (!_spanLists[k].Empty())
    21. 	{
    22. 		Span* kSpan = _spanLists[k].PopFront();
    23.  
    24. 		// 建立id和span的映射，方便central cache回收小块内存时，查找对应的span
    25. 		for (PAGE_ID i = 0; i < kSpan->_n; ++i)
    26. 		{
    27. 			_idSpanMap[kSpan->_pageId + i] = kSpan;
    28. 		}
    29.  
    30. 		return kSpan;
    31. 	}
    32.  
    33. 	// 检查一下后面的桶里面有没有span，如果有，可以把它进行切分（将n页的span切分成1个k页的span和1个n-k页的span）
    34. 	for (size_t i = k + 1; i < NPAGES; ++i)
    35. 	{
    36. 		if (!_spanLists[i].Empty())
    37. 		{
    38. 			Span* nSpan = _spanLists[i].PopFront();
    39. 			Span* kSpan = _spanPool.New(); // Span* kSpan = new Span;
    40.  
    41. 			// 在nSpan的头部切一个k页下来
    42. 			// k页的span返回
    43. 			// nSpan再挂到对应新的映射位置
    44. 			kSpan->_pageId = nSpan->_pageId;
    45. 			kSpan->_n = k;
    46.  
    47. 			nSpan->_pageId += k;
    48. 			nSpan->_n -= k;
    49.  
    50. 			_spanLists[nSpan->_n].PushFront(nSpan); // 最后将剩下的n-k页的span挂到它对应的位置
    51. 			// 存储nSpan的首尾页号跟nSpan映射，方便page cache回收内存时进行的合并查找
    52. 			//（这里不用存储所有的页号，因为nspan不用切分成小块的thread cache）
    53. 			_idSpanMap[nSpan->_pageId] = nSpan;
    54. 			_idSpanMap[nSpan->_pageId + nSpan->_n - 1] = nSpan;
    55.  
    56. 			// 建立id和span的映射，方便central cache回收小块内存时，查找对应的span
    57. 			for (PAGE_ID i = 0; i < kSpan->_n; ++i)
    58. 			{
    59. 				_idSpanMap[kSpan->_pageId + i] = kSpan;
    60. 			}
    61.  
    62. 			return kSpan;
    63. 		}
    64. 	}
    65.  
    66. 	// 走到这个位置就说明后面没有大页的span了
    67. 	// 这时候就取找堆要一个128页的span
    68. 	Span* bigSpan = _spanPool.New(); // Span* bigSpan = new Span;
    69. 	void* ptr = SystemAlloc(NPAGES - 1);
    70. 	bigSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
    71. 	bigSpan->_n = NPAGES - 1;
    72.  
    73. 	_spanLists[bigSpan->_n].PushFront(bigSpan);
    74.  
    75. 	return NewSpan(k); // 申请完span后再重新调用一次这个函数进行切分，而且还避免了代码重复
    76. }

            此时page cache当中的span就都与其首尾页之间建立了映射关系，现在我们就可以进行span的合并了，其合并逻辑如下：

    1. //释放空闲的span回到PageCache，并合并相邻的span
    2. void PageCache::ReleaseSpanToPageCache(Span* span)
    3. {
    4. 	//对span的前后页，尝试进行合并，缓解内存碎片问题
    5. 	//1、向前合并
    6. 	while (1)
    7. 	{
    8. 		PAGE_ID prevId = span->_pageId - 1;
    9. 		auto ret = _idSpanMap.find(prevId);
    10. 		//前面的页号没有（还未向系统申请），停止向前合并
    11. 		if (ret == _idSpanMap.end())
    12. 		{
    13. 			break;
    14. 		}
    15. 		//前面的页号对应的span正在被使用，停止向前合并
    16. 		Span* prevSpan = ret->second;
    17. 		if (prevSpan->_isUse == true)
    18. 		{
    19. 			break;
    20. 		}
    21. 		//合并出超过128页的span无法进行管理，停止向前合并
    22. 		if (prevSpan->_n + span->_n > NPAGES - 1)
    23. 		{
    24. 			break;
    25. 		}
    26. 		//进行向前合并
    27. 		span->_pageId = prevSpan->_pageId;
    28. 		span->_n += prevSpan->_n;
    29.  
    30. 		//将prevSpan从对应的双链表中移除
    31. 		_spanLists[prevSpan->_n].Erase(prevSpan);
    32.  
    33. 		delete prevSpan;
    34. 	}
    35. 	//2、向后合并
    36. 	while (1)
    37. 	{
    38. 		PAGE_ID nextId = span->_pageId + span->_n;
    39. 		auto ret = _idSpanMap.find(nextId);
    40. 		//后面的页号没有（还未向系统申请），停止向后合并
    41. 		if (ret == _idSpanMap.end())
    42. 		{
    43. 			break;
    44. 		}
    45. 		//后面的页号对应的span正在被使用，停止向后合并
    46. 		Span* nextSpan = ret->second;
    47. 		if (nextSpan->_isUse == true)
    48. 		{
    49. 			break;
    50. 		}
    51. 		//合并出超过128页的span无法进行管理，停止向后合并
    52. 		if (nextSpan->_n + span->_n > NPAGES - 1)
    53. 		{
    54. 			break;
    55. 		}
    56. 		//进行向后合并
    57. 		span->_n += nextSpan->_n;
    58.  
    59. 		//将nextSpan从对应的双链表中移除
    60. 		_spanLists[nextSpan->_n].Erase(nextSpan);
    61.  
    62. 		delete nextSpan;
    63. 	}
    64. 	//将合并后的span挂到对应的双链表当中
    65. 	_spanLists[span->_n].PushFront(span);
    66. 	//建立该span与其首尾页的映射
    67. 	_idSpanMap[span->_pageId] = span;
    68. 	_idSpanMap[span->_pageId + span->_n - 1] = span;
    69. 	//将该span设置为未被使用的状态
    70. 	span->_isUse = false;
    71. }

    需要注意的是，在向前或向后进行合并的过程中：

    • 如果没有通过页号获取到其对应的span，说明对应到该页的内存块还未申请，此时需要停止合并。
    • 如果通过页号获取到了其对应的span，但该span处于被使用的状态，那我们也必须停止合并。
    • 如果合并后大于128页则不能进行本次合并，因为page cache无法对大于128页的span进行管理。

      在合并span时，由于这个span是在page cache的某个哈希桶的双链表当中的，因此在合并后需要将其从对应的双链表中移除，然后再将这个被合并了的span结构进行delete。

      除此之外，在合并结束后，除了将合并后的span挂到page cache对应哈希桶的双链表当中，还需要建立该span与其首位页之间的映射关系，便于此后合并出更大的span。

    七、封装释放内存函数

    ConcurrentFree函数

      至此我们将thread cache、central cache以及page cache的释放流程也都写完了，此时我们就可以向外提供一个ConcurrentFree函数，用于释放内存块，释放内存块时每个线程通过自己的thread cache对象，调用thread cache中释放内存对象的接口即可。

    当释放对象时，我们需要判断释放对象的大小：

    申请内存的大小申请方式
    x <= 256KB(32页)释放给thread cache
    32页 < x <= 128页释放给page cache
    x > 128页释放给堆

            因此当释放对象时，我们需要先找到该对象对应的span，但是在释放对象时我们只知道该对象的起始地址。这也就是我们在申请大于256KB的内存时，也要给申请到的内存建立span结构，并建立起始页号与该span之间的映射关系的原因。此时我们就可以通过释放对象的起始地址计算出起始页号，进而通过页号找到该对象对应的span。 

    1. // 内存释放
    2. static void ConcurrentFree(void* ptr)
    3. {
    4. 	Span* span = PageCache::GetInstance()->MapObjectToSpan(ptr);
    5. 	size_t size = span->_objSize;
    6.  
    7. 	if (size > MAX_BYTES)
    8. 	{
    9. 		PageCache::GetInstance()->_pageMtx.lock();
    10. 		PageCache::GetInstance()->ReleaseSpanToPageCache(span);
    11. 		PageCache::GetInstance()->_pageMtx.unlock();
    12. 	}
    13. 	else
    14. 	{
    15. 		assert(pTLSThreadCache);
    16.  
    17. 		pTLSThreadCache->Deallocate(ptr, size);
    18. 	}
    19. }

     因此page cache在回收span时也需要进行判断，如果该span的大小是小于等于128页的，那么直接还给page cache进行了，page cache会尝试对其进行合并。而如果该span的大小是大于128页的，那么说明该span是直接向堆申请的，我们直接将这块内存释放给堆，然后将这个span结构进行delete就行了。

    1. //释放空闲的span回到PageCache，并合并相邻的span
    2. void PageCache::ReleaseSpanToPageCache(Span* span)
    3. {
    4. 	if (span->_n > NPAGES - 1) //大于128页直接释放给堆
    5. 	{
    6. 		void* ptr = (void*)(span->_pageId << PAGE_SHIFT);
    7. 		SystemFree(ptr);
    8. 		delete span;
    9. 		return;
    10. 	}
    11. 	//对span的前后页，尝试进行合并，缓解内存碎片问题
    12. 	//1、向前合并
    13. 	while (1)
    14. 	{
    15. 		PAGE_ID prevId = span->_pageId - 1;
    16. 		auto ret = _idSpanMap.find(prevId);
    17. 		//前面的页号没有（还未向系统申请），停止向前合并
    18. 		if (ret == _idSpanMap.end())
    19. 		{
    20. 			break;
    21. 		}
    22. 		//前面的页号对应的span正在被使用，停止向前合并
    23. 		Span* prevSpan = ret->second;
    24. 		if (prevSpan->_isUse == true)
    25. 		{
    26. 			break;
    27. 		}
    28. 		//合并出超过128页的span无法进行管理，停止向前合并
    29. 		if (prevSpan->_n + span->_n > NPAGES - 1)
    30. 		{
    31. 			break;
    32. 		}
    33. 		//进行向前合并
    34. 		span->_pageId = prevSpan->_pageId;
    35. 		span->_n += prevSpan->_n;
    36.  
    37. 		//将prevSpan从对应的双链表中移除
    38. 		_spanLists[prevSpan->_n].Erase(prevSpan);
    39.  
    40. 		delete prevSpan;
    41. 	}
    42. 	//2、向后合并
    43. 	while (1)
    44. 	{
    45. 		PAGE_ID nextId = span->_pageId + span->_n;
    46. 		auto ret = _idSpanMap.find(nextId);
    47. 		//后面的页号没有（还未向系统申请），停止向后合并
    48. 		if (ret == _idSpanMap.end())
    49. 		{
    50. 			break;
    51. 		}
    52. 		//后面的页号对应的span正在被使用，停止向后合并
    53. 		Span* nextSpan = ret->second;
    54. 		if (nextSpan->_isUse == true)
    55. 		{
    56. 			break;
    57. 		}
    58. 		//合并出超过128页的span无法进行管理，停止向后合并
    59. 		if (nextSpan->_n + span->_n > NPAGES - 1)
    60. 		{
    61. 			break;
    62. 		}
    63. 		//进行向后合并
    64. 		span->_n += nextSpan->_n;
    65.  
    66. 		//将nextSpan从对应的双链表中移除
    67. 		_spanLists[nextSpan->_n].Erase(nextSpan);
    68.  
    69. 		delete nextSpan;
    70. 	}
    71. 	//将合并后的span挂到对应的双链表当中
    72. 	_spanLists[span->_n].PushFront(span);
    73. 	//建立该span与其首尾页的映射
    74. 	_idSpanMap[span->_pageId] = span;
    75. 	_idSpanMap[span->_pageId + span->_n - 1] = span;
    76. 	//将该span设置为未被使用的状态
    77. 	span->_isUse = false;
    78. }

    八、使用定长内存池优化定长对象的申请

      tcmalloc是要在高并发场景下替代malloc进行内存申请的，因此tcmalloc在实现的时，其内部是不能调用malloc函数的，我们当前的代码中存在通过new获取到的内存，而new在底层实际上就是封装了malloc。

      为了完全脱离掉malloc函数，此时我们之前实现的定长内存池就起作用了，代码中使用new时基本都是为Span结构的对象申请空间，而span对象基本都是在page cache层创建的，因此我们可以在PageCache类当中定义一个_spanPool，用于span对象的申请和释放。

    1. //单例模式
    2. class PageCache
    3. {
    4. public:
    5. 	//...
    6. private:
    7. 	ObjectPool _spanPool;
    8. };

      然后将代码中使用new的地方替换为调用定长内存池当中的New函数，将代码中使用delete的地方替换为调用定长内存池当中的Delete函数。

    1. //申请span对象
    2. Span* span = _spanPool.New();
    3. //释放span对象
    4. _spanPool.Delete(span);

      注意：当使用定长内存池当中的New函数申请Span对象时，New函数通过定位new也是对Span对象进行了初始化的。

     此外，每个线程第一次申请内存时都会创建其专属的thread cache，而这个thread cache目前也是new出来的，我们也需要对其进行替换。

    1. //通过TLS，每个线程无锁的获取自己专属的ThreadCache对象
    2. if (pTLSThreadCache == nullptr)
    3. {
    4. 	static std::mutex tcMtx;
    5. 	static ObjectPool tcPool;
    6. 	tcMtx.lock();
    7. 	pTLSThreadCache = tcPool.New();
    8. 	tcMtx.unlock();
    9. }

      这里我们将用于申请ThreadCache类对象的定长内存池定义为静态的，保持全局只有一个，让所有线程创建自己的thread cache时，都在个定长内存池中申请内存就行了。

      但注意在从该定长内存池中申请内存时需要加锁，防止多个线程同时申请自己的ThreadCache对象而导致线程安全问题。

      最后在SpanList的构造函数中也用到了new，因为SpanList是带头循环双向链表，所以在构造期间我们需要申请一个span对象作为双链表的头结点。

    1. //带头双向循环链表
    2. class SpanList
    3. {
    4. public:
    5. 	SpanList()
    6. 	{
    7. 		_head = _spanPool.New();
    8. 		_head->_next = _head;
    9. 		_head->_prev = _head;
    10. 	}
    11. private:
    12. 	Span* _head;
    13. 	static ObjectPool _spanPool;
    14. };

      由于每个span双链表只需要一个头结点，因此将这个定长内存池定义为静态的，保持全局只有一个，让所有span双链表在申请头结点时，都在一个定长内存池中申请内存就行了。

    九、多线程并发环境下，与malloc进行申请和释放内存效率对比

    1. // 用自己写的ConcurrentAlloc与malloc进行性能对比
    2. // 参数：
    3. // ntimes：一轮申请和释放内存的次数
    4. // nworks：创建的线程数
    5. // rounds：轮次
    6. void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
    7. {
    8. 	std::vector vthread(nworks);
    9. 	std::atomic<size_t> malloc_costtime = 0;
    10. 	std::atomic<size_t> free_costtime = 0;
    11. 	for (size_t k = 0; k < nworks; ++k)
    12. 	{
    13. 		vthread[k] = std::thread([&, k]() {
    14. 			std::vector<void*> v;
    15. 			v.reserve(ntimes);
    16. 			for (size_t j = 0; j < rounds; ++j)
    17. 			{
    18. 				size_t begin1 = clock();
    19. 				for (size_t i = 0; i < ntimes; i++)
    20. 				{
    21. 					//v.push_back(malloc(16));
    22. 					v.push_back(malloc((16 + i) % 8192 + 1));
    23. 				}
    24. 				size_t end1 = clock();
    25. 				size_t begin2 = clock();
    26. 				for (size_t i = 0; i < ntimes; i++)
    27. 				{
    28. 					free(v[i]);
    29. 				}
    30. 				size_t end2 = clock();
    31. 				v.clear();
    32. 				malloc_costtime += (end1 - begin1);
    33. 				free_costtime += (end2 - begin2);
    34. 			}
    35. 			});
    36. 	}
    37. 	for (auto& t : vthread)
    38. 	{
    39. 		t.join();
    40. 	}
    41. 	printf("%u个线程并发执行%u轮次，每轮次malloc %u次: 花费：%u ms\n",
    42. 		nworks, rounds, ntimes, (const size_t)malloc_costtime);
    43. 	printf("%u个线程并发执行%u轮次，每轮次free %u次: 花费：%u ms\n",
    44. 		nworks, rounds, ntimes, (const size_t)free_costtime);
    45. 	printf("%u个线程并发malloc&free %u次，总计花费：%u ms\n",
    46. 		nworks, nworks * rounds * ntimes, (const size_t)malloc_costtime + (const size_t)free_costtime);
    47. }
    48.  
    49. // 单轮次申请释放次数 线程数 轮次
    50. void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
    51. {
    52. 	std::vector vthread(nworks);
    53. 	std::atomic<size_t> malloc_costtime = 0;
    54. 	std::atomic<size_t> free_costtime = 0;
    55. 	for (size_t k = 0; k < nworks; ++k)
    56. 	{
    57. 		vthread[k] = std::thread([&]() {
    58. 			std::vector<void*> v;
    59. 			v.reserve(ntimes);
    60. 			for (size_t j = 0; j < rounds; ++j)
    61. 			{
    62. 				size_t begin1 = clock();
    63. 				for (size_t i = 0; i < ntimes; i++)
    64. 				{
    65. 					//v.push_back(ConcurrentAlloc(16));
    66. 					v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
    67. 				}
    68. 				size_t end1 = clock();
    69. 				size_t begin2 = clock();
    70. 				for (size_t i = 0; i < ntimes; i++)
    71. 				{
    72. 					ConcurrentFree(v[i]);
    73. 				}
    74. 				size_t end2 = clock();
    75. 				v.clear();
    76. 				malloc_costtime += (end1 - begin1);
    77. 				free_costtime += (end2 - begin2);
    78. 			}
    79. 			});
    80. 	}
    81. 	for (auto& t : vthread)
    82. 	{
    83. 		t.join();
    84. 	}
    85. 	printf("%u个线程并发执行%u轮次，每轮次concurrent alloc %u次: 花费：%u ms\n",
    86. 		nworks, rounds, ntimes, (const size_t)malloc_costtime);
    87. 	printf("%u个线程并发执行%u轮次，每轮次concurrent dealloc %u次: 花费：%u ms\n",
    88. 		nworks, rounds, ntimes, (const size_t)free_costtime);
    89. 	printf("%u个线程并发concurrent alloc&dealloc %u次，总计花费：%u ms\n",
    90. 		nworks, nworks * rounds * ntimes, (const size_t)malloc_costtime + (const size_t)free_costtime);
    91. }
    92. int main()
    93. {
    94. 	size_t n = 10000;
    95. 	cout << "==========================================================" <<
    96. 		endl;
    97. 	BenchmarkConcurrentMalloc(n, 4, 10);
    98. 	cout << endl << endl;
    99. 	BenchmarkMalloc(n, 4, 10);
    100. 	cout << "==========================================================" <<
    101. 		endl;
    102. 	return 0;
    103. }

    其中测试函数各个参数的含义如下：

    • ntimes：单轮次申请和释放内存的次数。
    • nworks：线程数。
    • rounds：轮次。

      在测试函数中，我们通过clock函数分别获取到每轮次申请和释放所花费的时间，然后将其对应累加到malloc_costtime和free_costtime上。最后我们就得到了，nworks个线程跑rounds轮，每轮申请和释放ntimes次，这个过程申请所消耗的时间、释放所消耗的时间、申请和释放总共消耗的时间。

      注意，我们创建线程时让线程执行的是lambda表达式，而我们这里在使用lambda表达式时，以值传递的方式捕捉了变量k，以引用传递的方式捕捉了其他父作用域中的变量，因此我们可以将各个线程消耗的时间累加到一起。

      我们将所有线程申请内存消耗的时间都累加到malloc_costtime上， 将释放内存消耗的时间都累加到free_costtime上，此时malloc_costtime和free_costtime可能被多个线程同时进行累加操作的，所以存在线程安全的问题。鉴于此，我们在定义这两个变量时使用了atomic类模板，这时对它们的操作就是原子操作了。

    固定大小内存的申请和释放

    我们先来测试一下固定大小内存的申请和释放：

    1. v.push_back(malloc(16));
    2. v.push_back(ConcurrentAlloc(16));

    温馨提示：这里测试时可以在Release下进行测试，会比在Debug下运行速度快很多。

    此时4个线程执行10轮操作，每轮申请释放10000次，总共申请释放了40万次，运行后可以看到，malloc的效率还是更高的。

    由于此时我们申请释放的都是固定大小的对象，每个线程申请释放时访问的都是各自thread cache的同一个桶，当thread cache的这个桶中没有对象或对象太多要归还时，也都会访问central cache的同一个桶。此时central cache中的桶锁就不起作用了，因为我们让central cache使用桶锁的目的就是为了，让多个thread cache可以同时访问central cache的不同桶，而此时每个thread cache访问的却都是central cache中的同一个桶。

    不同大小内存的申请和释放

    下面我们再来测试一下不同大小内存的申请和释放：

    1. v.push_back(malloc((16 + i) % 8192 + 1));
    2. v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));

    运行后可以看到，由于申请和释放内存的大小是不同的，此时central cache当中的桶锁就起作用了，ConcurrentAlloc的效率也有了较大增长，但相比malloc来说还是差一点点。

    十、性能瓶颈分析

            经过前面的测试可以看到，我们的代码此时与malloc之间还是有差距的，此时我们就应该分析分析我们当前项目的瓶颈在哪里，但这不能简单的凭感觉，我们应该用性能分析的工具来进行分析。        

    VS编译器下性能分析的操作步骤

    VS编译器中就带有性能分析的工具的，我们可以依次点击“调试→性能和诊断”进行性能分析，注意该操作要在Debug模式下进行。

    同时我们将代码中n的值由10000调成了1000，否则该分析过程可能会花费较多时间，并且将malloc的测试代码进行了屏蔽，因为我们要分析的是我们实现的高并发内存池。

    1. int main()
    2. {
    3. 	size_t n = 1000;
    4. 	cout << "==========================================================" <<
    5. 		endl;
    6. 	BenchmarkConcurrentMalloc(n, 4, 10);
    7. 	cout << endl << endl;
    8. 	//BenchmarkMalloc(n, 4, 10);
    9. 	cout << "==========================================================" <<
    10. 		endl;
    11. 	return 0;
    12. }

    在点击了“调试→性能和诊断”→“检测”，因为我们要分析的是各个函数的用时时间，然后我们直接点击“开始”就可以进行了。

    然后我们就只用等待分析结果就可以了。 

    分析性能瓶颈

    通过分析结果可以看到，光是Deallocate和MapObjectToSpan这两个函数就占用了一半多的时间。

    而在Deallocate函数中，调用ListTooLong函数时消耗的时间是最多的。

    继续往下看，在ListTooLong函数中，调用ReleaseListToSpans函数时消耗的时间是最多的。

    再进一步看，在ReleaseListToSpans函数中，调用MapObjectToSpan函数时消耗的时间是最多的。

    也就是说，最终消耗时间最多的实际就是MapObjectToSpan函数，我们这时再来看看为什么调用MapObjectToSpan函数会消耗这么多时间。通过观察我们最终发现，调用该函数时会消耗这么多时间就是因为锁的原因。

    因此当前项目的瓶颈点就在锁竞争上面，需要解决调用MapObjectToSpan函数访问映射关系时的加锁问题。tcmalloc当中针对这一点使用了基数树进行优化，使得在读取这个映射关系时可以做到不加锁。

    十一、使用tcmalloc源码中实现基数树进行优化

    为了解决PageCache访问页号与Span*的映射加锁耗费太多的时间问题，引出了基数树这种映射方法。

    1.介绍基数树

    直接定址法的基数树：

    一层基数树映射保存页号和Span*

    1. // Single-level array
    2. template <int BITS> // 这里的BITS表示存储页号需要多少位，在32位下为32-PAGE_SHIFT，64位下为64-PAGE_SHIFT
    3. class TCMalloc_PageMap1 {
    4. private:
    5. 	static const int LENGTH = 1 << BITS;
    6. 	void** array_; // 一个数组，用于存储span*，数组的下标就是页号
    7. };
    • BITS 表示记录所有页所需要的比特位

    假设一页8K（2 ^ 13byte），在32位平台下，2 ^ 32 / 2 ^ 13= 2 ^ 19，所以需要19位可以表示所有的页，BITS=19

    • void** array_ 表示一个数组，用于存储span*，数组的下标就是页号。

    如图数组大小仅为2MB所以对于32位可以直接将映射数组开辟出来。

    注意：如果是64位机器，不能之一这种方式，因为要开辟的数组太大。这个时候需要高层映射（基数树）

    二层基数树

    假设在32位下，拿到一个页号，因为页号最大到19位，所以前面13位都是0可以不用管。

    给一个页号，先分离出后19为[A]，通过[A]前5位来找在第一层位置，再通过后14位来找第二层数组的位置。

    1. // Two-level radix tree
    2. template <int BITS>
    3. class TCMalloc_PageMap2 {
    4. private:
    5. 	// Put 32 entries in the root and (2^BITS)/32 entries in each leaf.
    6. 	static const int ROOT_BITS = 5;
    7. 	static const int ROOT_LENGTH = 1 << ROOT_BITS; //第一层数组的大小
    8.  
    9. 	static const int LEAF_BITS = BITS - ROOT_BITS;
    10. 	static const int LEAF_LENGTH = 1 << LEAF_BITS; //第二层数组的大小
    11.  
    12. 	// Leaf node
    13. 	struct Leaf {
    14. 		void* values[LEAF_LENGTH];
    15. 	};
    16.  
    17. 	Leaf* root_[ROOT_LENGTH];             //第一层数组的每个数组元素是一个数组
    18. };

    三层基数树

    64位采用为了减少开辟数组的大小，选用三层的基数树。需要访问那个位置，再开辟数组，可以避免开始就开辟特别大的数组。

    同理三层模型与二层基数树类型，这里不在赘述。

    1. // Three-level radix tree
    2. template <int BITS>
    3. class TCMalloc_PageMap3 {
    4. private:
    5. 	// How many bits should we consume at each interior level
    6. 	static const int INTERIOR_BITS = (BITS + 2) / 3; // Round-up
    7. 	static const int INTERIOR_LENGTH = 1 << INTERIOR_BITS;
    8.  
    9. 	// How many bits should we consume at leaf level
    10. 	static const int LEAF_BITS = BITS - 2 * INTERIOR_BITS;
    11. 	static const int LEAF_LENGTH = 1 << LEAF_BITS;
    12.  
    13. 	// Interior node
    14. 	struct Node {
    15. 		Node* ptrs[INTERIOR_LENGTH];
    16. 	};
    17.  
    18. 	// Leaf node
    19. 	struct Leaf {
    20. 		void* values[LEAF_LENGTH];
    21. 	};
    22.  
    23. 	Node* root_;                          // Root of radix tree
    24. };

    一二三层基数树C++实现

    1. // Single-level array
    2. template <int BITS> // 这里的BITS表示存储页号需要多少位，在32位下为32-PAGE_SHIFT，64位下为64-PAGE_SHIFT
    3. class TCMalloc_PageMap1 {
    4. private:
    5. 	static const int LENGTH = 1 << BITS;
    6. 	void** array_; // 一个数组，用于存储span*，数组的下标就是页号
    7.  
    8. public:
    9. 	typedef uintptr_t Number;
    10.  
    11. 	//explicit TCMalloc_PageMap1(void* (*allocator)(size_t)) {
    12. 	explicit TCMalloc_PageMap1() {
    13. 		//array_ = reinterpret_cast((*allocator)(sizeof(void*) << BITS));
    14. 		size_t size = sizeof(void*) << BITS;
    15. 		size_t alignSize = SizeClass::_RoundUp(size, 1 << PAGE_SHIFT);
    16. 		array_ = (void**)SystemAlloc(alignSize >> PAGE_SHIFT);
    17. 		memset(array_, 0, sizeof(void*) << BITS);
    18. 	}
    19.  
    20. 	// Return the current value for KEY.  Returns NULL if not yet set,
    21. 	// or if k is out of range.
    22. 	void* get(Number k) const {
    23. 		if ((k >> BITS) > 0) {
    24. 			return NULL;
    25. 		}
    26. 		return array_[k];
    27. 	}
    28.  
    29. 	// REQUIRES "k" is in range "[0,2^BITS-1]".
    30. 	// REQUIRES "k" has been ensured before.
    31. 	//
    32. 	// Sets the value 'v' for key 'k'.
    33. 	void set(Number k, void* v) {
    34. 		array_[k] = v;
    35. 	}
    36. };
    37.  
    38. // Two-level radix tree
    39. template <int BITS>
    40. class TCMalloc_PageMap2 {
    41. private:
    42. 	// Put 32 entries in the root and (2^BITS)/32 entries in each leaf.
    43. 	static const int ROOT_BITS = 5;
    44. 	static const int ROOT_LENGTH = 1 << ROOT_BITS;
    45.  
    46. 	static const int LEAF_BITS = BITS - ROOT_BITS;
    47. 	static const int LEAF_LENGTH = 1 << LEAF_BITS;
    48.  
    49. 	// Leaf node
    50. 	struct Leaf {
    51. 		void* values[LEAF_LENGTH];
    52. 	};
    53.  
    54. 	Leaf* root_[ROOT_LENGTH];             // Pointers to 32 child nodes
    55. 	void* (*allocator_)(size_t);          // Memory allocator
    56.  
    57. public:
    58. 	typedef uintptr_t Number;
    59.  
    60. 	//explicit TCMalloc_PageMap2(void* (*allocator)(size_t)) {
    61. 	explicit TCMalloc_PageMap2() {
    62. 		//allocator_ = allocator;
    63. 		memset(root_, 0, sizeof(root_));
    64.  
    65. 		PreallocateMoreMemory();
    66. 	}
    67.  
    68. 	void* get(Number k) const {
    69. 		const Number i1 = k >> LEAF_BITS;
    70. 		const Number i2 = k & (LEAF_LENGTH - 1);
    71. 		if ((k >> BITS) > 0 || root_[i1] == NULL) {
    72. 			return NULL;
    73. 		}
    74. 		return root_[i1]->values[i2];
    75. 	}
    76.  
    77. 	void set(Number k, void* v) {
    78. 		const Number i1 = k >> LEAF_BITS;
    79. 		const Number i2 = k & (LEAF_LENGTH - 1);
    80. 		ASSERT(i1 < ROOT_LENGTH);
    81. 		root_[i1]->values[i2] = v;
    82. 	}
    83.  
    84. 	bool Ensure(Number start, size_t n) {
    85. 		for (Number key = start; key <= start + n - 1;) {
    86. 			const Number i1 = key >> LEAF_BITS;
    87.  
    88. 			// Check for overflow
    89. 			if (i1 >= ROOT_LENGTH)
    90. 				return false;
    91.  
    92. 			// Make 2nd level node if necessary
    93. 			if (root_[i1] == NULL) {
    94. 				//Leaf* leaf = reinterpret_cast((*allocator_)(sizeof(Leaf)));
    95. 				//if (leaf == NULL) return false;
    96. 				static ObjectPool	leafPool;
    97. 				Leaf* leaf = (Leaf*)leafPool.New();
    98.  
    99. 				memset(leaf, 0, sizeof(*leaf));
    100. 				root_[i1] = leaf;
    101. 			}
    102.  
    103. 			// Advance key past whatever is covered by this leaf node
    104. 			key = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
    105. 		}
    106. 		return true;
    107. 	}
    108.  
    109. 	void PreallocateMoreMemory() {
    110. 		// Allocate enough to keep track of all possible pages
    111. 		Ensure(0, 1 << BITS);
    112. 	}
    113. };
    114.  
    115. // Three-level radix tree
    116. template <int BITS>
    117. class TCMalloc_PageMap3 {
    118. private:
    119. 	// How many bits should we consume at each interior level
    120. 	static const int INTERIOR_BITS = (BITS + 2) / 3; // Round-up
    121. 	static const int INTERIOR_LENGTH = 1 << INTERIOR_BITS;
    122.  
    123. 	// How many bits should we consume at leaf level
    124. 	static const int LEAF_BITS = BITS - 2 * INTERIOR_BITS;
    125. 	static const int LEAF_LENGTH = 1 << LEAF_BITS;
    126.  
    127. 	// Interior node
    128. 	struct Node {
    129. 		Node* ptrs[INTERIOR_LENGTH];
    130. 	};
    131.  
    132. 	// Leaf node
    133. 	struct Leaf {
    134. 		void* values[LEAF_LENGTH];
    135. 	};
    136.  
    137. 	Node* root_;                          // Root of radix tree
    138. 	void* (*allocator_)(size_t);          // Memory allocator
    139.  
    140. 	Node* NewNode() {
    141. 		Node* result = reinterpret_cast((*allocator_)(sizeof(Node)));
    142. 		if (result != NULL) {
    143. 			memset(result, 0, sizeof(*result));
    144. 		}
    145. 		return result;
    146. 	}
    147.  
    148. public:
    149. 	typedef uintptr_t Number;
    150.  
    151. 	explicit TCMalloc_PageMap3(void* (*allocator)(size_t)) {
    152. 		allocator_ = allocator;
    153. 		root_ = NewNode();
    154. 	}
    155.  
    156. 	void* get(Number k) const {
    157. 		const Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
    158. 		const Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
    159. 		const Number i3 = k & (LEAF_LENGTH - 1);
    160. 		if ((k >> BITS) > 0 ||
    161. 			root_->ptrs[i1] == NULL || root_->ptrs[i1]->ptrs[i2] == NULL) {
    162. 			return NULL;
    163. 		}
    164. 		return reinterpret_cast(root_->ptrs[i1]->ptrs[i2])->values[i3];
    165. 	}
    166.  
    167. 	void set(Number k, void* v) {
    168. 		ASSERT(k >> BITS == 0);
    169. 		const Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
    170. 		const Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
    171. 		const Number i3 = k & (LEAF_LENGTH - 1);
    172. 		reinterpret_cast(root_->ptrs[i1]->ptrs[i2])->values[i3] = v;
    173. 	}
    174.  
    175. 	bool Ensure(Number start, size_t n) {
    176. 		for (Number key = start; key <= start + n - 1;) {
    177. 			const Number i1 = key >> (LEAF_BITS + INTERIOR_BITS);
    178. 			const Number i2 = (key >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
    179.  
    180. 			// Check for overflow
    181. 			if (i1 >= INTERIOR_LENGTH || i2 >= INTERIOR_LENGTH)
    182. 				return false;
    183.  
    184. 			// Make 2nd level node if necessary
    185. 			if (root_->ptrs[i1] == NULL) {
    186. 				Node* n = NewNode();
    187. 				if (n == NULL) return false;
    188. 				root_->ptrs[i1] = n;
    189. 			}
    190.  
    191. 			// Make leaf node if necessary
    192. 			if (root_->ptrs[i1]->ptrs[i2] == NULL) {
    193. 				Leaf* leaf = reinterpret_cast((*allocator_)(sizeof(Leaf)));
    194. 				if (leaf == NULL) return false;
    195. 				memset(leaf, 0, sizeof(*leaf));
    196. 				root_->ptrs[i1]->ptrs[i2] = reinterpret_cast(leaf);
    197. 			}
    198.  
    199. 			// Advance key past whatever is covered by this leaf node
    200. 			key = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
    201. 		}
    202. 		return true;
    203. 	}
    204.  
    205. 	void PreallocateMoreMemory() {
    206. 	}
    207. };

    注意：这里要使用一层基数树只能在32位下运行，64位需要三层基数树。
    VS2022默认64位，如果你是VS2022下测试注意改为32位： 

    2.优化代码

            现在我们用基数树对代码进行优化，此时将PageCache类当中的unorder_map用基数树进行替换即可，由于当前是32位平台，因此这里随便用几层基数树都可以。

    1. //单例模式
    2. class PageCache
    3. {
    4. public:
    5. 	//...
    6. private:
    7. 	//std::unordered_map _idSpanMap;
    8. 	TCMalloc_PageMap1<32 - PAGE_SHIFT> _idSpanMap;
    9. };

            此时当我们需要建立页号与span的映射时，就调用基数树当中的set函数。

    _idSpanMap.set(span->_pageId, span);

            而当我们需要读取某一页号对应的span时，就调用基数树当中的get函数。

    Span* ret = (Span*)_idSpanMap.get(id);

            并且现在PageCache类向外提供的，用于读取映射关系的MapObjectToSpan函数内部就不需要加锁了。

    1. //获取从对象到span的映射
    2. Span* PageCache::MapObjectToSpan(void* obj)
    3. {
    4. 	PAGE_ID id = (PAGE_ID)obj >> PAGE_SHIFT; //页号
    5. 	Span* ret = (Span*)_idSpanMap.get(id);
    6. 	assert(ret != nullptr);
    7. 	return ret;
    8. }

    3.为什么读取基数树映射关系时不需要加锁？

            当某个线程在读取映射关系时，可能另外一个线程正在建立其他页号的映射关系，而此时无论我们用的是C++当中的map还是unordered_map，在读取映射关系时都是需要加锁的。

      因为C++中map的底层数据结构是红黑树，unordered_map的底层数据结构是哈希表，而无论是红黑树还是哈希表，当我们在插入数据时其底层的结构都有可能会发生变化。比如红黑树在插入数据时可能会引起树的旋转，而哈希表在插入数据时可能会引起哈希表扩容。此时要避免出现数据不一致的问题，就不能让插入操作和读取操作同时进行，因此我们在读取映射关系的时候是需要加锁的。

      而对于基数树来说就不一样了，基数树的空间一旦开辟好了就不会发生变化，因此无论什么时候去读取某个页的映射，都是对应在一个固定的位置进行读取的。并且我们不会同时对同一个页进行读取映射和建立映射的操作，因为我们只有在释放对象时才需要读取映射，而建立映射的操作都是在page cache进行的。也就是说，读取映射时读取的都是对应span的_useCount不等于0的页，而建立映射时建立的都是对应span的_useCount等于0的页，所以说我们不会同时对同一个页进行读取映射和建立映射的操作。

    4.再次对比malloc进行测试

    还是同样的代码，只不过我们用基数树对代码进行了优化，这时测试固定大小内存的申请和释放的结果如下：

    可以看到，这时就算申请释放的是固定大小的对象，其效率都是malloc的两倍。下面在申请释放不同大小的对象时，由于central cache的桶锁起作用了，其效率更是变成了malloc的好几倍。

    十二、打包成动静态库

            实际Google开源的tcmalloc是会直接用于替换malloc的，不同平台替换的方式不同。比如基于Unix的系统上的glibc，使用了weak alias的方式替换；而对于某些其他平台，需要使用hook的钩子技术来做。

      对于我们当前实现的项目，可以考虑将其打包成静态库或动态库。我们先右击解决方案资源管理器当中的项目名称，然后选择属性。

    此时会弹出该选项卡，按照以下图示就可以选择将其打包成静态库或动态库了。

    十三、项目源码

            项目到这里就已经圆满结束了，但是由于篇幅已经很长了，项目中有些地方只给了文字说明与框架，具体的完整实现代码我会放在Gitee上供大家参考。项目源码icon-default.png?t=N7T8https://gitee.com/what-you-want-a/high-concurrency-memory-pool

  • 相关阅读:
    振弦采集仪应用水坝安全监测的方案
    【字符串函数内功修炼】strcpy + strcat + strcmp（一）
    springboot如何集成swagger，swagger如何为所有API添加token参数，swagger常用注解，简介明了，举例说明
    ROS机器人应用（4）—— 查看里程计、IMU 话题信息
    数字孪生技术打造智慧矿山可视化解决方案
    Word文档格式设置——小课堂
    【力扣-每日一题】714. 买卖股票的最佳时机含手续费
    【通信原理】第三章 -- 随机过程[下]
    强大的SQL计算利器-SPL
    自动化测试框架
  • 原文地址：https://blog.csdn.net/qq_64042727/article/details/133466109