C++项目高并发内存池_ThreadCache设计

已于 2022-03-01 14:55:01 修改
阅读量865 收藏 2
点赞数 3
分类专栏： # C++高并发内存池 文章标签： c++ 链表 数据结构
于 2022-03-01 14:54:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dodamce/article/details/123185205
版权

文章目录

thread cache设计思路

thread cache：每一个线程都有一个独立的空间，当线程都要申请空间（小于256KB）时直接在线程内部申请，不需要加锁竞争。

根据之前设计的定长内存池可知，一条链表管理释放内存只能处理固定内存大小的情况
如：这个自由链表每个节点都是4字节，这条链表只能处理申请4字节空间的情况。
而实际线程申请的空间不一定是相同的所以这里需要多条链表来处理。多条链表用哈希桶来管理

但是哈希桶中桶个数为多少合适呢，假设以8字节为一个桶

在这里插入图片描述

这里选择每8字节为一个桶，如果要申请5字节内存，也向其提供8字节。
申请9字节提供16字节空间。(这样不可避免的造成了内存泄漏的问题)
这里我们单独设计类管理对齐规则。

因为在64位下一个指针为8字节，所以每个桶中链表节点大小至少要等于8字节

但是每8个字节一个桶，桶的个数太多了。所以采用分级分桶

整体控制在最多10%左右的内碎片浪费
[1,128] 8byte对齐 freelist[0,16)
[128+1，1KB] 16byte对齐 freelist[16,72)
[1KB+1，8KB] 128byte对齐 freelist[72,128)
[8KB+1，64KB] 1KB对齐 freelist[128,184)
[64KB+1，256KB] 8KB对齐 freelist[184,208)
这样的话256KB只需要208个桶（208个自由链表）可以接受。

#pragma once

#include<iostream>
#include<vector>
#include<time.h>
#include<assert.h>

using std::cout; using std::endl;

static const size_t MAX_BYTE = 126 * 1024;//如果线程申请超过126KB不能直接向ThreadCache申请空间

static const size_t NUMLIST = 208;//ThreadCache中哈希桶的个数

//获取自由链表下一个节点
void*& NextObj(void* obj) {
	return *(void**)obj;
}

//管理切分好内存的自由链表
class FreeList {
public:
	FreeList() :_freeList(nullptr) {}
	void Push(void* obj) {
		//头插
		assert(obj);
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

	void* Pop() {
		//头删
		assert(_freeList);
		void* obj = _freeList;
		_freeList = NextObj(obj);
	}

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

//计算ThreadCache中哈希桶的桶个数
class SizeClass {
public:
	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;
		}
	}
	//计算在哈希桶的那个位置
	static inline size_t Index(size_t size) {
		assert(size <= MAX_BYTE);
		static int Group[4] = { 16,56,56,56 };
		if (size <= 128) return _Index(size, 8);
		else if (size <= 1024) return _Index(size - 128, 16) + Group[0];
		else if (size <= 8 * 1024) return _Index(size - 1024, 128) + Group[1] + Group[0];
		else if (size < 64 * 1024) return _Index(size - 8 * 1024, 1024) + Group[2] + Group[1] + Group[0];
		else if (size < 256 * 1024) return _Index(size - 64 * 1024, 8 * 1024) + Group[3] + Group[2] + Group[1] + Group[0];
		else {
			assert(false);
			return -1;
		}
	}
private:
	static inline size_t _RoundUp(size_t size, size_t AlignNum) {
		size_t AligSize = size;
		if (size % AlignNum != 0) {
			AligSize = (size / AlignNum + 1) * AlignNum;
		}
		return AligSize;
	}
	static inline size_t _Index(size_t size, size_t AlignNum) {
		size_t Pos = 0;
		if (size % AlignNum == 0) {
			Pos = size / AlignNum - 1;
		}
		else {
			Pos = size / AlignNum;
		}
		return Pos;
	}
};

thread cache实现无锁访问（线程本地存储）

线程共享进程地址空间，每个线程有独立的栈。高并发内存池中每个线程都有独立的thread cache。

线程本地存储：是一种变量的储存方法，这个变量在线程内部是可访问的，但是其他线程不能访问到。(TLS)

Windows TLS

Linux TLS

window创建静态ThreadCacheTLS为static __declspec(thread) ThreadCache*

还要注意用static修饰，防止重复定义

C++高并发内存池 ThreadCache代码

1.公共头文件Commen.h

#pragma once

#include<iostream>
#include<vector>
#include<time.h>
#include<assert.h>
#include<thread>

using std::cout; using std::endl;

static const size_t MAX_BYTE = 126 * 1024;//如果线程申请超过126KB不能直接向ThreadCache申请空间

static const size_t NUMLIST = 208;//ThreadCache中哈希桶的个数

//获取自由链表下一个节点
void*& NextObj(void* obj) {
	return *(void**)obj;
}

//管理切分好内存的自由链表
class FreeList {
public:
	FreeList() :_freeList(nullptr) {}
	void Push(void* obj) {
		//头插
		assert(obj);
		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;
};

//计算ThreadCache中哈希桶的桶个数
class SizeClass {
public:
	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;
		}
	}
	//计算在哈希桶的那个位置
	static inline size_t Index(size_t size) {
		assert(size <= MAX_BYTE);
		static int Group[4] = { 16,56,56,56 };
		if (size <= 128) return _Index(size, 8);
		else if (size <= 1024) return _Index(size - 128, 16) + Group[0];
		else if (size <= 8 * 1024) return _Index(size - 1024, 128) + Group[1] + Group[0];
		else if (size < 64 * 1024) return _Index(size - 8 * 1024, 1024) + Group[2] + Group[1] + Group[0];
		else if (size < 256 * 1024) return _Index(size - 64 * 1024, 8 * 1024) + Group[3] + Group[2] + Group[1] + Group[0];
		else {
			assert(false);
			return -1;
		}
	}
private:
	static inline size_t _RoundUp(size_t size, size_t AlignNum) {
		size_t AligSize = size;
		if (size % AlignNum != 0) {
			AligSize = (size / AlignNum + 1) * AlignNum;
		}
		return AligSize;
	}
	static inline size_t _Index(size_t size, size_t AlignNum) {
		size_t Pos = 0;
		if (size % AlignNum == 0) {
			Pos = size / AlignNum - 1;
		}
		else {
			Pos = size / AlignNum;
		}
		return Pos;
	}
};

2.ThreadCache.h

#pragma once

#include"Common.h"

class ThreadCache {
private:
	FreeList _FreeList[NUMLIST];
public:
	//申请释放空间
	void* ApplySpace(size_t size) {
		assert(size <= MAX_BYTE);
		size_t AligSize = SizeClass::RoundUp(size);
		//计算桶位置
		size_t index = SizeClass::Index(AligSize);
		if (!_FreeList[index].Empty()) {
			return _FreeList[index].Pop();
		}
		else {
			//thread cache没有内存向central cache要空间
			return RequestFromCentralCache(index, AligSize);
		}
	}
	void ReleaseSpace(void* ptr, size_t size) {
		assert(size <= MAX_BYTE && ptr != nullptr);
		size_t index = SizeClass::Index(size);//找到第几个桶
		//将这个空间头插到自由链表上
		_FreeList[index].Push(ptr);
	}

	//向中心缓存申请空间，先空开
	void* RequestFromCentralCache(size_t index, size_t size) { return nullptr; }
};

//每个线程都会拥有自己的ThreadCache
static __declspec(thread) ThreadCache* tls_threadcache = nullptr;//用static修饰只在当前文件可见

3.线程申请独立的ThreadCache空间实现无锁（ConcurrentAlloc.h）

#pragma once

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

//线程调用申请ThreadCache空间
static void* ConcurrentAlloc(size_t size) {
	//获取线程自己的ThreadCache
	if (tls_threadcache == nullptr) {
		tls_threadcache = new ThreadCache;
	}
	cout << std::this_thread::get_id()<<" "<<tls_threadcache<< endl;
	return tls_threadcache->ApplySpace(size);
}

static void ConcurrentFree(void* ptr, size_t size) {
	//释放时每个线程一定有tls_threadcache
	assert(tls_threadcache != nullptr);
	tls_threadcache->ReleaseSpace(ptr,size);
}

测试Window下静态TLS

#include"ConcurrentAlloc.h"

void Alloc() {
	for (int i = 0; i < 10; i++) {
		void* ptr = ConcurrentAlloc(6);
	}
}

void Alloc2() {
	for (int i = 0; i < 10; i++) {
		void* ptr = ConcurrentAlloc(7);
	}
}

void TestTLS() {
	std::thread t1(Alloc);
	t1.join();
	std::thread t2(Alloc2);
	t2.join();
}

int main()
{
	TestTLS();
	return 0;
}

在这里插入图片描述
如上图可知两个线程拥有不同的ThreadCache对象，且这两个对象相互独立，这两个线程申请ThreadCache空间时不需要加锁

NUC_Dodamce
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【BOOST C++ 13 并行编程】（3） 线程本地存储
gongdiwudu的专栏
11-17 2541
线程本地存储 (TLS) 是一个只能由一个线程访问的专用存储区域。 TLS 变量可以看作是全局变量，只对特定线程可见，对整个程序不可见。
【C++项目设计】高并发内存池.zip
05-28
本项目实现的是一个高并发的内存池，它的原型是Google的一个开源项目tcmalloc，tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替换系统的内存分配相关函数malloc和free...
并发内存池
DaiLan_的博客
04-06 236
该项目主要模拟实现tcmalloc最核心的框架。高并发内存池主要解决的是内存碎片问题，而内存碎片又分为内碎片和外碎片。在32位平台下以外碎片为例，如下图：假设已申请3G的内存，现在想再申请950M的内存，虽然合计剩余内存大于950M，但是由于空间不连续，因此无法申请到950M的内存空间，这就是由于外碎片问题导致申请内存失败。内存池是程序在向操作系统申请内存时，申请过量内存，由进程自己将这些过量内存组织起来，待到需要使用内存的时候，直接分配，而不需要频繁地向操作系统申请内存，
【C++项目】高并发内存池
最新发布
weixin_53831496的博客
01-25 1044
当前项目是实现一个高并发的内存池，他的原型是google的一个开源项目tcmalloc，tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替代系统的内存分配相关的函数（malloc、free）。所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次申请该资源都有较大的开销，不如提前申请好了，这样使用时就会变得非常快捷，大大提高程序运行效率。
C++实现的高并发内存池
mz474920631的博客
06-08 2745
C/C++下内存管理是件很头疼的事，分配足够的内存、追踪内存的分配、在不需要的时候释放内存—这个任务很复杂。如果直接使用系统调用malloc/free、new/delete进行内存分配和释放，则会有以下弊端：内存池（memory pool)是代替直接调用malloc/free、new/delete进行内存管理的常用方法，当我们申请内存空间时，首先到我们的内存池中查找合适的内存块，而不是直接向操作系统申请，优势在于：现代很多的开发环境都是多核多线程，在申请内存的场景下，必然存在激烈的锁竞争问题。malloc本
mysql thread cache_MySQL性能优化配置参数之thread_cache和table_cache详解
weixin_39617470的博客
01-19 433
一、THREAD_CACHEMySQL里面为了提高客户端请求创建连接过程的性能,提供了一个连接池也就是 Thread_Cache池,将空闲的连接线程放在连接池中,而不是立即销毁.这样的好处就是,当又有一个新的请求的时候,mysql不会立即去创建连接 线程,而是先去Thread_Cache中去查找空闲的连接线程,如果存在则直接使用,不存在才创建新的连接线程.有关Thread_Cache在MySQL有...
基于C++研究高并发内存池
毕业作品网站
07-24 265
3.pagecache页缓存时在centralcache缓存上面的一层缓存，存储的内存是以页为单位存储及分配的，centralcache没有内存对象时，从pagecache分配出一定数量的page，并切割成定长大小的内存，分配给centralcache，当一个span的及格跨度也的对象都回收以后，pagecache会回收centralcache满足条件的span对象，并且合并相邻的页，组成更大的页，缓解内存碎片的问题。......
基于C++研究高并发内存池【100011812】
04-11
内存池：程序预先向系统申请一大块足够的内存，此后，当系统需要申请内存的时候，不是直接向操作习题申请，而是向内存池中申请，当释放的时候，不返回给操作系统，而是返回给内存池，当程序退出时，内存池才将申请的...
高并发内存池项目原始代码，开源项目
01-12
高并发内存池，模仿tcmalloc的最核心的框架。包含基数树优化等内容。
C++内存池完整代码memory_pool.zip
04-03
C++内存池完整代码memory_pool Makefile
c++高性能内存池.rar
03-27
std::allocator 是 C++标准库中提供的默认分配器，他的特点就在于我们在 使用 new 来申请内存构造新对象的时候，势必要调用类对象的默认构造函数 ...所以为了让代码直接可用，我们同样应该在内存池中设计同样的接口：
TCMalloc : Thread-Caching Malloc高性能的内存分配器(C/C++)
伍意的博客
06-29 1683
 TCMalloc : Thread-Caching Malloc Sanjay Ghemawat, Paul Menage Motivation TCMalloc is faster than the glibc 2.3 malloc (available as a separate library called ptmalloc2) and other mallocs that
c++多线程 thread mutex 使用小结
杂七杂八
11-11 9014
c++多线程 thread mutex 使用小结std::thread std::mutex 基本使用方法std::thread 用于开启一个线程。std::mutex 是互斥锁，防止不同线程间的代码在不同线程间做不安全的切换std::mutex try_lock()子线程作生产者、主线程做消费者子线程做加载、主线程显示百分比多线程里遇到的几个问题： c++对于多线程的支持，依赖于 std::th...
mysql优化之thread_cache_size
篱笆女人和狗的博客
02-21 1138
即可以重新利用保存在缓存中线程的数量，当断开连接时如果缓存中还有空间，那么客户端的线程将被放到缓存中，如果线程重新被请求，那么请求将从缓存中读取，如果缓存中是空的或者是新的请求，那么这个线程将被重新创建，如果有很多新的线程，增加这个值可以改善系统性能。对于长连接，不能保证连接的稳定性，所以设置这参数还是有一定必要，可能连接池的问题，会导致连接数据库的不稳定性，也会出现频繁的创建和销毁，但这个情况比较少，如果是长连接，可以设置成小一点，一般在50-100左右。2、优化参数thread_cache_size。
高并发内存池的整体框架以及thread cache
weixin_73077979的博客
03-12 138
项目框架以及thread cache
[收藏]__declspec关键字详细用法
ahch8077的博客
05-17 367
原文链接：http://hi.baidu.com/baiyw920/blog/item/a06ddb986314fd0f6e068c0c.html __declspec用于指定所给定类型的实例的与Microsoft相关的存储方式。其它的有关存储方式的修饰符如static与extern等是C和C++语言的ANSI规范，而__declspec是一种扩展属性的定义。扩展属性...
C++项目：高并发内存池
qq_41646522的博客
03-09 469
内存池 1. 池化 池化是一种常用设计模式：程序运行过程中常用的资源频繁申请/释放，对于该共享资源使用时还要竞争加锁使用。如果放到一个池通过池来管理资源（在使用前先申请，由程序管理申请和释放，可提高资源利用率）。 常用池化技术： 1. 内存池 不使用用内存池：通常情况下，程序员习惯直接使用new，delete，malloc,free等API申请和释放内存，在一个程序运行期间频繁申请释放不定长内存，使内存中出现很多内部碎片和外部碎片。 无回收机制，导致内存泄漏（由于疏忽或错误造成程序未能释放已经不再使用的 内
使用线程本地存储
believe_s的博客
09-11 660
线程本地存储（TLS）使同一进程的多个线程能够使用由TlsAlloc函数分配的索引来存储和检索线程本地的值。在此示例中，在进程启动时分配索引。当每个线程启动时，它会分配一个动态内存块，并使用TlsSetValue函数在TLS槽中存储指向此内存的指针。CommonFunc函数使用TlsGetValue函数来访问与调用线程本地的索引相关联的数据。在每个线程终止之前，它会释放其动态内存。在进程终止之前，...
写一个c++符合高并发的内存池
01-16
在 C 语言中，可以使用多线程和锁机制来实现内存池，以满足高并发的需求。 下面是一个例子： ``` #include #include #include #define POOL_SIZE 1000000 // 内存池大小 static char memory_pool[POOL_SIZE];...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NUC_Dodamce

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值