【项目日记(五)】第二层: 中心缓存的具体实现

项目日记

• [1. 前言](#1. 前言)
• [2. 中心缓存的哈希桶结构](#2. 中心缓存的哈希桶结构)
• [3. span结构的具体实现](#3. span结构的具体实现)
• [4. 中心缓存类的定义](#4. 中心缓存类的定义)
• [5. 中心缓存如何分配小块儿内存?](#5. 中心缓存如何分配小块儿内存?)
• [6. 中心缓存无内存时应该如何做?](#6. 中心缓存无内存时应该如何做?)
• [7. 小结](#7. 小结)
• [8. 中心缓存回收/还回内存的细节](#8. 中心缓存回收/还回内存的细节)
• [9. 中心缓存回收内存的代码实现](#9. 中心缓存回收内存的代码实现)
• [10. 对于页号与span映射的代码补充](#10. 对于页号与span映射的代码补充)
• [11. 总结](#11. 总结)

1. 前言

中心缓存起到一个承上启下的作用,

它负责给线程缓存分配小块儿的内

存,并且负责从页缓存申请大块儿内存

本章重点:

本篇文章着重讲解中心缓存的结构
包括span类的具体成员.并且会讲解
中心缓存是如何给线程缓存分配内存
并且是如何向页缓存申请/内存的!

---

2. 中心缓存的哈希桶结构

在对整个项目的结构做介绍的文章

中以及提到过中心缓存的结构了,

值得注意的是中心缓存使用的是桶锁

即每个哈希桶也就是每个spanlist都

又一个互斥锁

---

3. span结构的具体实现

span的具体结构:

shared.h文件:

//管理多个连续页的大块内存跨度结构,centralcache的哈希桶中链接的就是这种结构
class SpanData
{
public:
	PAGE_ID _pageid = 0;//32位下,程序地址空间,2^32byte,一页8kb=2^13byte,一共有2^19页
	size_t _n = 0;//页数
	SpanData* _next = nullptr;
	SpanData* _prev = nullptr;
	size_t _useCount = 0;//span中切分好的小对象有几个被使用了
	void* _freeList = nullptr;//切分好的小块内存的自由链表
	bool _isUse = false; //这个span是否正在被使用,若没有被使用则可能被pagecache合并成为大页
	size_t _objSize = 0; //切分好的小对象的大小,方便后面删除的时候可以直接知道它的大小
};
class SpanList//双向带头循环链表
{
public:
	SpanList()
	{
		_head = new SpanData;
		_head->_next = _head;
		_head->_prev = _head;
	}
	SpanData* Begin()
	{
		return _head->_next;
	}
	SpanData* End()
	{
		return _head;
	}
	bool Empty()//判断这个桶中是不是没有span
	{
		return _head->_next == _head;
	}
	void Insert(SpanData* pos, SpanData* newSpan)
	{
		assert(pos && newSpan);
		SpanData* prev = pos->_prev;
		prev->_next = newSpan;
		newSpan->_prev = prev;
		newSpan->_next = pos;
		pos->_prev = newSpan;
	}
	void Erase(SpanData* pos)
	{
		assert(pos);
		assert(pos != _head);
		/*if (pos == _head)
		{
			int x = 0;
		}*/
		SpanData* prev = pos->_prev;
		SpanData* next = pos->_next;
		prev->_next = next;
		next->_prev = prev;
	}
	void PushFront(SpanData* span)
	{
		Insert(Begin(), span);
	}
	SpanData* PopFront()
	{
		SpanData* front = _head->_next;
		Erase(front);
		return front;//erase中没有将此节点释放
	}
	SpanData* _head = nullptr;
	std::mutex _mtx;//桶锁
}; 

对成员变量use_count的解释:
use_count为0时,代表这个span
中所有被分配出去的小块儿内存
都被线程缓存还回来了,此时可直接
将这个span从中心缓存还给页缓存

---

4. 中心缓存类的定义

并且,中心缓存整体被设计为了单例模式:

CentralCache.h文件:

lass CentralCache
{
public:
	static CentralCache* GetInstance()
	{
		return &_singleton;
	}
	// 从中心缓存获取一定数量的对象(小块儿内存)给thread cache
	size_t FetchRangeObj(void*& start, void*& end, size_t massNum, size_t size);//拿n个内存对象,大小是byte_size,start和end是输出型参数

	// 从SpanList获取一个非空的span
	SpanData* GetOneSpan(SpanList& list, size_t size);

	// 将ThreadCache返回来的内存重新挂在CentralCache的span
	void ReleaseListToSpans(void* start, size_t byte_size);
private:
	CentralCache(){}
	CentralCache(const CentralCache&) = delete;
private:
	SpanList _spanlist[N_FREE_LIST];//中心缓存的桶映射规则和Thread一样,208个桶
	static CentralCache _singleton;//单例模式
};
CentralCache CentralCache::_singleton = new CentreaCache();

---

5. 中心缓存如何分配小块儿内存?

FetchRangeObj函数我们并不陌生,

在线程缓存中,当桶中没有小块儿内存

时就是调用此函数来中心缓存获取的!

分配内存的基本步骤1:

中心缓存会先找到对应的哈希桶,然后
去桶中取一个非空的span结构,再将这
个span结构中切分好的小块儿内存分
配给线程缓存使用

CentralCache.h文件:

size_t CentralCache::FetchRangeObj(void*& start, void*& end, size_t massNum, size_t size)
{
	size_t index = AlignmentRule::Index(size);//找到对应的哈希桶
	_spanlist[index]._mtx.lock();//加锁
	SpanData* span = GetOneSpan(_spanlist[index], size);//从桶中获取一个span结构
	assert(span && span->_freeList);
	//从span中获取massnum个对象,若没有这么多对象的话,有多少就给多少
	start = span->_freeList;//把start指向首地址
	end = start;
	int factcount = 1;//实际分配给线程缓存的对象个数
	int i = 0;
	while (*(void**)end != nullptr && i< massNum - 1)
	{
		end = *(void**)end;
		i++;
		factcount++;
	}
	span->_useCount += factcount;
	span->_freeList = *(void**)end;
	*(void**)end = nullptr;
	_spanlist[index]._mtx.unlock();//解锁
	return factcount;
}

---

6. 中心缓存无内存时应该如何做?

分配内存的基本步骤2:

若对应的哈希桶中的span为空,也
就是中心缓存无内存了,就会调用
NewSpan去页缓存获取一个新的
span结构,然后把新的span切分为
小块儿内存后再给线程缓存使用!

SpanData* CentralCache::GetOneSpan(SpanList& list, size_t size)
{
	SpanData* it = list.Begin();
	//遍历centralcache的中固定桶的所有span,若找到有不为空的freelist,则直接返回
	while (it != list.End())
	{
		if (it->_freeList != nullptr)//如果中心缓存有非空span,直接返回
			return it;
		else
			it = it->_next;
	}
	//先把centralcache的桶锁解除,这样如果其他线程释放内存对象回来不会阻塞
	list._mtx.unlock();
	//走到这儿证明这个桶中没有span小对象了,去找pagecache要span
	//直接在这里将页缓存结构加锁,Newspan内就不用加锁了
	PageCache::GetInstance()->_mtx.lock();
	SpanData* span = PageCache::GetInstance()->NewSpan(AlignmentRule::NumMovePage(size));//传的参数是要申请的页数,size越大对应的页就应该越大
	span->_isUse = true;//将这个span的状态修改为正在使用
	span->_objSize = size;
	PageCache::GetInstance()->_mtx.unlock();
	//下面的内容不需要加锁,因为获取到的span只有我这个线程有,其他线程访问不到
	char* address = (char*)((span->_pageid) << PAGE_SHIFT); //这个页的起始地址是页号*8*1024,第0页的地址是0,以此类推
	size_t bytes = span->_n << PAGE_SHIFT; //计算这个span总共有多少个字节,用_n(页数)*8*1024
	//接下来要将这个span的大块内存切分成小块内存用自由链表连接起来
	char* end = address + bytes;//address和end对应空间的开头和结尾
	//1. 先切一块下来去做头,方便后续尾插
	span->_freeList = address;
	address += size;
	void* cur = span->_freeList;
	while (address < end)//2. 遍历空间尾插
	{
		*(void**)cur = address;
		cur = *(void**)cur;
		address += size;
	}
	*(void**)cur = nullptr;
	//插入时需要加锁,否则指向可能乱掉
	list._mtx.lock();
	list.PushFront(span);
	return span;
}

值得注意的是,获取到span后我们要通过这个span的页数来知道这个span有多少内存,并且要通过这个span在程序地址空间的页号来判断这份内存的起始地址是多少!第0页的地址是0000 0000,第一页的地址是8KB,以此类推

---

7. 小结

中心缓存这里给线程缓存分配内存时是

有两种情况的,当中心缓存无内存时就

会向页缓存索要,而本篇文章只讲解了

申请内存的过程,而当线程缓存将内存

还回来后,还有可能将span还给页缓存

8. 中心缓存回收/还回内存的细节

• 第一步: 当线程缓存中的哈希桶中小块儿内存的个数大于了该线程缓存一次性向中心缓存中申请的小块儿内存的个数,此时小块儿内存会从线程缓存中还回到中心缓存的span中

细节问题一:

从线程缓存中还回来的小块儿内存是多个,然而中心缓存的桶中可能不止一个span,我们怎么知道哪个小块儿内存对应到哪个span?很明显随意将在小块儿内存还回到任意span肯定是不对的!在上一篇文章中我们提到过如何通过指针得到这块儿空间在程序地址空间上的页号,所以我们可以使用一个unordered_map来存储页号和span的映射关系,当线程缓存还回小块儿内存时,可以通过计算小块儿内存在地址空间的页号来从这个哈希表中找到对应的span,这就是解决了我们的问题!

• 第二步: 当中心缓存中的span结构体中的成员变量:use_count等于0时,代表这个span被分配出去的小块儿内存都已经还回来了,所以此时将这个span整体还给上一级,也就是页缓存

---

9. 中心缓存回收内存的代码实现

根据上面的讲解,每还回来一个小块儿

内存都要检查一下它对应的span结构

的use_count是否为0,如果为0就要将

整个span结构还给页缓存!

centralcache.h文件:

void CentralCache::ReleaseListToSpans(void* start, size_t size)//一个桶中有多个span,这些内存块儿属于哪个span是不确定的
{
	size_t index = AlignmentRule::Index(size);//计算在哪个桶
	_spanlist[index]._mtx.lock();
	//要想知道这些内存块分别在哪个span,将内存块的地址除8*1024,得到这个内存块属于第几页
	while (start != nullptr)
	{
		void* next = *(void**)start;
		SpanData* span = PageCache::GetInstance()->MapObjectToSpan(start);//利用地址与span的映射函数,找到这个内存块对应的span
		*(void**)start = span->_freeList;//将内存块start头插到span中
		span->_freeList = start;
		span->_useCount--;//还回来一次内存块,就将usecount--,减到0后就又把内存还给pagecache
		if (span->_useCount == 0)//此时说明span切分出去的所有小块儿内存都被还回来了,直接将整个span还给pagecache,pagecache再进行前后页的合并
		{
			_spanlist[index].Erase(span);
			span->_freeList = nullptr;//span中的小块内存已经打乱了,但我知道起始地址和结束地址,可直接置空
			span->_next = nullptr;
			span->_prev = nullptr;
			//还回来内存时不用加桶锁了,但是pagecache的整体大锁需要加上
			_spanlist[index]._mtx.unlock();
			PageCache::GetInstance()->_mtx.lock();
			PageCache::GetInstance()->ReleaseSpanToPageCache(span);
			PageCache::GetInstance()->_mtx.unlock();
			_spanlist[index]._mtx.lock();
		}
		start = next;
	}
	_spanlist[index]._mtx.unlock();
}

注:对于代码的解释都在注释中
并且ReleaseSpanToPageCache函数
是页缓存需要实现的,这里暂时放一放

---

10. 对于页号与span映射的代码补充

由于这份代码是在pagecache中存放的并且页缓存还没有具体解释,所以看不懂没关系,把页缓存部分学完就都明白了.再一个,存储页号和span的映射关系的哈希表是存储在页缓存中的!因为不止在中心缓存中会使用到这种映射关系,在页缓存时同样页面临相同的问题,所以将它放在了最上层的页缓存中

pagecache.h文件中:

std::unordered_map<PAGE_ID, SpanData*> _idSpanMap;//存储页号和桶中对应的span的映射,解决换回来的内存对应哪个span的问题
//给我一个地址,返回这个地址对应的span
SpanData* PageCache::MapObjectToSpan(void* obj)
{
	PAGE_ID pageId = (PAGE_ID)obj >> PAGE_SHIFT;//将地址右移13位就算出了页号
	std::unique_lock<std::mutex> lock(_mtx);//加锁
	auto ret = _idSpanMap.find(pageId);
	if (ret != _idSpanMap.end())//若找到了对应的页号,就返回对应的span
		return _idSpanMap[pageId];
	else assert(false);//没找到,证明前面的代码有问题
	assert(ret != nullptr);
	return ret;
}

---

11. 总结

中心缓存这一层的所有内容已经讲解完毕,很巧妙的是,中心缓存使用的是桶锁,只有两个不同的线程同时进入到同一个桶中才会有锁竞争问题,这也是这个项目比较快的原因之一.总的来说,中心缓存的作用是承上启下,负责给线程缓存分配切分好的小块儿内存,以及从线程缓存中回收内存.并且它也会向页缓存申请大块儿内存,并且会在合适的时候将大块儿内存还回去,方便页缓存结构进行内存合并!

---

🔎 下期预告:页缓存的具体实现🔍