一种内存管理器的实现方法

最新推荐文章于 2024-10-09 21:29:39 发布
最新推荐文章于 2024-10-09 21:29:39 发布
阅读量374 收藏
点赞数
分类专栏： 项目开发经验 project study 文章标签： c++ 内存回收器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suifeng0204/article/details/50316797
版权

在软件设计和开发过程中，合理高效的使用内存，关乎软件执行的效率和性能，内存管理至关重要，下面一种方法可以对分配的内存进行回收再利用，提高内存使用率，c++代码如下：

memmgr.h

#ifndef __MEMMGR_H
#define __MEMMGR_H


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include "commondatastruct.h"


using namespace std;


//define data type
enum  MemoryType {B64_B,HALF_K,ONE_K,THREE_K,NO_MEM };
const int  BaseBlkNum=1; //must be 1   for add free policy to OS when occupy to much .SRC is 20


const size_t  B64 = 64;
const size_t  HalfK = 1024;
const size_t  OneK = 2048; //1024+ 512 = 1536
const size_t  ThreeK = 3072; //1024*3


const size_t MaxSizeForListB64 = 10000; //6.4M
const size_t MaxSizeForListB1K = 10000; //20000K,20M
const size_t MaxSizeForListBHalfK = 10000; //10000K,10M
const size_t MaxSizeForListB3K = 5000;  // 15000K,15M


class MemoryManager
{
public:
MemoryManager();
~MemoryManager();
void * Allocate(size_t len);
void  Free(void *obj,size_t sz);
void  OnTimer(time_t tm);
private:
void InitList(void * base,MemoryType mtype);
void CleanUp();


private:
list<void *>   b64ptrlist_;
list<void *>   b1kptrlist_;
list<void *>   bhalf1kptrlist_;
list<void *>   b3kptrlist_;
int newallocatecount_[THREE_K+1];
int reusedcount_[THREE_K+1];
int needcount_[THREE_K+1];
};


#endif



memmgr.cpp

#ifndef __MEMMGR_CPP
#define __MEMMGR_CPP


#include "memmgr.h"


using namespace std;




void MemoryManager::InitList(void * base,MemoryType mtype)
{
void *pbase = base;
int loop = 0;


if(B64_B==mtype)
{ 
//pbase+=64; 
newallocatecount_[B64_B]++;
while(loop<=BaseBlkNum-1) { b64ptrlist_.push_back(pbase); /*pbase+=B64;*/loop++;}
}
else
if(HALF_K==mtype)
{ 
//pbase+=512; 
newallocatecount_[HALF_K]++;
while(loop<=BaseBlkNum-1) { bhalf1kptrlist_.push_back(pbase); /*pbase+=HalfK;*/loop++;}
}
else
if(ONE_K == mtype)
{
//pbase+=1024; 
newallocatecount_[ONE_K]++;
while(loop<=BaseBlkNum-1) { b1kptrlist_.push_back(pbase); /*pbase+=OneK;*/loop++;}
}
else
if(THREE_K == mtype)
{
//pbase+=3072;
newallocatecount_[THREE_K]++;
while(loop<=BaseBlkNum-1) { b3kptrlist_.push_back(pbase); /*pbase+=ThreeK*/;loop++;}
}
};


MemoryManager::MemoryManager()
{
Logging::Info("[%d],%s,{%10u},Now MemoryManager creating ....\n",__LINE__,FileNameFormat(__FILE__),pThread_Self());

for(int i=0;i<=THREE_K;i++)
{
newallocatecount_[i]=0;
reusedcount_[i]=0;
needcount_[i]=0;
}
}


MemoryManager::~MemoryManager()
{
//CleanUp();
void *pbase = NULL;

//B64
list<void *>::iterator  it64 = b64ptrlist_.begin();
while(it64 != b64ptrlist_.end())
{
pbase = (*it64);
free(pbase);
pbase = NULL;
it64++;
}
    b64ptrlist_.clear();


//B1K
list<void *>::iterator  it1k = b1kptrlist_.begin();
while(it1k !=b1kptrlist_.end())
{
pbase =(*it1k);
free(pbase);
pbase = NULL;
it1k++;
}
b1kptrlist_.clear();


//BHalfK
list<void *>::iterator  ithalfk = bhalf1kptrlist_.begin();
while(ithalfk != bhalf1kptrlist_.end())
{
pbase = (*ithalfk);
free(pbase);
pbase = NULL;
ithalfk++;
}
bhalf1kptrlist_.clear();


//B3K
list<void *>::iterator  it3k = b3kptrlist_.begin();
while(it3k != b3kptrlist_.end())
{
pbase = (*it3k);
free(pbase);
pbase = NULL;
it3k++;
}
b3kptrlist_.clear();

Logging::Info("[%d],%s,{%10u},MemoryManager destroy ......\n",__LINE__,FileNameFormat(__FILE__),pThread_Self());
}


void * MemoryManager::Allocate(size_t len)
{
void *base=0;
void * blockptr=NULL;
MemoryType mtype = NO_MEM;
    
if(len< B64)
mtype = B64_B;
else
if(len < HalfK)
   mtype = HALF_K;
else
if(len < OneK)
mtype = ONE_K;
else
if(len < ThreeK)
mtype = THREE_K;


switch (mtype)
{
case B64_B:
{
if(b64ptrlist_.empty())
{
base = malloc(B64 * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
return NULL;
}
else
{
memset(base,0,B64*BaseBlkNum);
needcount_[B64_B]++;
newallocatecount_[B64_B]++;
return base;
}
}
else
{
blockptr = b64ptrlist_.front();
b64ptrlist_.pop_front();
needcount_[B64_B]++;
return blockptr;
}
break;
}


case HALF_K:
{
if(bhalf1kptrlist_.empty())
{
base = malloc(HalfK * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
return NULL;
}
else
{
memset(base,0,HalfK*BaseBlkNum);
needcount_[HALF_K]++;
newallocatecount_[HALF_K]++;
return base;
}
}
else
{
blockptr = bhalf1kptrlist_.front();
bhalf1kptrlist_.pop_front();
needcount_[HALF_K]++;
return blockptr;
}
break;
}


case ONE_K:
{
if(b1kptrlist_.empty())
{
base = malloc(OneK * BaseBlkNum);
if(base==NULL)
{
//Logging::Info("[%d],%s,{%10u},MemoryManager Allocate OneK  failed \n",__LINE__,FileNameFormat(__FILE__),pThread_Self());
return NULL;
}
else
{   
memset(base,0,OneK*BaseBlkNum);
needcount_[ONE_K]++;
newallocatecount_[ONE_K]++;
return base;
}
}
else
{
blockptr = b1kptrlist_.front();
b1kptrlist_.pop_front();
needcount_[ONE_K]++;
return blockptr;
}
break;
}


case THREE_K:
{
if(b3kptrlist_.empty())
        {
base = malloc(ThreeK * BaseBlkNum);
if(base==NULL)
{
return NULL;
}
else
{   
memset(base,0,ThreeK*BaseBlkNum);
needcount_[THREE_K]++;
newallocatecount_[THREE_K]++;
return base;
}
}
else
{
blockptr = b3kptrlist_.front();
b3kptrlist_.pop_front();
needcount_[THREE_K]++;
return blockptr;
}
break;
}


default:
return NULL;


}


return NULL;


  /*  if(len<=B64) //block 64
{
if(b64ptrlist_.empty())
{
//base = new char[B64 * BaseBlkNum];
base = malloc(B64 * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
return 0;
}
else
{
memset(base,0,B64*BaseBlkNum);
//mempoollist_.push_back(base);
InitList(base,B64_B);
}


blockptr = b64ptrlist_.front();
b64ptrlist_.pop_front();
needcount_[B64_B]++;
return blockptr;
}
else
{
blockptr = b64ptrlist_.front();
b64ptrlist_.pop_front();
needcount_[B64_B]++;
return blockptr;
}
}
else
if(len<=HalfK) //block 512
{
if(bhalf1kptrlist_.empty())
{
//base = new char[HalfK * BaseBlkNum];
base = malloc(HalfK * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
return 0;
}
else
{
memset(base,0,HalfK*BaseBlkNum);
//mempoollist_.push_back(base);
InitList(base,HALF_K);
}

blockptr = bhalf1kptrlist_.front();
bhalf1kptrlist_.pop_front();
needcount_[HALF_K]++;
return blockptr;
}
else
{
blockptr = bhalf1kptrlist_.front();
bhalf1kptrlist_.pop_front();
needcount_[HALF_K]++;
return blockptr;
}
}
else 
if(len <=OneK)  //block 1500
{
if(b1kptrlist_.empty())
        {
        //base = new char[OneK * BaseBlkNum];
base = malloc(OneK * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
Logging::Info("[%d],%s,{%10u},MemoryManager Allocate OneK  failed \n",__LINE__,FileNameFormat(__FILE__),pThread_Self());
return NULL;
}
else
{   
memset(base,0,OneK*BaseBlkNum);
//mempoollist_.push_back(base);
InitList(base,ONE_K);
}

blockptr = b1kptrlist_.front();
b1kptrlist_.pop_front();
needcount_[ONE_K]++;
return blockptr;
}
else
{
blockptr = b1kptrlist_.front();
b1kptrlist_.pop_front();
needcount_[ONE_K]++;
return blockptr;
}
}
else
if(len <=ThreeK)  //block 3072
{
if(b3kptrlist_.empty())
        {
        //base = new char[ThreeK * BaseBlkNum];
base = malloc(ThreeK * BaseBlkNum);
if(base==NULL)
{
//TraceAndAlarm cout<<"NOT enough memory to allocate"<<endl;
return 0;
}
else
{   
memset(base,0,ThreeK*BaseBlkNum);
//mempoollist_.push_back(base);
InitList(base,THREE_K);
}

blockptr = b3kptrlist_.front();
b3kptrlist_.pop_front();
needcount_[THREE_K]++;
return blockptr;
}
else
{
blockptr = b3kptrlist_.front();
b3kptrlist_.pop_front();
needcount_[THREE_K]++;
return blockptr;
}
}


return 0;
*/
};


void  MemoryManager::Free(void *obj,size_t sz)
{ 
MemoryType mtype=NO_MEM;
    
if(sz<B64)
mtype = B64_B;
else
if(sz<HalfK)
   mtype = HALF_K;
else
if(sz<OneK)
mtype = ONE_K;
else
if(sz < ThreeK)
mtype = THREE_K;
                  
//statistic reuse memory
reusedcount_[mtype]++;


switch (mtype)
{
case B64_B:
memset(obj,0,B64);
b64ptrlist_.push_front(obj);
return;
case HALF_K:
memset(obj,0,HalfK);
bhalf1kptrlist_.push_front(obj);
return;
case ONE_K:
memset(obj,0,OneK);
b1kptrlist_.push_front(obj);
return;
case THREE_K:
memset(obj,0,ThreeK);
b3kptrlist_.push_front(obj);
return;
default:
free(obj);
obj = NULL;
return;


}
};


void MemoryManager::CleanUp()
{


};


void MemoryManager::OnTimer(time_t tm)
{
Logging::Info("{%10u},Mem Usage Info: B64 [size: %u,NC: %u, RU: %u, ND: %u], B1k [size: %u,NC: %u, RU: %u, ND: %u],  BhalfK [size: %u,NC: %u, RU: %u,ND: %u], B3K [size: %u,NC: %u, RU: %u, ND: %u] \n",pThread_Self(),b64ptrlist_.size(),newallocatecount_[B64_B]*BaseBlkNum,reusedcount_[B64_B],needcount_[B64_B],b1kptrlist_.size(),newallocatecount_[ONE_K]*BaseBlkNum,reusedcount_[ONE_K],needcount_[ONE_K],bhalf1kptrlist_.size(),newallocatecount_[HALF_K]*BaseBlkNum,reusedcount_[HALF_K],needcount_[HALF_K],b3kptrlist_.size(),newallocatecount_[THREE_K]*BaseBlkNum,reusedcount_[THREE_K],needcount_[THREE_K]);

for(int i=0;i<=THREE_K;i++)
{
newallocatecount_[i]=0;
reusedcount_[i]=0;
needcount_[i]=0;
}


//check if need to free some memory to OS
size_t   tmplistlen = b64ptrlist_.size();

//B64
if(tmplistlen > MaxSizeForListB64 *2)
{
size_t  tmplen = tmplistlen - MaxSizeForListB64; 
void *pbase = NULL;
while(tmplen > 1)
{
pbase = b64ptrlist_.front();
b64ptrlist_.pop_front();
free(pbase);
pbase = NULL;
tmplen--;
}
}


//B1K
tmplistlen = b1kptrlist_.size();
if( tmplistlen> MaxSizeForListB1K *2)
{
size_t  tmplen = tmplistlen - MaxSizeForListB1K;
void *pbase = NULL;
while(tmplen > 1 )
{
pbase = b1kptrlist_.front();
b1kptrlist_.pop_front();
if(pbase !=NULL)
{
free(pbase);
pbase = NULL;
}
tmplen--;
}
}

//BHalfK
tmplistlen = bhalf1kptrlist_.size();
if(tmplistlen > MaxSizeForListBHalfK *2)
{
size_t  tmplen = tmplistlen - MaxSizeForListBHalfK;
void *pbase = NULL;
while(tmplen > 1)
{
pbase = bhalf1kptrlist_.front();
bhalf1kptrlist_.pop_front();
free(pbase);
pbase = NULL;
tmplen--;
}
}


//B3K
tmplistlen = b3kptrlist_.size();
if(tmplistlen > MaxSizeForListB3K *2)
{
size_t  tmplen = tmplistlen - MaxSizeForListB3K;
void *pbase = NULL;
while(tmplen > 1)
{
pbase = b3kptrlist_.front();
b3kptrlist_.pop_front();
free(pbase);
pbase = NULL;
tmplen--;
}
}

}


#endif

平哥
关注
专栏目录
一个动态内存管理模块的实现
11-30
引言 当前，绝大多数嵌入式平台上的软件都采用C语言编写。除了代码简洁、运行高效之外，灵活操作内存的能力更是C语言的重要特色。然而，不恰当的内存操作通常也...为此，本文介绍一个增强的、可定制的动态内存管理模块
C语言的内存管理
水逝流年
10-24 1723
1、内存管理的概述 当程序被加载到内存的时候，它在内存中会大致被组织成三个部分：代码区，静态存储区和动态存储区。代码区存放的是将要执行的程序的机器语言表示，包括组成程序的各种用户自定义函数和系统调用函数。关于静态存储区和动态存储区：The word static refers to things that happen at compile time and link time when the
内存管理系统 Memory Management System
weixin_44280688的博客
01-02 1379
文章目录key words:分段机制分页机制启用分页机制实现线性地址到物理地址转换的过程 key words: 分段机制 分页机制 用户空间 内核空间 逻辑地址 线性地址 物理地址 虚拟地址 分段机制 把逻辑地址转换为线性地址 分页机制 把线性地址转换为逻辑地址, 处理器分页机制会把线性地址空间划分成页面，然后这些线性地址空间页面被映射到物理地址空间的页面上 启用 通过设置控制寄存器 CR0 的 ...
一种简单实用的内存管理实现方法
Damon_Sandy的博客
03-15 491
内存管理
linux 内存管理(13) - memblock
weixin_41028621的博客
03-02 1426
了解memblock机制。 1.概述   在引导内核的过程中,需要使用内存, 而这个时候内核的内存管理并没有被创建, 因此也就需要一种精简的内存管理系统先接受这个工作, 而在初始化完成后, 再将旧的接口废弃, 转而使用强大的buddy系统来进行内存管理.   早期的Linux内核在引导阶段都是通过bootmem来完成初期的内存管理的, 但是后来的版本开始把bootmem弃用了,使用memblo...
桌面内存管理器(dwn.exe)占用内存过高时怎么办？
热门推荐
qq_40151247的博客
03-08 1万+
桌面内存管理器(dwn.exe)占用内存过高，可以解决的办法多种多样。 桌面内存管理器(dwn.exe)占用内存过高主要是因为存在DWM内存泄漏， 也正是因为这样，DWN内存泄露，不会自动回收内存，导致内存占用会不断升高，最后导致一系列的问题。
单片机的一种动态内存管理方法
08-12
使用该源码可以将单片机内部，外部RAM进行管理，在使用前调用初始化函数myMemInit（）进行内存初始化后即可使用，使用myMalloc（）实现内存的动态分配，使用myFree（）动态释放，使用方便、简单。只需更改需要管理的...
一个动态内存管理模块的实现-论文
05-08
从提供的文件内容来看，本文介绍了一种动态内存管理模块的实现方式，并详细阐述了该模块的设计原理、用户定制选项以及如何在嵌入式系统中应用动态内存管理技术。 首先，动态内存管理模块的核心功能包括监测和处理...
实现一个内存池管理的类方法
08-31
内存池是一种优化内存分配策略的技术，它通过预先一次性分配一大块连续内存，然后根据需要从中划分出小块内存进行分配，避免了频繁的系统调用和内存碎片的产生。在这个实现中，我们看到一个名为`MemoryPool`的类，它...
连续动态内存管理模拟实现
05-15
本项目旨在通过自定义的内存管理器，揭示动态内存管理的底层原理。 实现连续动态内存管理模拟器通常涉及以下几个步骤： 1. 初始化：首先，需要创建一个数据结构来表示64MB的内存空间，这可以是一个大数组或者是一...
C语言实现内存管理
03-21
通过C语言，基本实现了内存管理过程中的创建、修改、删除等操作
操作系统实验四——可变分区内存管理器设计与实现
qq_63052532的博客
01-17 1426
可变分区内存管理器设计与实现。
内存管理器（Memory Manager）
最新发布
听老罗娓娓道来
10-09 941
内存管理器是Unity引擎中至关重要的组件，它通过高效的内存分配与释放、垃圾回收、内存优化、资源管理、内存碎片整理、跨平台支持、性能监控、内存安全、内存预留与限制以及内存热更新等功能，确保了引擎的稳定性和高性能。希望这些信息对你有所帮助！如果你有更多具体的问题或需要进一步的详细解答，请随时提问。Unity内存管理器的架构设计综合考虑了效率、稳定性、兼容性和可扩展性。
实现简单的内存管理
qq_32938605的博客
07-13 735
1 源码： 源码已经提交github，内存管理github链接，欢迎一起讨论。 2 实现过程 该代码实现了在固定地址空间上进行内存的分配与释放。在操作系统启动时刻指定固定的地址作为mymlloc（）操作的Heap空间，也可以直接定义数组。在嵌入式系统中，最好指定固定的地址，方便进行管理以及问题的排查。 2.1 内存控制块定义 struct free_block_t{ unsigned long size; unsigned char *start; unsigned char *en
大内高手—内存管理器
jinghuainfo
06-27 198
大内高手—内存管理器 转载时请注明出处和作者联系方式：http://blog.csdn.net/absurd 作者联系方式：李先静 &lt;xianjimli at hotmail dot com&gt; 更新时间：2007-7-9 作为一个C程序员，每天都在和malloc/free/calloc/realloc系列函数打交道。也许和它们混得太熟了，反而忽略了它们的存在，甚...
操作系统-内存管理
captain
02-27 1370
内存抖动通常发生在系统内存不足时，导致操作系统频繁地将页面从物理内存中换出到磁盘（页面置换），而后又需要将其重新调入内存，这样频繁的置换操作会消耗大量的计算资源和时间，影响系统的性能。通常，操作系统会被加载到计算机的物理内存中，并占用一定的地址空间。通过这种方式，双向链表可以根据页面的访问顺序进行排序，最近访问的页面始终位于链表的头部，而最久未使用的页面位于链表的尾部。内存管理是操作系统中一个非常重要的功能，它主要负责管理计算机系统中的内存资源，包括内存的分配、回收、保护和共享等。
用c++写个内存管理器
weixin_35754962的博客
01-13 175
内存管理器是一种重要的系统组件，用于管理程序运行时使用的内存。下面是一个简单的 C 语言内存管理器的例子： #include <stdio.h> #include <stdlib.h> #define MEM_SIZE 100 char memory[MEM_SIZE]; int used_size = 0; void *my_malloc(int size) { ...
内存管理的具体实现
小哥哥咯的博客
01-05 939
程序与虚拟内存和物理内存的关系： 结构mm_struct可以看成属于一个程序的包括虚拟内存和物理内存的所有内存的控制块；vm_area_struct里有指向相关段虚拟地址的指针vm_end and vm_start和指向操作函数集中的函数指针vm_opst；mm_struct里有指向实际物理空间的指针pgd。Linux的空间分配： Linux以PAGE_OFFSET为界将4GB的虚拟内存空间分成
内存管理的算法及实现
难波儿万的博客
05-04 820
1.内存管理模块的算法原理及实现 bcos的内存管理模块预先会以数组的形式开辟一块内存空间，然后以链表的方式去管理内存的申请和释放。当然在管理的过程中链表的头和保存被占用空间的大小等数据会额外的占用一定的空间。在bcos中内存管理链表节点定义如下： typedef struct { slist_t list; size_t size; }bcos_mem_t; 每次我们申请一块空间时会额外的占用8个字节用来管理这块被分配的内存空间，如果你每次只申请一个字节这似乎看起来不是很合算，所以尽量不要那样做。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值