高并发内存池（4）——实现CentralCache

最新推荐文章于 2024-09-13 17:43:09 发布
最新推荐文章于 2024-09-13 17:43:09 发布
阅读量696 收藏 5
点赞数 11
分类专栏： 高并发内存池项目笔记 文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41934502/article/details/142152580
版权

目录

一，CentralCache的简单介绍

 二，CentralCache的整体结构

三，CentralCache实现的详细代码

1，成员

 2，函数

1， 获取单例对象的指针

2， FetchRangeObj函数

3，GetOneSpan函数实现

 4，ReleaseListToSpans函数实现

一，CentralCache的简单介绍

CentralCache是高并发内存池这个项目的中间层。当第一层ThreadCache内存不够时便会向这一层申请内存。而CentralCache这一层的内存是从下一层的PageCache层申请的。如下图所示：

可以看到，CentralCahe层的实现和ThreadCache层的实现有异曲同工之妙。不过，在CentralCache链接的是由span块链接而成的spanlist。 spanlist上面便链接着自由链表。

span实现如下：

//定义一个Span结构，是CentralCache里面的大号内存
struct Span
{
	PAGEID _pageid = 0; //页号：在不同的程序下要有不同的类型
	size_t _n = 0; //一个span里的页的数量
	//双向链表的结构
	Span* _prev = nullptr;
	Span* _next = nullptr;
	//使用的个数，当_usecount为0时表示无人使用。
	int _useCont = 0;
	//Span节点中的小内存
	void* _freelist = nullptr;
	bool _used = false;
	int _objSize = 0;
	
};

//一个成员为Span类型的带头双向循环链表
class Spanlist
{
public:
   Spanlist()
   {
	   //_head = PageCache::GetInstance()->_Newtospan.New();
	  // FixedPoll<Span> _fixedpoll;
	   _head = new Span;
	   _head->_next = _head;
	   _head->_prev = _head;
   }

   void PushFront(Span* span)
   {
	   insert(begin(), span);
   }

   Span* PopFront()
   {
	   return remove(begin());
   }

   //插入新的节点到某一个位置上
   void insert(Span* pos, Span* Newnode)
   {
	   assert(pos );
	   assert(Newnode);

	   Span* prev = pos->_prev;
	  

	   prev->_next = Newnode;
	   Newnode->_prev = prev;
	   Newnode->_next = pos;
	   pos->_prev = Newnode;
   }

   //删除某个位置上的节点
   Span* remove(Span* pos)
   {
	   assert(pos);
	   assert(pos != _head);
	   Span* Next = pos->_next;
	   Span* Prev = pos->_prev;
	   Prev->_next = Next;
	   Next->_prev = Prev;
	   pos->_next = nullptr;
	   pos->_prev = nullptr;
	   return pos;
   }

   //开始和结束函数
   Span* begin()
   {
	   return _head->_next;
   }

   Span* end()
   {
	   return _head;
   }

   //判空函数
   bool Empty()
   {
	   return begin() == _head;
   }

private:
	//Span*节点
	Span* _head = nullptr;
public:
	//桶锁
	std::mutex _mux;
};

 二，CentralCache的整体结构

CentralCache的整体代码如下图所示：

//定义一个CentralCache类,类里面放的是SpanList*对象
//这个CentralCache要定义为单例
class CentralCache
{
public:
	//获取单例
	static CentralCache* GetInstance()
	{
		return &_singleton;
	}


	//为threadCache向Central申请内存
	 size_t FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size);
	 Span* GetOneSpan(Spanlist* splist, size_t sz);
	 // 将⼀定数量的对象释放到span中
	 void ReleaseListToSpans(void* start, size_t byte_size);


private:
	CentralCache() {};//不能删除只能私有
	CentralCache(const CentralCache&) = delete;
	CentralCache&operator =(CentralCache&) = delete;
	Spanlist _List[Nspan];
	static CentralCache _singleton;
};

正如上面的代码所示，CentralCache的实现依赖于它的四个函数和两个成员。

三，CentralCache实现的详细代码

1，成员

CentalCache函数的内部有两个成员。分别是一个spanlist的数组和一个单例对象。前面我已经介绍了spanlist这个结构。那为什么要使用单例呢？ 使用单例能够提前生成CentralCache的实例，提高使用效率，方便在别处调用。

 2，函数

//获取单例
	static CentralCache* GetInstance()
	{
		return &_singleton;
	}


	//为threadCache向Central申请内存
	 size_t FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size);
	 Span* GetOneSpan(Spanlist* splist, size_t sz);
	 // 将⼀定数量的对象释放到span中
	 void ReleaseListToSpans(void* start, size_t byte_size);

在CentralCache的类中实现了以上四个函数，接下来便详细讲解以上函数的实现。

1， 获取单例对象的指针
static CentralCache* GetInstance()
	{
		return &_singleton;
	}

 这个函数的作用就是获取单例对象的指针。

2， FetchRangeObj函数

具体实现如下：

size_t CentralCache:: FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size)
{
	//1,先获取大的span
	int index = Index(size);
	CentralCache::_List[index]._mux.lock();
	Span* span = GetOneSpan(&_List[index], size);
	//断言下获取到的span和size
	assert(span);
	assert(size <= MaxBytes);

	//开始获取：end,start从span的自由链表处开始出发
	start = span->_freelist;
	end = span->_freelist;
	int i = 0;
	int actualNum = 1;
	while (i++ < batchNum-1 && NextObj(end) != nullptr)
	{
		end = NextObj(end);
		actualNum++;
	}

	//截断
	span->_freelist = NextObj(end);
	NextObj(end) = nullptr;
	span->_useCont += actualNum;
	CentralCache::GetInstance()->_List[index]._mux.unlock();
	//返回相应的块数
	return actualNum;
}

这个函数通过调用对齐函数算出传入的大小对应的下标后再调用:GetOneSpan获得一个span并切分通过begin和end带出去交给ThreadCache。

3，GetOneSpan函数实现

具体实现代码如下：

Span* CentralCache::GetOneSpan(Spanlist* splist,size_t sz)
{

	//先查找范围
	Span* it = splist->begin();
	while (it != splist->end())
	{
		if (it->_freelist != nullptr)
		{
			return it;
		}
		else
		{
			it = it->_next;
		}
	}
	//解锁：为了在下面的调用更加的快捷
	splist->_mux.unlock();
	//需要向下申请Span对象
	PageCache::GetInstance()->_mut.lock();
	Span* span = PageCache::GetInstance()->NewSpan(PageNum(sz));
	//从PageCache获取后标记被使用状态
	span->_used = true;
	PageCache::GetInstance()->_mut.unlock();

	//确定得到的span的内存范围,这个_pageid不是从0开始的而是一个地址>>PageShift后得到的
	char* start = (char*)(span->_pageid << PageShift);
	int bytes = span->_n << PageShift;
	char* end = start + bytes;

	//开始分割Span
	span->_freelist = start;
	start += sz;
	void* tail = span->_freelist;

	while (start < end)
	{
		NextObj(tail) = start;
		tail = NextObj(tail);
		start += sz;
	}

	NextObj(tail) = nullptr;
    
	//再次加锁：涉及到了splist的操作
	splist->_mux.lock();
	//将span头插到spanlist中
	splist->PushFront(span);

	//返回span
	return span;

 这个函数的目的就是得到一个span。当CentralCache中没有sapn时便调用NewSpan函数向下一层的pageCache申请内存。并将span切成一块一块的小内存头插到对应的sanlist中。

 4，ReleaseListToSpans函数实现

具体代码如下：

//ThreadCache释放内存还给CentralCache
void CentralCache::ReleaseListToSpans(void* start, size_t byte_size)
{   
	 //计算是操作那个桶
	int index = Index(byte_size);
	_List[index]._mux.lock();
	//找span
	Span* span = PageCache::GetInstance()->MapObjectToSpan(start);
	//开始插入到span中
	while (start)
	{
		//头插
		void* Next = NextObj(start);
		NextObj(start) = span->_freelist;
		span->_freelist = start;
		start = Next;
		//还回来一个就usecount减少一个,当_usecount减少到0就还给PageCache
		span->_useCont--;
		if (span->_useCont == 0)
		{
			_List[index]._mux.unlock();
			PageCache::GetInstance()->_mut.lock();
			//将CentralCache中的内存还给PageCache
			PageCache::GetInstance()->ReleaseSpanToPage(span);
			PageCache::GetInstance()->_mut.unlock();
			_List[index]._mux.lock();
		}
	}
	_List->_mux.unlock();

}

这个函数实现的功能是将ThreadCache中的内存还给CentralCache层。                              发生条件是：ThreadCache上的自由链表太长了。

原理：再ThreadCache层调用时ThreadCache层会调用该函数，并传入要归还的内存的首地址。因为每一个地址对应的页号是被设计过的，并且每一个页号和Span都会再PageCache中放入到哈希表中一一对应。所以，通过ThreadCache传入的地址便可以知道这个地址对应的Span，找到这个Span便可以进行头插从而将ThreadCache上过长的自由链表上的内存还给CentralCache。

 四，总结

CentralCache层是高并发内存池的中间层。主要的作用便是为ThreadCache提供内存，提高ThreadCache申请内存的能力。

Niu_brave
关注
专栏目录
高并发内存池——CentralCache实现
Shall#的博客
07-30 264
中心缓存
高并发内存池——ThreadCache实现
Shall#的博客
07-27 331
ThreadCache
高并发内存池——PageCache实现
Shall#的博客
07-30 307
Pgaecache
C++项目——高并发内存池
hu_143的博客
07-28 985
本项目参考了谷歌 tcmalloc 设计模式，设计实现了高并发内存池
高并发内存池——总体框架铺垫
Shall#的博客
07-26 1089
总体框架
高并发内存池(ConCurrentMemoryPool)
qq_64341323的博客
02-22 2297
一、 项目概述 1. 简介 基于Google开源tcmalloc项目，该内存池主要应用于多线程频繁申请和释放大量小块内存。它的优点：性能卓越、大幅减少了外内存碎片。 2. 工具 Google的tcmalloc开源代码，使用vs2019进行研究学习。 3. 目标 1、 建立一个可行的私人高并发内存池，需要解决以下三个问题： a) 效率问题 b) 内存碎片问题 c) 多线程并发场景下的内存释放和申请的锁竞争问题。 2、 深入理解内存管理 4. 扩展 1、 完全脱离malloc和free，且不要使用thread和
高并发内存池详解（C/C++/Windows/Linux）
qq_42591783的博客
03-21 2109
待填
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 792
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 161
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
【c++23种设计模式概述】
m0_45463480的博客
09-09 792
c++23种设计模式概述。
C语言作用域
天道酬勤
09-07 1025
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 832
set、map仿STL模拟实现
从C到C++
D1557329860的博客
09-08 1171
string不是C++的基本数据类型，它是一个C++标准库中的字符串类，使用时需要引入对应的头文件，#include<string>，而不是string.h.引用参数，在不参与计算的情况下，我们建议使用const进行修饰，以达到引用的安全性。声明引用的时候，初始化的值可以是纯数值，但是此时需要使用const关键字修饰，表示该引用为常量引用，这样引用的值不可变。写一个函数，函数有两个参数a和b，函数的功能是交换两个传入的参数原来变量的值。可以使用const修饰引用，此时如果原变量的值改变，引用的值也改变。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 706
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 1028
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 297
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值