五、central cache的设计

central cache 也是一个哈希桶结构，与 thread cache 的映射结构相同。但不同之处在于，central cache 每个哈希桶挂载的是 SpanList 链表结构 。每个 Span 节点，指向的是由一块大内存切割出来的，对应大小的小内存块的自由链表结构，如 8Byte 的桶中，每个 Span 节点指向 8Byte 内存大小的自由链表；256KB 的桶中，每个 Span 节点指向 256KB 内存大小的自由链表。

Span 节点所指向的内存块，是由 page cache 中按页划分得到的一块连续内存空间。一开始，每个桶内只有一个 Span，当一个 Span 拥有的内存被使用完毕后，SpanList 会创建新的 Span 节点，从 page cache 中划分新的内存过来使用。当有内存使用完毕进行归还时，将原先拿走的内存重新挂载到原 Span 节点中，即向谁借的内存，就归还给谁。这就能解释 SpanList 中有多个 Span 节点都拥有剩余的内存资源的情况。

2. 设计细节

2.1 单例模式

central cache 不需要让线程独有，所以我们就设计成只允许存在一个 central cache 即可。

cpp 复制代码

class CentralCache
{
public:
	static CentralCache* GetInstance()
	{
	return &_instance;
	}
private:
	CentralCache() {};
	CentralCache(const CentralCache&) = delete;
};

2.2 桶锁保证线程安全

在 central cache 中，为了保证线程安全，必须进行加锁。但如果采用一个全局锁，会严重影响并发性能 。所以，我们设计 central cache 的每个哈希桶中都有独立的桶锁（bucket lock） 。这样即使有多个线程同时访问 central cache，如果它们访问的是 central cache 里不同的桶，就不会产生线程安全问题；而如果有线程访问了相同的哈希桶，也会被桶锁阻塞在外面。

在 TCMalloc 的实现中，CentralFreeList 通常按 size class 数量划分，比如有 88 个 size class，就有 88 个桶锁。这种设计叫做 fine-grained locking（细粒度锁），是性能优化中常用的一种并发控制策略。

2.3 条件编译

在 thread cache 的设计中，我们能通过巧妙的代码设计来同时适配 32 位和 64 位系统，但在 central cache 的代码实现中，就不得不使用条件编译来适配不同的系统了。Windows 环境下，有一个宏 _WIN32 表示 Win32 位系统，和一个 _WIN64 表示 Win64 位系统。但问题是，在 Win32 配置下，_Win32 有定义，_Win64 无定义；在 Win64 配置下，_Win32 和 _Win64 均有定义。所以我们要想将 Win32 和 Win64 区分出来，必须严格控制条件编译的顺序才能实现。

cpp 复制代码

#ifdef _Win64
typedef unsigned long long PAGE_ID;
#elif _Win32
typedef size_t PAGE_ID
#endif

2.4 central cache申请内存

central cache 通过 SpanList + Freelist 的结构管理内存。每个 size class 对应一个 SpanList ，用于管理多个来源于 page cache 的 Span。每个 Span 内部包含一个自由链表（freelist），用于记录尚未分配的小对象。当 thread cache 请求内存时，central cache 可以直接将已经切分好的对象链表批量返回，避免了 thread cache 进行对象切分的开销。当当前 SpanList 中的可用对象不足时，central cache 会向 page cache 申请新的 span，并挂载到对应的 SpanList 中，便于后续统一回收与管理。

2.5 central cache归还内存

central cache 在整个内存池中作为中间结构，其归还内存的函数涉及到三个 cache 的内容， ReleaseListToSpans() 最初由 thread cache 调用归还内存给 central cache，thread cache 的内存是由 central cache 的 span 切分并构建自由链表结构分配的。所以在归还内存时，ReleaseListToSpans() 会将被归还的小内存块重新拼接成到原来的 span，直到这个 span 恢复到初始的大小（通过计数器 useCount 实现），就将这个 span 归还给 page cache。

3. 代码实现

3.1 SpanList

SpanList 的结构实现放在了 Common.h 中，这是因为 SpanList 在 page cache 中也有用到。其每一个节点 Span 中包含了以下信息：

cpp 复制代码

class Span
{
public:
	PAGE_ID _pageID = 0;	//大块内存起始页的页号
	size_t _pageNum = 0;	//页的数量
	Span* _next = nullptr;
	Span* _prev = nullptr;

	size_t _useCount = 0;	//小内存块分配给thread cache的计数
	void* _freeList = nullptr;	//小内存块的自由链表
};

3.2 CentralCache.h和CentralCache.cpp

central cache 使用了单例模式实现。

CentralCache.h：

cpp 复制代码

#pragma once
#include "PageCache.h"
#include "Common.h"

class CentralCache
{
public:
	static CentralCache* GetInstance()
	{
		return &_instance;
	}
	
	Span* GetOneSpan(SpanList& list, size_t byte_size);

	size_t FetchRangeObj(void*& start, void*& end, size_t bachNum, size_t size);

	void ReleaseListToSpans(void* start, size_t byte_size);
private:
	CentralCache() {};
	CentralCache(const CentralCache&) = delete;

private:
	SpanList _spanLists[NFREELIST];
	static CentralCache _instance;
};

CentralCache.cpp：

cpp 复制代码

#include "CentralCache.h"

CentralCache CentralCache::_instance;

//获得一个非空的span
Span* CentralCache::GetOneSpan(SpanList& list, size_t byte_size)
{
	//找当前的spanlist中是否有空闲的span
	Span* it = list.Begin();
	while (it != list.End())
	{
		if (it->_freeList != nullptr)
		{
			return it;
		}
		else
		{
			it = it->_next;
		}
	}

	//没有空闲的span，向page cache申请内存
	//先把在central cache的桶锁解开，避免其他线程归还内存也被阻塞在外面
	list._mtx.unlock();

	PageCache::GetInstance()->_pageMtx.lock();
	Span* span = PageCache::GetInstance()->NewSpan(SizeClass::NumMovePage(byte_size));
	span->_isUse = true;
	span->_objSize = byte_size;
	PageCache::GetInstance()->_pageMtx.unlock();

	//对获得的span进行切分
	//1.计算span的起始地址和大小（字节数）
	char* start = (char*)(span->_pageID << PAGE_SHIFT);
	size_t bytes = span->_pageNum << PAGE_SHIFT;
	char* end = start + bytes;

	//2.把大内存切成自由链表链接起来
	//先切下一块做头节点
	span->_freeList = start;
	start += byte_size;
	void* tail = span->_freeList;
	int i = 1;
	while (start + byte_size < end)
	{
		//使用尾插方便保持内存地址连续
		i++;
		NextObj(tail) = start;
		tail = NextObj(tail);
		start += byte_size;
	}
	NextObj(tail) = nullptr;
	list._mtx.lock();
	list.PushFront(span);
	return span;
}

size_t CentralCache::FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size)
{
	size_t index = SizeClass::Index(size);
	_spanLists[index]._mtx.lock();

	Span* span = GetOneSpan(_spanLists[index], size);
	assert(span);
	assert(span->_freeList);

	start = span->_freeList;
	end = start;
	size_t i = 0;
	size_t actualNum = 1;
	//span中不一定有请求量的内存块，如果少于就有多少拿多少
	while (i < batchNum - 1 && NextObj(end))
	{
		end = NextObj(end);
		++i;
		++actualNum;
	}
	//将需求的自由链表拆开
	span->_freeList = NextObj(end);
	NextObj(end) = nullptr;
	span->_useCount += actualNum;

	_spanLists[index]._mtx.unlock();
	return actualNum;
}

void CentralCache::ReleaseListToSpans(void* start, size_t byte_size)
{
	size_t index = SizeClass::Index(byte_size);
	_spanLists[index]._mtx.lock();
	while (start)
	{
		void* next = NextObj(start);
		Span* span = PageCache::GetInstance()->MapObjectToSpan(start);
		NextObj(start) = span->_freeList;
		span->_freeList = start;
		span->_useCount--;

		if (span->_useCount == 0)
		{
			//此时span切分出去的内存已经全部回收，可以归还给PageCache
			_spanLists[index].Erase(span);
			span->_freeList = nullptr;
			span->_next = nullptr;
			span->_prev = nullptr;

			_spanLists[index]._mtx.unlock();

			PageCache::GetInstance()->_pageMtx.lock();
			PageCache::GetInstance()->ReleaseSpanToPageCache(span);
			PageCache::GetInstance()->_pageMtx.unlock();

			_spanLists[index]._mtx.lock();
		}
		start = next;
	}
	_spanLists[index]._mtx.unlock();
}