固定大小的内存池

最新推荐文章于 2024-05-14 09:14:25 发布
最新推荐文章于 2024-05-14 09:14:25 发布
阅读量82 收藏
点赞数
文章标签： ui c/c++
原文链接：https://my.oschina.net/osbin/blog/349355
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

参考LOKI内存池实现。当定义了USE_NO_LOCK宏时，编译成无锁版本。

// defs.h
#ifndef _DEFS_H_
#define _DEFS_H_

typedef char int8 ;
typedef unsigned char uint8 ;
typedef uint8 byte ;
typedef short int16 ;
typedef unsigned short uint16 ;
typedef int int32 ;
typedef unsigned int uint32 ;

#ifdef _MSC_VER
	typedef __int64 int64 ;
	typedef unsigned __int64 uint64 ;
	#ifdef _WIN32
		typedef uint32 uaddr ;
	#else
		typedef uint64 uaddr ;
	#endif
	#define STDCALL	__stdcall
#else
	typedef long long int64 ;
	typedef unsigned long long uint64 ;
	#if __SIZEOF_POINTER__ == 4
		typedef uint32 uaddr ;
	#elif __SIZEOF_POINTER__ == 8
		typedef uint64 uaddr ;
	#endif
	#define STDCALL __attribute__((stdcall))
#endif

#ifdef USE_NO_LOCK
#define MEM_POOL_NO_LOCK
#define TASK_SCHEDULE_NO_LOCK
#define IO_BUFFER_NO_LOCK
#endif

#endif //_DEFS_H_

 

// atom.h 原子操作
#ifndef _ATOM_H_
#define _ATOM_H_

#include "defs.h"

#ifdef _MSC_VER
	#include <windows.h>
#elif defined(__GNUC__)
	#if __GNUC__<4 || (__GNUC__==4 && __GNUC_MINOR__<1)
		#error GCC version must be greater or equal than 4.1.2
	#endif
	//#include <sched.h>
#else
	#error Currently only windows and linux os are supported
#endif

//自增,返回新值
inline uint32 AtomSelfAdd(void *var)
{
#ifdef _MSC_VER
  return InterlockedIncrement((long *)var); // NOLINT
#else
  return __sync_add_and_fetch((uint32 *)var, 1); // NOLINT
#endif
}

//自减,返回新值
inline uint32 AtomSelfDec(void *var) 
{
#ifdef _MSC_VER
  return InterlockedDecrement((long *)var); // NOLINT
#else
  return __sync_add_and_fetch((uint32 *)var, -1); // NOLINT
#endif
}

//加一个值,返回旧值
inline uint32 AtomAdd(void *var, const uint32 value) 
{
#ifdef _MSC_VER
  return InterlockedExchangeAdd((long *)var, value); // NOLINT
#else
  return __sync_fetch_and_add((uint32 *)var, value);  // NOLINT
#endif
}

//减一个值,返回旧值
inline uint32 AtomDec(void *var, int32 value) 
{
	value = value * -1;
#ifdef _MSC_VER
	return InterlockedExchangeAdd((long *)var, value); // NOLINT
#else
	return __sync_fetch_and_add((uint32 *)var, value);  // NOLINT
#endif
}

//赋值,windows下返回新值，linux下返回旧值
inline uint32 AtomSet(void *var, const uint32 value) 
{
#ifdef _MSC_VER
	::InterlockedExchange((long *)var, (long)value); // NOLINT
#else
	__sync_lock_test_and_set((uint32 *)var, value);  // NOLINT
#endif
	return value;
}

//取值
inline uint32 AtomGet(void *var) 
{
#ifdef _MSC_VER
  return InterlockedExchangeAdd((long *)var, 0); // NOLINT
#else
  return __sync_fetch_and_add((uint32 *)var, 0);  // NOLINT
#endif
}

//cas 返回旧值
inline uint32 AtomCmpAndSet(void *var, uint32 uiCmp, uint32 uiSet)
{
#ifdef _MSC_VER
	return InterlockedCompareExchange((long *)var, (long)uiSet, (long)uiCmp) ;
#else
	return __sync_val_compare_and_swap((uint32 *)var, uiCmp, uiSet) ;
#endif
}

//cas 返回旧值
inline void* AtomCmpAndSetPointer(void **pOri, void *pCmp, void *pSet)
{
#ifdef _MSC_VER
	return InterlockedCompareExchangePointer(pOri, pSet, pCmp) ;
#else
	return __sync_val_compare_and_swap(pOri, pCmp, pSet) ;
#endif
}

//cas 返回bool值
inline bool AtomBoolCmpAndSet(void *var, uint32 uiCmp, uint32 uiSet)
{
#ifdef _MSC_VER
	return InterlockedCompareExchange((long *)var, (long)uiSet, (long)uiCmp) == (long)uiCmp ;
#else
	return __sync_bool_compare_and_swap((uint32 *)var, uiCmp, uiSet) ;
#endif
}

//cas 返回bool值
inline bool AtomBoolCmpAndSetPointer(void **pOri, void *pCmp, void *pSet)
{
#ifdef _MSC_VER
	return InterlockedCompareExchangePointer(pOri, pSet, pCmp) == pCmp ;
#else
	return __sync_bool_compare_and_swap(pOri, pCmp, pSet) ;
#endif
}

#endif //_ATOM_H_

 

// Sync.h
#ifndef _MDL_SYNC_H_
#define _MDL_SYNC_H_

#include "defs.h"
#include "atom.h"

#define _SYNC_NO_LOCK_ //使用无锁

#ifdef _SYNC_NO_LOCK_

	typedef volatile uint32 SYNCOBJ;

	#ifdef _WIN_VER_

		#include <Windows.h>
		#if(_WIN32_WINNT >= 0x0400)
			#define Sync_Yield() SwitchToThread()
		#else
			#define Sync_Yield() Sleep(0)
		#endif

	#else

		#include <sched.h>
		#define Sync_Yield() sched_yield()

	#endif

	#define Sync_Init(pObj) *(pObj) = 0
	#define Sync_Destroy(pObj) *(pObj) = 0
	#define Sync_Lock(pObj) while(0 != *(pObj) || 1 != AtomSelfAdd((void *)(pObj))){Sync_Yield();}
	#define Sync_Unlock(pObj) AtomSet((void *)(pObj), 0)

#else

	#ifdef _WIN_VER_
		#include <Windows.h>
		typedef CRITICAL_SECTION SYNCOBJ;

		#define Sync_Init(pObj) InitializeCriticalSection(pObj)
		#define Sync_Destroy(pObj) DeleteCriticalSection(pObj)
		#define Sync_Lock(pObj) EnterCriticalSection(pObj)
		#define Sync_Unlock(pObj) LeaveCriticalSection(pObj)
	#else
		#include <pthread.h>
		typedef pthread_mutex_t SYNCOBJ;

		#define Sync_Init(pObj) pthread_mutex_init(pObj, NULL)
		#define Sync_Destroy(pObj) pthread_mutex_destroy(pObj)
		#define Sync_Lock(pObj) pthread_mutex_lock(pObj)
		#define Sync_Unlock(pObj) pthread_mutex_unlock(pObj)
	#endif

#endif

namespace mdl
{

class Sync
{
public:
	Sync()
	{
		Sync_Init(&m_syncObj);
	}

	~Sync()
	{
		Sync_Destroy(&m_syncObj);
	}

	void Lock()
	{
		Sync_Lock(&m_syncObj);
	}

	void Unlock()
	{
		Sync_Unlock(&m_syncObj);
	}

private:
	Sync(const Sync &);
	Sync& operator=(const Sync &);

private:
	SYNCOBJ m_syncObj;
};

class AutoSync
{
public:
	AutoSync(Sync *pSync) : m_pSync(pSync), m_bLocked(true)
	{
		m_pSync->Lock();
	}

	~AutoSync()
	{
		Unlock();
	}

	void Unlock()
	{
		if(m_bLocked)
		{
			m_pSync->Unlock();
			m_bLocked = false;
		}
	}

private:
	AutoSync(const AutoSync &);
	AutoSync& operator=(const AutoSync &);

private:
	Sync *m_pSync;
	bool m_bLocked;
};

} // namespace mdl

#endif //_MDL_SYNC_H_

 

// MemPool.h
#ifndef _MDL_MEM_POOL_H_
#define _MDL_MEM_POOL_H_

#include "defs.h"
#include "atom.h"
#include "Sync.h"

namespace mdl
{

class MemBlock
{
public:
	MemBlock();
	~MemBlock();
	byte *Allocator(uint32 uiSize, uint32 uiCount);

private:
	byte *AllocBuf(uint32 uiSize, uint32 uiCount);
	MemBlock *m_pNextBlock;
	byte *m_pBuf;	//预先申请的内存块
};

class MemPool
{
public:
	MemPool(uint32 uiSize, uint32 uiCount = 512);
	virtual ~MemPool();
	void *Alloc();
	void Free(void *pMem);
	uint32 GetPerMemSize() { return m_uiSize; }
	uint32 GetPerBlockCount() { return m_uiCount; }
	uint32 GetUsedCount() { return m_uiUsed; }
	uint32 GetFreeCount() { return m_uiFree; }

protected:
	MemBlock m_memBlock;
	byte *m_pNextFreeMem;		//下一个可分配的内存地址
	uint32 m_uiSize;			//分配出去的每个内存大小
	uint32 m_uiCount;			//数量。m_pBufList[i]指向内存块(大小：m_uiSize * m_uiCount)
	volatile uint32 m_uiUsed;	//使用数
	volatile uint32 m_uiFree;	//空闲数
	Sync m_lock;				//

private:
	byte *AllocBlock(uint32 uiSize, uint32 uiCount);
	MemPool(const MemPool &);
	MemPool& operator=(const MemPool &);
};

} // namespace mdl

#endif //_MDL_MEM_POOL_H_

 

// MemPool.cpp
#include <stddef.h>
#include <new>
#include "MemPool.h"

namespace mdl
{

MemBlock::MemBlock() : m_pNextBlock(NULL), m_pBuf(NULL)
{
}

MemBlock::~MemBlock()
{
	if(NULL != m_pBuf)
		delete [] m_pBuf;
	if(NULL != m_pNextBlock)
		delete m_pNextBlock;
}

byte* MemBlock::Allocator(uint32 uiSize, uint32 uiCount)
{
	MemBlock *p = new (std::nothrow) MemBlock;
	if(NULL != p && NULL != p->AllocBuf(uiSize, uiCount))
	{
		p->m_pNextBlock = m_pNextBlock;
		m_pNextBlock = p;
		return p->m_pBuf;
	}
	else
	{
		if(NULL != p)
			delete p;
		return NULL;
	}
}

byte* MemBlock::AllocBuf(uint32 uiSize, uint32 uiCount)
{
	uint32 ui;
	m_pBuf = new (std::nothrow) byte[uiSize * uiCount];
	//m_pNextBlock = NULL;
	if(NULL != m_pBuf)
	{
		for(ui=0; ui<uiCount-1; ui++)
			*(uaddr *)((uaddr)m_pBuf + uiSize * ui) = (uaddr)m_pBuf + uiSize * (ui + 1);
		*(uaddr *)((uaddr)m_pBuf + uiSize * ui) = 0;
	}
	return m_pBuf;
}

//
MemPool::MemPool(uint32 uiSize, uint32 uiCount /* = 512 */)
{
	m_uiSize = (uiSize + sizeof(void *)-1) & ~(sizeof(void *) - 1);
	if(m_uiSize < sizeof(void *))
		m_uiSize = sizeof(void *);
	m_uiCount = uiCount;
	m_uiUsed = 0;
	m_uiFree = uiCount;
	m_pNextFreeMem = NULL;
}

MemPool::~MemPool()
{
	//
}

void* MemPool::Alloc()
{
	byte *p = NULL;

	m_lock.Lock();
	if(m_pNextFreeMem != NULL || (m_pNextFreeMem = AllocBlock(m_uiSize, m_uiCount)) != NULL)
	{
		p = m_pNextFreeMem;
		m_pNextFreeMem = (byte *)*(uaddr *)p;
		m_uiFree--;
		m_uiUsed++;
	}
	m_lock.Unlock();
	return p;
}

void MemPool::Free(void *pMem)
{
	if(NULL != pMem)
	{
		m_lock.Lock();
		*(uaddr *)pMem = (uaddr)m_pNextFreeMem;
		m_pNextFreeMem = (byte *)pMem;
		m_uiFree++;
		m_uiUsed--;
		m_lock.Unlock();
	}
}

byte* MemPool::AllocBlock(uint32 uiSize, uint32 uiCount)
{
	byte *p = m_memBlock.Allocator(m_uiSize, uiCount);
	if(p != NULL)
		m_uiFree += m_uiCount;
	return p;
}

} // namespace mdl

 

转载于:https://my.oschina.net/osbin/blog/349355

weixin_34088598
关注
性能优化-内存池的设计和实现
Jack, what else can you do besides holding your little darling?
12-08 476
性能优化-内存池的设计和实现
袖珍版固定大小 内存池1(c语言)
xeqxerxe的专栏
08-13 709
1支持内存的快速申请和释放 一共约100行代码2 支持任意大小的固定块 一共约100行代码3支持多线程 设计完成,还没时间做4支持内存整理这是预计的,现在的1也可以用,能满足我的使用要求,有时间再做的更好些吧因为代码没带全,明天再发这几天忘记了,补上typedef struct BlockList { struct BlockList *NextBlock; //下一个块 struct Blo
简单实现一个固定大小的内存池
qq_29503203的博客
12-07 1087
1.内存池的引入       (1)内存池顾名思义就是存放内存的池子，直接分配一大块内存存起来，然后慢慢地切出来使用，用完了再还回到池子，后续还能再利用。      (2)如果我们需要申请一块空间，我们一般都会动态开辟一块空间(new或malloc),它们两个的共同点就是在堆上去申请空间，当然也是有一定限制的。如果我们频繁的去申请释放空间，就会造成许多的内存碎片，内存的浪费也就产生了。如果
固定大小对象的内存池
weixin_30332705的博客
09-23 87
#include <boost/progress.hpp> template<class T> class MemoryPool { public: MemoryPool(size_t size =EXPANSION_SIZE); ~MemoryPool(); //从空闲列表中分配T元素 inline void *...
linux C固定大小内存池
03-22
linux C固定大小内存池实现，支持多线程。
C++实现固定大小内存池，支持多线程之间传递，防止运行时分配内存花费时间，优化性能
weixin_42210846的博客
05-12 355
FixSizeMemoryPool.h #pragma once #include "BlockingQueue.h" //https://blog.csdn.net/weixin_42210846/article/details/124712457?spm=1001.2014.3001.5502 class CFixSizeMemoryPool { public: CFixSizeMemoryPool(int num, int size); ~CFixSizeMemoryPool(); std:
任意大小 内存池 c语言,C语言－固定大小内存池
weixin_31749595的博客
05-17 190
//// memorypool.c//// Created by peeno on 16/11/7.// Copyright © 2016年 auto. All rights reserved.//#include #include #include "memorypool.h"#define ALIGN4(align) (((align) + 3) & (~3))// memory bl...
visual c++ vc内存池源代码,用于分配固定大小的内存,速度超快又方便.zip
01-17
总的来说，这个资源对于想要提升C++程序性能，特别是需要频繁分配和释放固定大小内存的开发者来说，是一个宝贵的参考资料。通过研究和实践，开发者可以掌握如何创建自己的内存池，从而实现更高效、更稳定的内存管理...
易语言内存池申请
07-20
内存池是一种预先分配一大块连续内存空间，并将其分割成多个固定大小的小块内存块，供程序动态分配使用的策略。相比传统的内存分配方式（如C++中的`new`和`delete`，或C语言中的`malloc`和`free`），内存池能提高...
pool:用 C 实现的内存池。允许快速分配固定大小的对象
07-09
水池 用 C 实现的内存池。允许快速分配固定大小的对象。 该项目目前尚未完成，不应使用。
【高并发内存池】第一篇：定长内存池设计
m0_51064412的博客
04-06 1165
文章目录一. 什么是内存池？1. 池化技术2. 内存池概念二. 为什么要有内存池？1. 内存碎片问题2. 内存池带来的好处三. 定长内存池设计1. 定长内存池特点2. 定长内存池基本思想3. 定长内存池实现2.1 基本框架 一. 什么是内存池？ 1. 池化技术 内存池是池化技术的一种应用。所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次申请该资源都有较大的开销，不如提前申请好了，这样使用时就会变得非常快捷，大大提高程序运行效率。 生活中的池化
c++在一个地址连续固定大小的内存池中，如何给大块内存和小块内存分配。并解决大块内存释放利用问题
weixin_39291964的博客
03-06 320
在C++中管理一个地址连续、固定大小的内存池，并需要在其中同时分配大块内存和小块内存，是一个挑战。内存池初始化：在内存池初始化时，将整个内存池分割成固定大小的最小单元块。在实际应用中，你需要在deallocate函数中检查释放的块是否与现有的空闲块相邻，并相应地合并它们，以形成更大的空闲块。根据具体的应用需求，你可能需要调整空闲块列表的管理方式、内存分配策略，以及合并逻辑。内存释放：释放内存时，根据释放的块大小将其归还到相应的列表，并检查是否可以合并相邻的空闲块，以减少内存碎片。
单线程不固定大小对象的内存池实现
Always On The Way
01-08 1178
内存块类头文件： //MemoryChunk.h class MemoryChunk { public: MemoryChunk(MemoryChunk* nextChunk,size_t chunkSize); ~MemoryChunk() {delete[] mem;} void * alloc(size_t size); void free(void* someElement)
2024年性能优化-高效内存池的设计与实现_内存池的设计和实现(1)，HarmonyOS鸿蒙高级面试题库
最新发布
2401_84862359的博客
05-14 440
其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函数进行申请；在释放的时候，也是将被释放内存先方式内存池中，内存池根据一定的策略，来决定是否进行shrink以归还OS。那么，现一个内存池？我们该怎么实现呢？今天，借助这篇文章，我们一起来设计和实现一个内存池(文末附有github地址)。
【23秋招c++后端面试技术突围】 分析高效内存池的实现方式
m0_58687318的博客
10-08 545
群内提供免费的C/C++Linux服务器开发/高级架构师学习资料资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，，只有当内存池不够大需要动态扩增的时候才会调用系统的分配内存函数，其他时间对内存的一切操作都是用应用程序控制的。(在这里的固定指的是每一次和系统申请的内存的大小都是固定的，而不是这个内存池大小只能那么大)和。后面随着内存池的不断扩大，我们通过。
性能优化-高效内存池的设计与实现
高性能架构探索
12-07 2591
原文地址： 高效内存池的设计与实现 关注公众号【高性能架构探索】，也可以后台回复【pdf】，获取计算机必备经典书籍 大家好，我是雨乐！ 在之前的文章中，我们分析了glibc内存管理相关的内容，里面的是不是逻辑复杂????，毕竟咱们用几十行代码完成的功能，glibc要用上百乃至上千行代码来实现，毕竟它的受众太多了，需要考虑跨平台，各种边界条件等。 其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函
服务器设计系列：内存管理
Jack Zhou的专栏
11-09 4306
服务器设计人员在一段时间的摸索后，都会发现：服务器性能的关键在于内存。从收包到解析，到消息内存的申请，到session结构内存的申请都要小心处理，尽量减少内存数据copy，减少内存动态申请，减少内存检索。为达到这个目的，不同的地方有不同的方法，比如常见的包解析，使用缓冲区偏移以及长度来标识包内字段信息；内存使用量固定的系统，系统启动就申请好所有需要的内存，初始化好，等待使用的时候直接使用；基于li
一个分配固定大小块的内存池（memory pool） 的例子 FROM POCO
06-23 241
// // MemoryPool.h // // $Id: //poco/1.4/Foundation/include/Poco/MemoryPool.h#1 $ // // Library: Foundation // Package: Core // Module:MemoryPool // // Definition o...
内存池——实现一个简单的固定大小的内存池
宇哲
12-04 4211
最近在STL当中看到了第二级内存分配器，这里有个内存池的内容，在这在知乎上看到了内存池的相关内容，所以萌生了一个想自己写一个简单的内存池的想法。这种简单的内存池，援引自知乎的： 实现固定内存分配器： 即实现一个 FreeList，每个 FreeList 用于分配固定大小的内存块，比如用于分配 32字节对象的固定内存分配器，之类的。每个固定内存分配器里面有两个链表，OpenList 用于存储
高效无环固定内存池：游戏开发者的理想选择
本文档深入探讨了一种高效、无循环且低开销的固定大小内存池管理器——FastEfficientFixed-SizeMemoryPool。作者Ben Kenwright来自英国纽卡斯尔大学计算机科学学院，特别强调了这个内存池在对实时性要求极高的系统，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值