简单变长内存池实现的实现

最新推荐文章于 2023-07-08 20:24:47 发布
最新推荐文章于 2023-07-08 20:24:47 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 搜索引擎技术 文章标签： alignment delete null struct class qq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/preja2erec/article/details/2903282
版权

实现了变长内存池的申请和回收，其中回收包括在某种特定的情况下回收给系统

 

h文件：GenMemPool.h

#ifndef _SKIFFER_GENMEMPOOL_H
#define _SKIFFER_GENMEMPOOL_H

#include <stdlib.h>

//按此值向上取整申请所需内存大小，例如，如果申请内存为13字节，则返回14字节的内存
#define MEMPOOL_ALIGNMENT (2)
#define MAX_MEN_LIMIT (1<<16)
#pragma pack(1)
struct STMemBlk
{
//此内存块中内存单元的个数
unsigned short m_wAllUnitNum;
//空闲单元的个数
unsigned short m_wFreeUnitNum;
//第一个空闲单元的单元编号
unsigned short m_wFirstFreeUnitNo;
//next 指针
STMemBlk *m_pNextBlk;
//以上为内存块结构头部信息

//以下为外界可用内存
char m_pData[0];

STMemBlk()
{
   m_wAllUnitNum = 0;
   m_wFreeUnitNum = 0;
   m_wFirstFreeUnitNo = 0;
   m_pNextBlk = NULL;
}
~STMemBlk()
{
}

void* operator new(size_t wBlkSize, unsigned short wUnitNum, unsigned short wUnitSize)
{
   return ::operator new (sizeof(STMemBlk) + wUnitNum * wUnitSize);
}

void operator delete(void *p)
{
   ::operator delete (p);
}

void operator delete(void *p, unsigned short wUnitNum, unsigned short wUnitSize)
{
   ::operator delete (p);
}
};

struct STInitParam
{
//每个内存单元的大小
unsigned short m_wUnitSize;
//第一次初始化时，每一块内存中，需要申请的内存单元个数
unsigned short m_wInitUnitNum;
//内存不足时，每一块内存中，需要申请的内存单元个数
unsigned short m_wGrowUnitNum;
STInitParam()
{
   m_wUnitSize = 0;
   m_wInitUnitNum = 0;
   m_wGrowUnitNum = 0;
}
};
#pragma pack()


class CMemPool
{

public:
CMemPool();
~CMemPool();

//初始化
void Init(unsigned short wUnitSize, unsigned short wInitUnitNum, unsigned short wGrowUnitNum);
//分配内存块中的一个内存单元
void* Alloc();
//释放一个内存单元
void Free(void *pUnit);
//预处理块
void* PreAlloc(STMemBlk *pstMemBlk, int dwBlkFlag);

private:
//内存池头结点
STMemBlk *m_pstMemBlkHead;
//内存池块信息
STInitParam m_stInitBlkInfo;
};

class CVarLenMemPool
{
public:
CVarLenMemPool();
~CVarLenMemPool();

//申请dwMemSize字节的内存
void* Alloc(unsigned int dwMemSize);
//释放内存
void Free(void *p);
//初始化n个内存单元长度不同的固定内存池
void Init(const STInitParam *pstInitParam, unsigned short wMemPoolNum);
//退出
void Exit();
//向上对齐
void UpAlignment(STInitParam *pstInitParam, unsigned short wMemPoolNum);

public:
//内存单元大小不同的内存池
CMemPool **m_ppMemPoolList;
//n个内存单元长度不同的固定内存池
STInitParam *m_pstInitParam;
//内存池个数
unsigned short m_wMemPoolNum;
//最大的内存单元大小
unsigned short m_wMaxUnitSize;
};

#endif


.cpp文件:GenMemPool.cpp

#include "GenMemPool.h"
#include <string.h>

CMemPool::CMemPool()
{
m_pstMemBlkHead = NULL;
memset(&m_stInitBlkInfo, 0 , sizeof(m_stInitBlkInfo));
}

CMemPool::~CMemPool()
{
}

void CMemPool::Init(unsigned short wUnitSize, unsigned short wInitUnitNum, unsigned short wGrowUnitNum)
{
if(wUnitSize <= 4)
{
   wUnitSize = 4;
}
else
{
   wUnitSize = (wUnitSize + (MEMPOOL_ALIGNMENT - 1)) & ~(MEMPOOL_ALIGNMENT - 1);
}
m_stInitBlkInfo.m_wUnitSize = wUnitSize;
m_stInitBlkInfo.m_wInitUnitNum = wInitUnitNum;
m_stInitBlkInfo.m_wGrowUnitNum = wGrowUnitNum;
}

void* CMemPool::PreAlloc(STMemBlk *pstMemBlk, int dwBlkFlag)
{
char *pData = NULL;
unsigned short dwUnitNum = 0;
pData = pstMemBlk->m_pData;

if(dwBlkFlag == 1)
{
   dwUnitNum = m_stInitBlkInfo.m_wInitUnitNum;
}
else
{
   dwUnitNum = m_stInitBlkInfo.m_wGrowUnitNum;
}

pstMemBlk->m_wFreeUnitNum = dwUnitNum - 1;
pstMemBlk->m_wAllUnitNum = dwUnitNum;
pstMemBlk->m_wFirstFreeUnitNo = 1;

for(unsigned short dwUnit = 1; dwUnit < dwUnitNum - 1; ++dwUnit)
{  
   pData = pstMemBlk->m_pData + dwUnit * m_stInitBlkInfo.m_wUnitSize;
   *(unsigned short*)pData = dwUnit + 1;
}
pData = pstMemBlk->m_pData;
return pData;
}

void* CMemPool::Alloc()
{
void *pData = NULL;
STMemBlk *pstMemBlk = NULL;

if(m_pstMemBlkHead == NULL)
{
   m_pstMemBlkHead = ::new STMemBlk;
   m_pstMemBlkHead->m_pNextBlk = new(m_stInitBlkInfo.m_wInitUnitNum, m_stInitBlkInfo.m_wUnitSize)STMemBlk;
   pData = PreAlloc(m_pstMemBlkHead->m_pNextBlk, 1);
}
else
{
   pstMemBlk = m_pstMemBlkHead->m_pNextBlk;
   while(pstMemBlk != NULL)
   {
    if(pstMemBlk->m_wFreeUnitNum == 0)
    {
     pstMemBlk = pstMemBlk->m_pNextBlk;
     continue;
    }
    else
    {
     break;
    }
   }
   if(NULL == pstMemBlk)
   {
    pstMemBlk = new(m_stInitBlkInfo.m_wGrowUnitNum, m_stInitBlkInfo.m_wUnitSize)STMemBlk;
    pData = PreAlloc(pstMemBlk, 2);
    pstMemBlk->m_pNextBlk = m_pstMemBlkHead->m_pNextBlk;
    m_pstMemBlkHead->m_pNextBlk = pstMemBlk;
   }
   else
   {
    pData = (void*)(pstMemBlk->m_pData + pstMemBlk->m_wFirstFreeUnitNo * m_stInitBlkInfo.m_wUnitSize);
    --(pstMemBlk->m_wFreeUnitNum);
    pstMemBlk->m_wFirstFreeUnitNo = *(unsigned short*)pData;
   }
}
return pData;
}

void CMemPool::Free(void *pUnit)
{
STMemBlk *pstMemBlk = NULL;
STMemBlk *pstMemBlkPre = NULL;
unsigned short dwBlkNo = 0;
pstMemBlkPre = m_pstMemBlkHead;
pstMemBlk = m_pstMemBlkHead->m_pNextBlk;

while(pstMemBlk != NULL)
{
   if(((unsigned int)pUnit) > (unsigned int)pstMemBlk &&
    (unsigned int)pUnit <
    (unsigned int)(pstMemBlk->m_pData + (pstMemBlk->m_wAllUnitNum + 1) * m_stInitBlkInfo.m_wUnitSize))
   {
    dwBlkNo = ((unsigned int)pUnit - (unsigned int)(pstMemBlk->m_pData))/m_stInitBlkInfo.m_wUnitSize;
    break;
   }
   else
   {
    pstMemBlkPre = pstMemBlk;
    pstMemBlk = pstMemBlk->m_pNextBlk;
   }
}

if(pstMemBlk->m_wFreeUnitNum - 1 == pstMemBlk->m_wAllUnitNum)
{
   pstMemBlkPre->m_pNextBlk = pstMemBlk->m_pNextBlk;
   delete(pstMemBlk);
}
else
{
   *(unsigned short*)pUnit = pstMemBlk->m_wFirstFreeUnitNo;
   pstMemBlk->m_wFirstFreeUnitNo = dwBlkNo;
   ++(pstMemBlk->m_wFreeUnitNum);
}
}


CVarLenMemPool::CVarLenMemPool()
{
m_ppMemPoolList = NULL;
m_pstInitParam = NULL;
m_wMemPoolNum = 0;
m_wMaxUnitSize = 0;
}

CVarLenMemPool::~CVarLenMemPool()
{
}

void CVarLenMemPool::Init(const STInitParam *pstInitParam, unsigned short wMemPoolNum)
{
unsigned short wInitIdxBegin = 0;
unsigned short wInitIdxEnd = 0;
m_wMemPoolNum = wMemPoolNum;
m_pstInitParam = new STInitParam[m_wMemPoolNum];
memcpy(m_pstInitParam, pstInitParam, sizeof(*pstInitParam) * wMemPoolNum);
UpAlignment(m_pstInitParam, wMemPoolNum);

m_wMaxUnitSize = 0;
unsigned short i = 0;

for(i = 0; i < m_wMemPoolNum; ++i)
{
   if(m_pstInitParam[i].m_wUnitSize > m_wMaxUnitSize)
   {
    m_wMaxUnitSize = m_pstInitParam[i].m_wUnitSize;
   }
}

m_ppMemPoolList = new CMemPool*[m_wMaxUnitSize+1];

for(i = 0; i < m_wMemPoolNum; ++i)
{
   CMemPool *pMemPool = new CMemPool;
   pMemPool->Init(m_pstInitParam[i].m_wUnitSize, m_pstInitParam[i].m_wInitUnitNum,
       m_pstInitParam[i].m_wGrowUnitNum);
   wInitIdxEnd = m_pstInitParam[i].m_wUnitSize;

   for(unsigned short j = wInitIdxBegin; j <= wInitIdxEnd; ++j)
   {
    m_ppMemPoolList[j] = pMemPool;
   }
   wInitIdxBegin = wInitIdxEnd + 1;
}
}

void* CVarLenMemPool::Alloc(unsigned int dwMemSize)
{
void *p = NULL;
if(dwMemSize+2 > m_wMaxUnitSize)
{
   p = ::operator new(dwMemSize+2);
   *(unsigned short*)p = 0;
}
else
{
   p = m_ppMemPoolList[dwMemSize+2]->Alloc();
   *(unsigned short*)p = dwMemSize+2;
}
return ((unsigned short*)p+1);
}

void CVarLenMemPool::Free(void *p)
{
unsigned short *pTmp = ((unsigned short*)p)-1;
unsigned short dwSize = *pTmp;
if(0 == dwSize)
{
   ::operator delete(pTmp);
}
else
{
   m_ppMemPoolList[dwSize]->Free(p);
}
}

void CVarLenMemPool::UpAlignment(STInitParam *pstInitParam, unsigned short wMemPoolNum)
{
for(unsigned short wParam; wParam < wMemPoolNum; ++wParam)
{
   if(pstInitParam[wParam].m_wUnitSize <= 4)
   {
    pstInitParam[wParam].m_wUnitSize = 4;
   }
   else
   {
    pstInitParam[wParam].m_wUnitSize = (pstInitParam[wParam].m_wUnitSize + (MEMPOOL_ALIGNMENT - 1)) &
             ~(MEMPOOL_ALIGNMENT - 1);     
   }
}
}


void CVarLenMemPool::Exit()
{

}

参考论文：http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html

 

email:winxu81@gmail.com
msn:wx_bird@msn.com
qq:44203734

preja2erec
关注
专栏目录
一个简单的变长内存池
心之所向，身之所往
06-02 1777
#define NODE_SIZE (200) //每个node的大小 #define BASE_NODE_NUM (1024 * 1) //初始分配大小 #define STEP_NODE_NUM (1024 * 1) //每次递增大小 #include #pragma pack(1) typedef struct _mem_node {
C++ 实现高性能内存池项目实现
yx5666的博客
10-24 647
本节我们实现了一个用于测试性能比较的模板链表栈，目前的代码如下。在下一节中，我们开始详细实现我们的高性能内存池。{T data;};// T 为存储的对象类型, Alloc 为使用的分配器,// 并默认使用 std::allocator 作为对象的分配器{public:// 使用 typedef 简化类型名// 默认构造}// 默认析构}// 当栈中元素为空时返回 true}// 释放栈中元素的所有内存= 0){curr = tmp;}head_ = 0。
自适应变长内存池
10-29
一个简单的适应变长内存池的实现， 主要用于大量IP数据包的存储.
变长内存池的设计概要
qman007的专栏
01-13 291
变长内存池，听起来感觉很是高大上，其实也是很简单的一种定长内存池的多维度管理。 我设计开发的变长内存池就是完全基于这种思想： 1.首先定义最小分配长度=32，为了兼容ARM CPU，一定要确保分配的内存地址是4的整数倍。 2.以32的倍数作为长度维度，意思是说当前申请的内存长度可以通过计算定位到合适的长度维度 ，例如：一次申请78个字节长度，则78/32=2(倍数)，78%32=14(余数)，定位...
一种自适应变长块内存池
08-12
一种自适应变长块内存池一种自适应变长块内存池一种自适应变长块内存池一种自适应变长块内存池
内存池版本4--多线程-可变大小对象的内存池
weixin_34085658的博客
01-08 140
#include "stdafx.h"#include &lt;windows.h&gt;#include &lt;MMSystem.h&gt;#include &lt;iostream&gt;using namespace std;#pragma comment(lib, "winmm.lib")class Foo{public: Foo(int a = 0, int b = 0):m...
一个简单内存池的实现
11-03
注意咯。应该在基类加上 ~_T()不然将无法析构对象。 这个类工作正常。
【项目】C++实现高并发内存池
最新发布
qq_66314292的博客
07-08 1426
C++实现高并发内存池
性能优化-内存池的设计和实现，看这篇文章就够了
lt_xiaodou的博客
09-27 1015
在之前的文章中，我们分析了glibc内存管理相关的内容，里面的是不是逻辑复杂，毕竟咱们用几十行代码完成的功能，glibc要用上百乃至上千行代码来实现，毕竟它的受众太多了，需要考虑跨平台，各种边界条件等。其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函数进行申请；在释放的时候，也是将被释放内存先方式内存池中，内存池根据一定的策略，来决定是否进行shrink以归还OS。那么，发现一个内存池？
C++多平台线程池与内存池实现及编码封装类分享
本资源包为开发者提供了一套完整的线程池和内存池实现代码，以及多种编码转换的封装类代码。它们能够帮助开发者在Linux和Windows平台下高效地开发多线程程序，并处理各种编码转换问题。对于需要进行性能优化、提升...
不定长内存池之apr_pool
weixin_34015860的博客
09-23 216
内存池可有效降低动态申请内存的次数，减少与内核态的交互，提升系统性能，减少内存碎片，增加内存空间使用率，避免内存泄漏的可能性，这么多的优点，没有理由不在系统中使用该技术。 内存池分类： 1、              不定长内存池。典型的实现有apr_pool、obstack。优点是不需要为不同的数据类型创建不同的内存池，缺点是造成分配出的内存不能回收到池中。这是由于这种方案以session为...
(3)单线程内存池--可变大小的内存管理器
cai0612123的专栏
02-25 709
#include #include using std::cout; using std::endl;                          可变大小的内存空间列表 class MemoryChunk { public:         MemoryChunk(MemoryChunk *nextChunk, size_t chunkSize);      
内存池版本3--单线程-可变大小对象的内存池
weixin_33881041的博客
01-08 136
#include "stdafx.h"#include &lt;windows.h&gt;#include &lt;MMSystem.h&gt;#include &lt;iostream&gt;using namespace std;#pragma comment(lib, "winmm.lib")class Foo{public: Foo(int a = 0, int b = 0):m...
单线程环境中对象大小可变的内存池
Augusdi的专栏
07-18 2056
很多系统中申请的内存大小都不是固定的，而是变化的，比如一个http服务器。http服务器获得的请求不同，不同的请求需要不同大小的内存块。那么如何构造一个可以申请不同大小内存的内存池了。其实，构造方法类似vs2008下面的debug模式中的全局new和delete的实现。思路大致是申请很多不同大小的内存块，链接起来，根据需求从内存块链的头部申请指定大小内存。  注意，本文代码中的内存池只在内存块链的
变长内存管理方案
木子皿--啥都不会的菜鸟
05-16 287
文章目录1 变长内存管理方案 1 变长内存管理方案 使用接口： 管理方案： 总结： 应用实例： /** * @brief tOS应用示例 * @details * @author 01课堂 李述铜 http://01ketang.cc * @date 2017-06-01 * @version 1.0 * @copyright 版权所有，禁止用于商业用途 */ #include "tinyOS.h" #include "app.h" #include "hal.h" #include
简单内存池的实现
zdy0_2004的专栏
01-25 636
简单内存池的实现 在实际项目中，很多地方都存在IO。 而IO是很耗时间的，比方说：new、malloc。 对于现代的计算机来说，动辄就是GHz量级的主频，似乎感觉不到影响。但是在大型的项目里面，反复的new和delete，不仅会耗大量的时间，还会造成内存碎片。   new是一个很麻烦的东西。 有new的地方，就是你可能栽坑的地方。 new出的内存，没有
【uTenux实验】内存池管理（固定内存池和可变内存池）
weixin_34061042的博客
07-03 210
1、固定内存池管理实验       内存管理是操作系统的一个基础功能。uTenux的内存池管理函数提供了基于软件的内存池管理和内存块分配管理。uTenux的内存池有固定大小的内存池和大小可变的内存池之分，它们被看成是互相独立的对象，需要不同的系统调用集来进行操作。 内存池管理函数管理的内存全部包含在系统空间以内。 1、固定尺寸内存池实验     固定尺寸内存池是一个用来动态管理固定尺寸内存...
变长字符串的内存管理
托雷斯基的专栏
04-10 843
方法1：静态内存 这里有一个方法来实现帮助函数： const char * get_string() {         static char buf[10000]; /* Big enough */         /* Read string inot buf... */         return buf; } 复制代码
不定长内存池算法
04-08
c++实现的不定长内存池算法，效率较高，能较好重载new delete时使用，以及配合其他开源库需要的内存分配算法使用。
内存池管理函数,非常好用,自己已经在项目中使用
10-23
支持可变大小内存的申请,NUCLUES内存池函数的实现.自己已经使用了,很好用的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值