【lesson4】高并发内存池ThreadCache（线程缓存）层实现

  • 开发
  • 26

文章目录

ThreadCache层的结构

thread cache是哈希桶结构，每个桶是一个按桶位置映射大小的内存块对象的自由链表。每个线程都会有一个thread cache对象，这样每个线程在这里获取对象和释放对象时是无锁的。

在这里插入图片描述

申请内存逻辑

  1. 当内存申请size<=256KB，先获取到线程本地存储的thread cache对象，计算size映射的哈希桶自由链表下标i。
  2. 如果自由链表_freeLists[i]中有对象，则直接Pop一个内存对象返回。
  3. 如果_freeLists[i]中没有对象时，则批量从central cache中获取一定数量的对象，插入到自由链表并返回一个对象。

释放内存逻辑

释放逻辑之后再完整实现，现在先了解释放流程

  1. 当释放内存小于256k时将内存释放回thread cache，计算size映射自由链表桶位置i，将对象Push到_freeLists[i]。
  2. 当链表的长度过长，则回收一部分内存对象到central cache。

自由链表的实现

从上面我们可以知道，ThreadCache存放内存块需要自由链表，所以我们要先实现自由链表。

自由链表的成员变量

在这里插入图片描述
之前学过定长内存池就知道用一个_freeList指针就能管理好多个内存块。

自由链表的成员函数

在这里插入图片描述
Push：可以让内存块链入自由链表中
Pop：可以将内存块从自由链表中移除（也就是该内存块被申请出去了）
Empty：可以判断该自由链表是否为空。

Push的过程
在这里插入图片描述
Push的实现

void Push(void* obj)
	{
   
		assert(obj);//断言保证obj不为空

		// 头插
		*(void**)obj = _freeList;
		_freeList = obj;
	}

因为*(void**)obj在后面很多地方都会用到，所以我们对其封装成函数

static void*& NextObj(void* obj)
{
   
	return *(void**)obj;
}
//这里用static的原因是因为，NextObj是
//被放进行Common.h文件的，而Common.h文件
//肯被对个.cpp文件包含，那么到时编译器就会
//报错
//而static修饰函数表示只在Common.h文件内有效

所以我们Push就可改成

void Push(void* obj)
	{
   
		assert(obj);//断言保证obj不为空

		// 头插
		//*(void**)obj = _freeList;
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

如果大家不理解*(void**)obj，可以去之前的博客观看，这里不再做讲解。

Pop的过程：
在这里插入图片描述
Pop的实现：

void* Pop()
	{
   
		assert(_freeList);//_freeList一定不能为空

		// 头删
		void* obj = _freeList;
		_freeList = NextObj(obj);

		return obj;
	}

Empty的实现

bool Empty()
	{
   
		return _freeList == nullptr;
	}

自由链表的完整实现

// 管理切分好的小对象的自由链表
class FreeList
{
   
public:
	void Push(void* obj)
	{
   
		assert(obj);

		// 头插
		//*(void**)obj = _freeList;
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

	void* Pop()
	{
   
		assert(_freeList);

		// 头删
		void* obj = _freeList;
		_freeList = NextObj(obj);

		return obj;
	}

	bool Empty()
	{
   
		return _freeList == nullptr;
	}
private:
	void* _freeList = nullptr;
};

ThreadCache申请内存过程的实现

首先做项目，我们肯定要定义一个包含头文件的.h文件一般命名为Common.h文件
Common.h

//Common.h
#pragma once
#include <iostream>
#include <assert.h>
using std::cout;
using std::endl;

// thread cache 和 central cache自由链表哈希桶的表大小
static const size_t NFREELISTS = 208;

static void*& NextObj(void* obj)
{
   
	return *(void**)obj;
}

// 管理切分好的小对象的自由链表
class FreeList
{
   
public:
	void Push(void* obj)
	{
   
		assert(obj);

		// 头插
		//*(void**)obj = _freeList;
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

	void* Pop()
	{
   
		assert(_freeList);

		// 头删
		void* obj = _freeList;
		_freeList = NextObj(obj);

		return obj;
	}

	bool Empty()
	{
   
		return _freeList == nullptr;
	}
private:
	void* _freeList = nullptr;
};

这里我们先定义这几个，等其它有用到再慢慢添加。
然后实现ThreadCache也要定义两个文件。
一个是ThreadCache.h，ThreadCache.cpp
ThreadCache定义两个文件是为了声明和定义分离，这样更符合实际的项目场景。

ThreadCache.h

//ThreadCache.h
#include "Common.h"

ThreadCache.cpp

//ThreadCache.cpp
#include "ThreadCache.h"

ThreadCache需要的成员变量

在这里插入图片描述
从ThreadCache的结构中我们就可以知道，我们肯定要定义一个指针数组，而每个指针都用来管理内存块，所以这些指针都是自由链表指针

class ThreadCache
{
   
public:
	
private:
	FreeList _freeLists[NFREELIST];
};

NFREELIST是thread cache自由链表哈希桶的表大小，为208个，所以我们还要Common.h中定义。

ThreadCache需要的成员函数

class ThreadCache
{
   
public:
	// 申请和释放内存对象
	void* Allocate(size_t size);
	void Deallocate(void* ptr, size_t size);

	// 从中心缓存获取对象
	void* FetchFromCentralCache(size_t index, size_t size);
private:
	FreeList _freeLists[NFREELIST];
};

Allocate：申请内存对象
Deallocate：释放内存对象
FetchFromCentralCache：哈希桶如果内存空间不够，向中心缓存（central cache）申请内存空间

ThreadCache.h文件代码

#pragma once

#include "Common.h"

class ThreadCache
{
   
public:
	// 申请和释放内存对象
	void* Allocate(size_t size);
	void Deallocate(void* ptr, size_t size);

	// 从中心缓存获取对象
	void* FetchFromCentralCache(size_t index, size_t size);
private:
	FreeList _freeLists[NFREELIST];
};

那么接下来就是实现这些成员函数了。

Allocate的实现

首先我们要知道申请的空间的字节数大小是多少。
其次我们要对该大小进行对齐，我们用自己设定的对齐规则对原字节数大小对齐
最后我们要根据字节数大小找到对应的哈希桶。

那么这是我们就要设计一个类帮助我们解决这些问题。

//放在common.h中
// 计算对象大小的对齐映射规则
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)

	//方法一：
	/*size_t _RoundUp(size_t size, size_t alignNum)
	{
		size_t alignSize;
		if (size % alignNum != 0)
		{
			alignSize = (size / alignNum + 1)*alignNum;
		}
		else
		{
			alignSize = size;
		}

		return alignSize;
	}*/
	// 1-8 
	//方法二：
	static inline size_t _RoundUp(size_t bytes, size_t alignNum)
	{
   
		return ((bytes + alignNum - 1) & ~(alignNum - 1));
	}
	
	//字节对齐
	static inline size_t RoundUp(size_t size)
	{
   
		if (size <= 128)
		{
   
			return _RoundUp(size, 8);
		}
		else if (size <= 1024)
		{
   
			return _RoundUp(size, 16);
		}
		else if (size <= 8*1024)
		{
   
			return _RoundUp(size, 128);
		}
		else if (size <= 64*1024)
		{
   
			return _RoundUp(size, 1024);
		}
		else if (size <= 256 * 1024)
		{
   
			return _RoundUp(size, 8*1024);
		}
		else
		{
   
			assert(false);
			return -1;
		}
	}

	//方法一：
	/*size_t _Index(size_t bytes, size_t alignNum)
	{
	if (bytes % alignNum == 0)
	{
	return bytes / alignNum - 1;
	}
	else
	{
	return bytes / alignNum;
	}
	}*/

	//方法二：
	static inline size_t _Index(size_t bytes, size_t align_shift)
	{
   
		return ((bytes + (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;
	}


};

Allocate的实现

void* ThreadCache::Allocate(size_t size)
{
   
	//size是要申请空间的字节大小
	//MAX_BYTES为最大申请的空间字节数 256*1024字节
	assert(size <= MAX_BYTES);
	//首先计算出对齐字节数和对应桶的下标
	size_t alignSize = SizeClass::RoundUp(size);
	size_t index = SizeClass::Index(size);
	
	//如果对应桶不为空，则拿对应的字节空间
	if (!_freeLists[index].Empty())
	{
   
		return _freeLists[index].Pop();
	}
	else//如果对应桶为空，则向中心缓存申请空间
	{
   
		return FetchFromCentralCache(index, alignSize);
	}
}

Deallocate的实现

void ThreadCache::Deallocate(void* ptr, size_t size)
{
   
	assert(ptr);
	assert(size <= MAX_BYTES);

	// 找对映射的自由链表桶，对象插入进入
	size_t index = SizeClass::Index(size);
	_freeLists[index].Push(ptr);

封装ThreadCache层可以多线程访问

只要在ThreadCache.h文件添加下列代码，就可以支持多线程访问。

// TLS thread local storage
static _declspec(thread) ThreadCache* pTLSThreadCache = nullptr;

然后用ConcurrentAlloc.h封装ThreadCache层，不让外面直接可以访问到ThreadCache的函数。保证安全性

pragma once

#include "Common.h"
#include "ThreadCache.h"

static void* ConcurrentAlloc(size_t size)
{
   
	// 通过TLS 每个线程无锁的获取自己的专属的ThreadCache对象
	if (pTLSThreadCache == nullptr)
	{
   
		pTLSThreadCache = new ThreadCache;
	}

	return pTLSThreadCache->Allocate(size);
}

static void ConcurrentFree(void* ptr, size_t size)
{
   
	assert(pTLSThreadCache);

	pTLSThreadCache->Deallocate(ptr, size);
}

ThreadCache层完整代码

Common.h

#pragma once

#include <iostream>
#include <vector>
#include <thread>
#include <time.h>
#include <assert.h>
using std::cout;
using std::endl;

static const size_t MAX_BYTES = 256 * 1024;
static const size_t NFREELIST = 208;

static void*& NextObj(void* obj)
{
   
	return *(void**)obj;
}

// 管理切分好的小对象的自由链表
class FreeList
{
   
public:
	void Push(void* obj)
	{
   
		assert(obj);

		// 头插
		//*(void**)obj = _freeList;
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

	void* Pop()
	{
   
		assert(_freeList);

		// 头删
		void* obj = _freeList;
		_freeList = NextObj(obj);

		return obj;
	}

	bool Empty()
	{
   
		return _freeList == nullptr;
	}
private:
	void* _freeList = nullptr;
};

// 计算对象大小的对齐映射规则
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)

	/*size_t _RoundUp(size_t size, size_t alignNum)
	{
		size_t alignSize;
		if (size % alignNum != 0)
		{
			alignSize = (size / alignNum + 1)*alignNum;
		}
		else
		{
			alignSize = size;
		}

		return alignSize;
	}*/
	// 1-8 
	static inline size_t _RoundUp(size_t bytes, size_t alignNum)
	{
   
		return ((bytes + alignNum - 1) & ~(alignNum - 1));
	}

	static inline size_t RoundUp(size_t size)
	{
   
		if (size <= 128)
		{
   
			return _RoundUp(size, 8);
		}
		else if (size <= 1024)
		{
   
			return _RoundUp(size, 16);
		}
		else if (size <= 8*1024)
		{
   
			return _RoundUp(size, 128);
		}
		else if (size <= 64*1024)
		{
   
			return _RoundUp(size, 1024);
		}
		else if (size <= 256 * 1024)
		{
   
			return _RoundUp(size, 8*1024);
		}
		else
		{
   
			assert(false);
			return -1;
		}
	}

	/*size_t _Index(size_t bytes, size_t alignNum)
	{
	if (bytes % alignNum == 0)
	{
	return bytes / alignNum - 1;
	}
	else
	{
	return bytes / alignNum;
	}
	}*/

	// 1 + 7  8
	// 2      9
	// ...
	// 8      15
	
	// 9 + 7 16
	// 10
	// ...
	// 16    23
	static inline size_t _Index(size_t bytes, size_t align_shift)
	{
   
		return ((bytes + (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;
	}


};

ThreadCache.h

#pragma once

#include "Common.h"

class ThreadCache
{
   
public:
	// 申请和释放内存对象
	void* Allocate(size_t size);
	void Deallocate(void* ptr, size_t size);

	// 从中心缓存获取对象
	void* FetchFromCentralCache(size_t index, size_t size);
private:
	FreeList _freeLists[NFREELIST];
};

// TLS thread local storage
static _declspec(thread) ThreadCache* pTLSThreadCache = nullptr;

ThreadCache.cpp

#include "ThreadCache.h"

void* ThreadCache::FetchFromCentralCache(size_t index, size_t size)
{
   
	// ...
	return nullptr;
}

void* ThreadCache::Allocate(size_t size)
{
   
	assert(size <= MAX_BYTES);
	size_t alignSize = SizeClass::RoundUp(size);
	size_t index = SizeClass::Index(size);

	if (!_freeLists[index].Empty())
	{
   
		return _freeLists[index].Pop();
	}
	else
	{
   
		return FetchFromCentralCache(index, alignSize);
	}
}

void ThreadCache::Deallocate(void* ptr, size_t size)
{
   
	assert(ptr);
	assert(size <= MAX_BYTES);

	// 找对映射的自由链表桶，对象插入进入
	size_t index = SizeClass::Index(size);
	_freeLists[index].Push(ptr);
}

ConcurrentAlloc.h

#pragma once

#include "Common.h"
#include "ThreadCache.h"

static void* ConcurrentAlloc(size_t size)
{
   
	// 通过TLS 每个线程无锁的获取自己的专属的ThreadCache对象
	if (pTLSThreadCache == nullptr)
	{
   
		pTLSThreadCache = new ThreadCache;
	}

	return pTLSThreadCache->Allocate(size);
}

static void ConcurrentFree(void* ptr, size_t size)
{
   
	assert(pTLSThreadCache);

	pTLSThreadCache->Deallocate(ptr, size);
}
阅读全部

相关推荐

  5. 【lesson12】高并发内存池项目最终完整版代码

    2024-02-01 06:16:07       28 阅读

  10. 【高并发服务器 02】——线程池与IO多路复用

    2024-02-01 06:16:07       19 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-02-01 06:16:07       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-02-01 06:16:07       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-02-01 06:16:07       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-02-01 06:16:07       20 阅读

热门阅读

  1. KAFKA鉴权设计以及相关探讨

    2024-02-01 06:16:07       34 阅读

  8. 优雅管理多线程异步任务 - 永动异步任务

    2024-02-01 06:16:07       33 阅读

  9. Jenkins插件安装推荐

    2024-02-01 06:16:07       32 阅读

  13. 2024.1.31

    2024-02-01 06:16:07       22 阅读

  14. 前端Vue日常工作中--CSS变量

    2024-02-01 06:16:07       27 阅读

  18. R语言【taxlist】——subset()：取taxlist对象的子集

    2024-02-01 06:16:07       27 阅读
  20. Lua脚本

    Lua脚本

    2024-02-01 06:16:07      28 阅读

  22. 在next.js的13.2.1版本中使用中间件，实现禁止特定ip访问网址所有页面

    2024-02-01 06:16:07       34 阅读

  30. C语言实现的数组合并与排序程序

    2024-02-01 06:16:07       25 阅读