通用C++内存池代码

最新推荐文章于 2023-01-08 20:33:47 发布
最新推荐文章于 2023-01-08 20:33:47 发布
阅读量1.6k 收藏
点赞数 2
分类专栏： C/C++ 文章标签： c++ struct table delete byte class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kevin_qing/article/details/7340257
版权

原理在这里http://blog.csdn.net/kevin_qing/article/details/608891

以前代码找不到了，重写一次。

加上了一些简单的错误检测代码。帮助调试内存问题。

初步代码，还未仔细检查，有bug请留言。

 

//type and macro
#include <default.h>

//debug 信息
const	bool	DebugQMem=1;

struct	QMemDebugInfo{
	uint32_t		mask;
	uint32_t		size;
	byte			guard[128-8];
};


template <bool flag, typename T, typename U>
struct TypeSelectT
{
private:
 template<bool>
 struct In 
 { typedef T Result; };

 template<>
 struct In<false>
 { typedef U Result; };

public:
 typedef typename In<flag>::Result Result;
};

//计算ln(x)/ln(y)，向上转换为整形
template <uint64_t x,uint64_t y>
struct logT{
protected:
 template <uint64_t x1>
 struct imp{
  enum {
   next=(x1+y-1)/y,
  };
  enum {Result=1+imp<next>::Result};
 };

 template <>struct imp<1>{
  enum {Result=0};
 };

public:
 enum {Result=imp<x>::Result};
};

//x^y
template <uint64_t x,uint64_t y>
struct powerT{
protected:
 template <uint64_t y1>
 struct imp{
  enum{
   next=y1-1
  };
  enum{
   Result=x*imp<next>::Result
  };
 };
 template<> struct imp<0>{
  enum{
   Result=1
  };
 };

public:
 enum{
  Result=imp<y>::Result
 };
};


//缓存表,
template <uint64_t index>
struct cacheCount{

 //table<>未实现0,1,2,3,所以不允许<16b的对象编译通过，避免空间太小不能容纳调试信息。

	template <uint64_t>	struct	table;
	template <>	struct table<4>{ enum{	Result= 4096	};};	//16b -> 64k
	template <>	struct table<5>{ enum{	Result= 4096	};};	//32b -> 128k
	template <>	struct table<6>{ enum{	Result= 4096	};};	//64b -> 256k
	template <>	struct table<7>{ enum{	Result= 4096	};};	//128b-> 512k
	template <>	struct table<8>{ enum{	Result= 2048	};};	//256b-> 512k
	template <>	struct table<9>{ enum{	Result= 2048	};};	//512b-> 1m
	template <>	struct table<10>{ enum{	Result= 2048	};};	//1k  -> 2m
	template <>	struct table<11>{ enum{	Result= 2048	};};	//2k  -> 4m
	template <>	struct table<12>{ enum{	Result= 1024	};};	//4k  -> 4m
	template <>	struct table<13>{ enum{	Result= 1024	};};	//8k  -> 8m
	template <>	struct table<14>{ enum{	Result= 1024	};};	//16k -> 16m
 //更多的使用时添加
	template <>	struct table<20>{ enum{	Result= 4		};};	//1m -> 4m
	struct	minCache{enum	{Result=2};};
	enum	{Result=TypeSelectT<index<20,table<logT<index,2>::Result>,minCache>::Result::Result };
};





//链表，用于可用空间回收
struct	QMemLink{
	QMemLink*	next;
};

class	QMemTest;

byte*	QAlloc(size_t s){
	return	new byte[s];
}

template <size_t size> 
class QFixAllocator{

friend	class	QMemTest;
	uint64_t	usageBytes;
	uint64_t	allocBytes;
	uint64_t	poolBytes;
	QMemLink*	memPool;
	enum	{sizeFix=powerT<2,logT<size,2>::Result>::Result};
	enum	{caches=cacheCount<sizeFix>::Result};
protected:
	QFixAllocator(){
		usageBytes=0;
		allocBytes=0;
		poolBytes=0;
		memPool=NULL;
	}

public:
	void* alloc(size_t s){
		assert(s<=sizeFix);//避免new[]call到错误的allocator,host class应该使用单独版本的new[]()，而不是默认调用new()

		QMemLink*	r;
		if(memPool){
			r=memPool;
			memPool=memPool->next;
			poolBytes-=sizeFix;
			usageBytes+=s;
			return	r;
		}

		byte*	p=QAlloc(sizeFix*caches);

		memPool=(QMemLink*)p;
		for(int i=1;i<caches;++i){
			r=(QMemLink*)p;
			p+=sizeFix;
			r->next=(QMemLink*)p;;
		}
		r->next=NULL;
		poolBytes+=(caches-1)*sizeFix;
		usageBytes+=s;

		allocBytes+=caches*sizeFix;
		return	p;

	}

	void free(void*p,size_t s){
		QMemLink*	l=(QMemLink*)p;
		l->next=memPool;
		memPool=l;
		usageBytes-=s;
		poolBytes+=size;
	}
	void	status(uint64_t &u,uint64_t &a,uint64_t& p)const{
		u=usageBytes;
		a=allocBytes;
		p=poolBytes;
	}

	typedef     QFixAllocator me;

	static me Instance;

	};



typedef	QFixAllocator<powerT<2,4>::Result>	QFixAllocator_4;
typedef	QFixAllocator<powerT<2,5>::Result>	QFixAllocator_5;
typedef	QFixAllocator<powerT<2,6>::Result>	QFixAllocator_6;
typedef	QFixAllocator<powerT<2,7>::Result>	QFixAllocator_7;
typedef	QFixAllocator<powerT<2,8>::Result>	QFixAllocator_8;
typedef	QFixAllocator<powerT<2,9>::Result>	QFixAllocator_9;
typedef	QFixAllocator<powerT<2,10>::Result>	QFixAllocator_10;
typedef	QFixAllocator<powerT<2,11>::Result>	QFixAllocator_11;
typedef	QFixAllocator<powerT<2,12>::Result>	QFixAllocator_12;
typedef	QFixAllocator<powerT<2,13>::Result>	QFixAllocator_13;
typedef	QFixAllocator<powerT<2,14>::Result>	QFixAllocator_14;
typedef	QFixAllocator<powerT<2,15>::Result>	QFixAllocator_15;
typedef	QFixAllocator<powerT<2,16>::Result>	QFixAllocator_16;
typedef	QFixAllocator<powerT<2,17>::Result>	QFixAllocator_17;
typedef	QFixAllocator<powerT<2,18>::Result>	QFixAllocator_18;
typedef	QFixAllocator<powerT<2,19>::Result>	QFixAllocator_19;
typedef	QFixAllocator<powerT<2,20>::Result>	QFixAllocator_20;
typedef	QFixAllocator<powerT<2,21>::Result>	QFixAllocator_21;


QFixAllocator_10	QFixAllocator_10::Instance;
QFixAllocator_11	QFixAllocator_11::Instance;
QFixAllocator_12	QFixAllocator_12::Instance;
QFixAllocator_13	QFixAllocator_13::Instance;
QFixAllocator_14	QFixAllocator_14::Instance;
QFixAllocator_15	QFixAllocator_15::Instance;
QFixAllocator_16	QFixAllocator_16::Instance;
QFixAllocator_17	QFixAllocator_17::Instance;
QFixAllocator_18	QFixAllocator_18::Instance;
QFixAllocator_19	QFixAllocator_19::Instance;
QFixAllocator_20	QFixAllocator_20::Instance;
QFixAllocator_21	QFixAllocator_21::Instance;












template	<class Host>
class	QMemImpl{
public:

	void*	operator	new(size_t size){
		return	QFixAllocator<powerT<2,logT<sizeof(Host),2>::Result>::Result>::Instance.alloc(size);
	}

	void	operator	delete(void*p){
		return	QFixAllocator<powerT<2,logT<sizeof(Host),2>::Result>::Result>::Instance.free(p,sizeof(Host));
	}

	void*	operator	new[](size_t size){
		
		size+=8;	//x64 8字节对齐

		ULONG	r,f;
		_BitScanReverse(&r,size);
		_BitScanReverse(&f,size);
		
		if(r!=f)	//对齐
			++r;

		switch(r){
			case	19://这里只处理了1m字节的分配
				{
					uint32_t *p=(uint32_t*)QFixAllocator_20::Instance.alloc(size);
					*p=19;//set mask
					++p;
					*p=size;
					return	++p;
				}
		
			default:
				DebugBreak();
		}
		throw	"bad alloc";
	}

	void	operator	delete[](void*p){
		uint32_t*	p32=(uint32_t*)p;
		p32-=2;
		switch(*p32){
			case	19://这里只处理了1m字节的释放
				QFixAllocator_20::Instance.free(p32,*(p32+1));
				return;
			default:
				DebugBreak();
		}

	}
};

template	<class Host>
class	QMemDebugImpl{
public:
	void*	operator	new(size_t size){

		QMemDebugInfo*	p=(QMemDebugInfo*)QFixAllocator<powerT<2,logT<sizeof(Host)+sizeof(QMemDebugInfo),2>::Result>::Result>::Instance.alloc(size);
		memset(p->guard,0,sizeof(p->guard));
		p->mask=logT<sizeof(Host)+sizeof(QMemDebugInfo),2>::Result;
		p->mask|=0x12345600;
		p->size=size;
		return	++p;

	}
	void	operator	delete(void*p){
		QMemDebugInfo*	pDebug=(QMemDebugInfo*)p;
		--pDebug;

		if((pDebug->mask&(~0xff))!=0x12345600){ //标志错，可能是乱用delete,new[]
			DebugBreak();
		}
		if(pDebug->size!=sizeof(Host)){		//size错
			DebugBreak();
		}

		//其他检查

		return	QFixAllocator<powerT<2,logT<sizeof(Host)+sizeof(QMemDebugInfo),2>::Result>::Result>::Instance.free(pDebug,sizeof(Host));
	}

	void*	operator	new[](size_t size){
		
		size+=sizeof(QMemDebugInfo);	
		ULONG	r,f;
		if(!_BitScanReverse(&r,size))
			DebugBreak();//size 0,不可能的情况
		_BitScanReverse(&f,size);
		
		if(r!=f)	//对齐
			++r;
		QMemDebugInfo *p;
		switch(r){
			case	19:
					p=(QMemDebugInfo*)QFixAllocator_20::Instance.alloc(size);
					p->mask=19;
					break;
			case	20:
					p=(QMemDebugInfo*)QFixAllocator_21::Instance.alloc(size);
					p->mask=20;
					break;
		
			default:
				DebugBreak();
		}
		memset(p->guard,0,sizeof(p->guard));
		p->size=size;
		return	++p;


	}

	void	operator	delete[](void*p){
		QMemDebugInfo *pDebug=(QMemDebugInfo*)p;
		--pDebug;

		if(pDebug->mask&(~0xff)){ //标志错，可能是乱用delete[],new
			DebugBreak();
		}
		if(pDebug->size<sizeof(Host)){		//size错
			DebugBreak();
		}

		ULONG	r,f;
		_BitScanReverse(&r,pDebug->size);
		_BitScanReverse(&f,pDebug->size);
		if(r!=f)
			++r;
		if(pDebug->mask!=r)
			DebugBreak();

		switch(pDebug->mask){
			case	19:
				QFixAllocator_20::Instance.free(pDebug,pDebug->size);
				return;
			case	20:
				QFixAllocator_21::Instance.free(pDebug,pDebug->size);
				return;

			default:
				DebugBreak();
		}

	}
};


template	<class Host>
class	QMemPool:public TypeSelectT<DebugQMem,QMemDebugImpl<Host>,QMemImpl<Host>>::Result	
{


};

class	QMemTest:public	QMemPool<QMemTest>{
	char	tmp[1000];
};


void	showMemInfo(){


	uint64_t	u,a,p;

	QFixAllocator_11::Instance.status(u,a,p);
	printf("_11 u=%I64u a=%I64u p=%I64u \n",u,a,p);

	QFixAllocator_20::Instance.status(u,a,p);
	printf("_20 u=%I64u a=%I64u p=%I64u \n",u,a,p);
}

void main(){

	QMemTest*	pTest[4096];


	showMemInfo();

	for(int i=0;i<countof(pTest);++i){
		pTest[i]=new	QMemTest;
	}
	printf("new\n");

	showMemInfo();

	for(int i=0;i<countof(pTest);++i){
		delete	pTest[i];
	}
	printf("delete\n");


	showMemInfo();
	delete	new	QMemTest[1024];

	printf("delete[] new[]\n");

	showMemInfo();



	
}


 

Kevin_qing
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++内存池完整代码memory_pool.rar
01-03
C++ 内存池完整 memory_pool
C++实现内存池
guoyilongedu的专栏
11-04 1221
想用C++实现内存池，参考了一下别人的代码 http://blog.csdn.net/chexlong/article/details/7071922 人家对内存块的管理是用vector,动态的插入与删除，来做内存的分配与回收，基于人家的代码，做的一些改动，用Map进行管理，用标志来区分该内存块是否已分配，回收时，内存里面的内容也得重置掉，以免影响下一次的调用。 代码如下 #ifndef _M
c++内存池
lichao201005的专栏
04-12 1509
此代码可作为商业代码，在使用内存池的场合直接拿来使用，特此记录！ // 分配内存池 嵌入式指针 class allocatorPool { public: //分配 void *allocator(size_t size) { obj *tmplink; if (m_FreePos == nullptr) { //分配内存池 size_t i_realsize = i_sTrunkCount * size; m_FreePos = (obj*)malloc(i_rea
C++内存池完整代码memory_pool.zip
04-03
C++内存池完整代码memory_pool Makefile
经典内存池c++源代码分享及性能对比研究
carlclouder的博客
09-24 451
最近在写一个IOCP扩展类，遇到内存池问题，网上的完整代码不多，可惜没钱下载，只能自己研究了，自己写了份代码，实现了基本功能，自动增加内存块，可实现较大吞吐量。代码分享出来，请大家交流，帮助优化。目前还只能实现单个对象的管理，大神请指点。 先来看性能对比结果，见下图（代码在后面，可能微博识别的原因导致贴上来后代码有些错误，自己调整）： Release模式下，反复循环处理总计5200万个对象，传统n...
C++实现高性能内存池.docx
04-29
在C++中，`std::allocator`是一个通用的内存分配器，它负责为容器如`std::vector`等分配和释放内存。然而，`std::allocator`在分配内存时会立即调用对象的构造函数，这并不适用于内存池的实现，因为内存池希望先分配...
代码雨c++源代码
09-19
首先，C++是静态类型、编译式的通用编程语言，以其高效性、灵活性和丰富的库支持而被广泛用于系统软件、游戏开发、高性能计算等场景。在实现代码雨特效时，C++的面向对象特性可能被用来封装文字对象、动画逻辑以及与...
深入探索C++内存池：高效内存管理的秘诀
最新发布
08-08
C++是一种通用的、面向对象的编程语言，它是由Bjarne Stroustrup在20世纪80年代初作为C语言的扩展而创建的。C++是C语言的一个超集，这意味着它包含了C语言的所有特性，并增加了面向对象编程的特性，如类和继承。C++...
C++内存泄漏检测原理+源代码
03-15
摘要:VC/C++源码,系统相关,内存泄漏　C++内存泄漏检测原理+实例源码下载，是一个跨平台的C++ 内存泄漏检测器的源程序，一个主要缺陷是不支持多线程。分配内存时不进行文件名复制，而只是保存其指针；效率较高（编译...
通用的C++数据结构代码实现.zip
07-27
这个"通用的C++数据结构代码实现.zip"压缩包很可能包含了一些常见的数据结构，如数组、链表、栈、队列、树、图以及哈希表等的实现。下面我们将详细探讨这些数据结构及其在C++中的应用。 1. **数组**：数组是最基础...
几种内存池的实现(c/c++ 源码)
07-25
几种 内存池 的实现 (c/c++ 源码)
多线程安全的内存池支持类
11-17
提供两个多线程安全的内存池支持类，详细的内容请看类说明
如何用100行C++代码实现内存池
C/C++Linux、音视频、DPDK
12-29 266
内存池 是 池化技术 的一种，通过池化，可以有效地减少资源对象创建的次数，提高程序运行的性能。 庞杂的内存问题，如何理出自己的思路出来 一、 内存池简介 1.1 基本概念 由上图，我们可以了解内存池的大概思想在于： 如果不使用内存池，用户程序是直接向操作系统申请内存的 如果使用内存池，用户程序会先询问内存池能不能够分配所申请的内存大小，如果不能则会先向操作系统申请内存到内存池，再由内存池间接返回内存给用户程序 综上，内存池的实现主要是为了 避免 用户程序频繁的直接向操作系统申请内存而造成的 大量的系统
C++语法学习笔记六十五：内存池概念、代码实现和详细分析
哲学天空的博客
08-30 185
实例代码： #include <iostream> #include <vector> #include <ctime> using namespace std; namespace _nmsp1 //命名空间 { //一：内存池的概念和实现原理概述 //malloc：内存浪费，频繁分配小块内存，则浪费更加显得明显 //“内存池”，要解决什么问题？ //(1)减少malloc的次数，减少malloc()调用次数就意味着减少对内存的浪费 //(2)减少mall
U型池 c++
hao12345i的博客
01-08 991
3D打印是一种新兴的技术，它是一种以模型为基础，运用特殊材料，把一个东西真的“打印”出来的技术。运用3D打印机（一种特殊的打印机），就可以将计算机中的模型文件变成一个实体的东西，非常精准。该技术在珠宝、鞋类、工业设计、建筑、工程、汽车，航空航天、牙科和医疗产业、教育、地理信息系统、土木工程以及其他领域都有所应用。 自从小蜗蜗学了3D打印后，他就一直想自己做一个东西，他的想象力有限，想来想去，只想到了打印一个方方正正的U。但是他学艺不精，你能帮帮他吗？ 输入n,mn,m，表示一个n×nn×n的正方形格
【常见缓存算法原理及其C++实现】LRU篇（包含过期时间详解）
saxon_li的博客
04-05 8050
一、缓存算法简介 （一）缓存算法应用背景 缓存的应用场景和范围十分广泛，下面给出其十分常见的两种应用背景： 首先，在操作系统内部，由于内存资源十分有限，而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制，它将进程的一部分内容暂留在磁盘中，在需要时再进行数据交换将其放入内存，这个过程就需要用到缓存算法机制进行置换。 其次，对于各类应用项目开发而言，在巨大的数据量面前，Catch 是不可或缺的。因为无论是针对本地端的浏览器缓存，还...
简单的数据缓存程序C++
qq_34790664的博客
02-28 2429
C++对列缓存数据
C++内存池(附源码)
ConstCpp的博客
05-13 5226
C++内存池 （附源码）
c++内存池实现
热门推荐
neustar1的专栏
04-19 1万+
利用C/C++开发大型应用程序中，内存的管理与分配是一个需要认真考虑的部分。 本文描述了内存池设计原理并给出内存池的实现代码，代码支持Windows和Linux，多线程安全。 内存池设计过程中需要考虑好内存的分配与释放问题，其实也就是空间和时间的矛盾。 有的内存池设计得很巧妙，内存分配与需求相当，但是会浪费过多的时间去查找分配与释放，这就得不偿失； 实际使用中，我们更多的是关心内存分配的速
C++动态内存分配详解
动态内存分配主要涉及堆内存，这是C++的四个内存区域之一，其他三个分别是代码区、全局和静态变量区以及栈区。堆内存是程序运行时动态分配和管理内存的地方，由程序员手动控制其分配和释放。 C++提供了`new`和`...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值