当前位置：首页 > news >正文

ThreadCache

news 来源：原创 2025/8/23 6:58:32

一、Freelist

二、ThreadCache

三、哈希桶映射规则

一、Freelist

在之前整体框架介绍的时候，我们曾说过ThreadCache是一个哈希桶的结构。每一个桶都要存同一个大小的对象块（即最小块的内存）。

那么我们使用FreeList来当做桶，存放这些小块内存。

Freelist的结构

//管理切分好的小对象的自由链表
class FreeList
{
public:void Push(void* obj){assert(obj);//头插*(void**)obj = _freeList;_freeList = obj;_size++;}void PushRange(void* start, void* end, size_t n)//范围型的插入{*(void**)end = _freeList;_freeList = start;_size += n;}void* Pop(){assert(_freeList);//头删void* obj = _freeList;_freeList = *(void**)obj;--_size;return obj;}void PopRange(void*& start, void*& end, size_t n)//start和end是输出型参数{assert(n <= _size);start = _freeList;end = start;for (int i = 0; i < n - 1; i++)end = *(void**)end;_freeList = *(void**)end;*(void**)end = nullptr;_size -= n;}bool Empty(){return _freeList == nullptr;}size_t& MaxSize(){return _maxSize;}size_t Size(){return _size;}
private:void* _freeList = nullptr;size_t _maxSize = 1;//记录ThreadCache一次性最多向CentralCache申请多少个对象size_t _size = 0;//记录自由链表中挂的内存个数
};

二、ThreadCache

ThreadCache要实现以下逻辑：其中Allocate和Deallocate是普通的申请和释放，而FetchFromCentralCache是保证在ThreadCache的freelist中没有内存块的时候，可以向CentralCache中要一定数量的内存块。当freelist中的内存块挂的太多了，通过listTooLong将其归还到CentralCache中。

#pragma once
#include"Common.hpp"
#include"CentralCache.hpp"class ThreadCache
{
public:// 申请和释放内存对象void* Allocate(size_t size);void Deallocate(void* ptr, size_t size);// 从中心缓存获取对象void* FetchFromCentralCache(size_t index, size_t size);// 释放对象时，链表过长时，回收内存回到中心缓存void ListTooLong(FreeList& list, size_t size);private:FreeList _freelists[NFREELISTS];
};//TLS无锁访问
thread_local ThreadCache* pTLSThreadCache=nullptr;-------------------------------------------------------------------------------void* ThreadCache::Allocate(size_t size)
{assert(size <= MAX_Bytes);//1.根据size，在合适的定长桶中拿内存块size_t alignSize = SizeClass::AlignUp(size);size_t index = SizeClass::Index(size);if (!_freelists[index].Empty()){return _freelists[index].Pop();}//2.如果对应的桶中没有内存块了，找CentralCache拿一大块，再切分else{return FetchFromCentralCache(index,alignSize);}
}void ThreadCache::Deallocate(void* ptr, size_t size)
{assert(size <= MAX_Bytes);assert(ptr);//1.把该内存块归还到对应的桶中size_t index = SizeClass::Index(size);_freelists->Push(ptr);//2.如果桶里挂的太多了，还给CentralCacheif (_freelists[index].Size() >= _freelists[index].MaxSize()){ListTooLong(_freelists[index],size);}}void ThreadCache::ListTooLong(FreeList& list, size_t size)
{//把一个批量的内存块从freelist中拿出来，链接到CentralCache的Span的freelist中void* start = nullptr;void* end = nullptr;list.PopRange(start,end, list.MaxSize());CentralCache::GetInstance()->ReleaseListToSpans(start,size);
}void* ThreadCache::FetchFromCentralCache(size_t index, size_t size)
{//采用慢开始的反馈调节算法,小对象给多一点,大对象给少一点size_t batchNum = min(_freelists[index].MaxSize(), SizeClass::NumMoveSize(size));if (_freelists[index].MaxSize() == batchNum){_freelists[index].MaxSize() += 1;}//用两个指针来接收中心缓存得到的内存空间的起始、结束地址void* begin = nullptr;void* end = nullptr;//需要massnum个对象,但是实际上不一定有这么多个,返回值为实际上获取到的个数size_t factNum = CentralCache::GetInstance()->CentralCache::FetchRangeObj(begin, end, batchNum, size);//要batchNum个对象,每个对象的大小是sizeassert(factNum != 0);if (factNum == 1){assert(begin == end);return begin;}else{//如果从中心缓存获取了多个,则将第一个返回给threadcachee,然后再将剩余的内存挂在threadcache的自由链表中_freelists[index].PushRange(NextObj(begin), end, factNum - 1);return begin;}
}

TLS无锁访问

我们知道每一个进程是独享一个内存地址空间的，而同一个进程内部的线程共享该进程的大部分资源，如堆区，全局变量等等。虽然线程有自己独立的栈区，但是栈是用于函数调用的时候存储局部变量了，出了该栈帧，变量就销毁没有用了。所以必须要有一个线程的空间，且能长久保存数据。那么如果每一个线程想要自己独立的空间怎么做呢？

C++中有一个关键字叫做thread_local,只要被他修饰的变量都会被操作系统保存在线程独享的空间中（不是堆），这样以后在每个线程访问自己的变量就不会再需要加锁或者局部变量被覆盖的问题了。

三、哈希桶映射规则

这里用到一个方法,也就是内存对齐!比如想要申请1~7字节的内存,先把它对齐为8字节再进行后续的操作,这么做的原因有两个: 一是因为如果申请多少内存就给多少内存,那么我们需要的哈希桶的数量就太多了,不合理. 二是因为释放内存时比较方便。当然这样会造成内碎片的问题，不过我们通过一定的规则将内碎片限制在10%左右。

内存对齐的具体规则:

为什么不都使用8字节对齐呢?

因为若使用8字节对齐,共256KB内存一共要使用三万多个桶,也是不合理的这样的对齐方式只用使用208个桶!

除此之外，我们还有一些用于计算桶号等的函数，为了方便管理我们统一放到一个类SizeClass中。关于这些函数我们只需要了解有这么个东西就行了，不用在意他具体是怎么实现的，现在AI如此发达，这种纯体力活可以交给AI代劳。

// 管理对齐和映射等关系
class SizeClass
{
public:// 整体控制在最多10%左右的内碎片浪费// [1,128]                  8byte对齐        freelist[0,16)// [128+1,1024]             16byte对齐       freelist[16,72)// [1024+1,8*1024]          128byte对齐      freelist[72,128)// [8*1024+1,64*1024]       1024byte对齐     freelist[128,184)// [64*1024+1,256*1024]     8*1024byte对齐   freelist[184,208)//一共208个桶static inline size_t AlignUp(size_t size)//将size向上对齐{if (size <= 128)return _AlignUp(size, 8);else if (size <= 1024)return _AlignUp(size, 16);else if (size <= 8 * 1024)return _AlignUp(size, 128);else if (size <= 64 * 1024)return _AlignUp(size, 1024);else if (size <= 256 * 1024)return _AlignUp(size, 8 * 1024);elsereturn _AlignUp(size, 1 << PAGE_SHIFT);}static inline size_t _AlignUp(size_t size, size_t align_number){return (((size)+align_number - 1) & ~(align_number - 1));}static inline size_t _Index(size_t bytes, size_t align_shift){return ((bytes + ((unsigned long long)1 << align_shift) - 1) >> align_shift) - 1;}// 计算映射的哪一个自由链表桶static inline size_t Index(size_t bytes){assert(bytes <= MAX_Bytes);// 每个区间有多少个链static int group_array[4] = { 16, 56, 56, 56 };if (bytes <= 128) {return _Index(bytes, 3);}else if (bytes <= 1024) {return _Index(bytes - 128, 4) + group_array[0];}else if (bytes <= 8 * 1024) {return _Index(bytes - 1024, 7) + group_array[1] + group_array[0];}else if (bytes <= 64 * 1024) {return _Index(bytes - 8 * 1024, 10) + group_array[2] + group_array[1]+ group_array[0];}else if (bytes <= 256 * 1024) {return _Index(bytes - 64 * 1024, 13) + group_array[3] +group_array[2] + group_array[1] + group_array[0];}else {assert(false);}return -1;}// 一次从中心缓存获取多少个static size_t NumMoveSize(size_t size){assert(size > 0);if (size == 0)return 0;// [2, 512]，一次批量移动多少个对象的(慢启动)上限值// 小对象一次批量上限高// 小对象一次批量上限低size_t num = MAX_Bytes / size;if (num < 2)num = 2;if (num > 512)num = 512;return num;}// 计算一次向系统获取几个页// 单个对象 8byte// ...// 单个对象 256KBstatic size_t NumMovePage(size_t size){size_t num = NumMoveSize(size);size_t npage = num * size;npage >>= PAGE_SHIFT;if (npage == 0)npage = 1;return npage;}};

一、Freelist

二、ThreadCache

三、哈希桶映射规则

相关文章：