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

💓博主CSDN主页:杭电码农-NEO💓

⏩专栏分类:项目日记-高并发内存池⏪

🚚代码仓库:NEO的学习日记🚚

🌹关注我🫵带你做项目

🔝🔝

开发环境: Visual Studio 2022

---

项目日记

• [1. 前言](#1. 前言)
• [2. 中心缓存的哈希桶结构](#2. 中心缓存的哈希桶结构)
• [3. span结构的具体实现](#3. span结构的具体实现)
• [4. 中心缓存类的定义](#4. 中心缓存类的定义)
• [5. 中心缓存如何分配小块儿内存?](#5. 中心缓存如何分配小块儿内存?)
• [6. 中心缓存无内存时应该如何做?](#6. 中心缓存无内存时应该如何做?)
• [7. 总结](#7. 总结)

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还给页缓存

---

🔎 下期预告:中心缓存的具体实现(下)🔍