简明分析C/C++内存分配的解决方案

最新推荐文章于 2022-08-18 15:30:07 发布
最新推荐文章于 2022-08-18 15:30:07 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： C++ 文章标签： null float class struct os oracle
本文介绍了一种用于C/C++的内存池技术，该技术通过预分配一大块内存并将其分割成小块，以减少内存碎片并提高内存分配效率。文章提供了内存池的实现代码，并解释了如何使用该内存池来替代标准的malloc和new操作。
摘要由CSDN通过智能技术生成
 

简明分析C/C++内存分配的解决方案

http://developer.51cto.com  2008-12-01 09:09  佚名  Chinaitlab   我要评论(0)

C/C++的内存分配（通过malloc或new）可能需要花费很多时。

更糟糕的是，随着时间的流逝，内存（memory）将形成碎片，所以一个应用程序的运行会越来越慢。当它运行了很长时间和/或执行了很多的内存分配（释放）操作的时候。特别是，你经常申请很小的一块内存，堆（heap）会变成碎片的。

解决方案：你自己的内存池一个（可能的）解决方法是内存池（Memory Pool）。

在启动的时候，一个“内存池”（Memory Pool）分配一块很大的内存，并将会将这个大块（block）分成较小的块（smaller chunks）。每次你从内存池申请内存空间时，它会从先前已经分配的块（chunks）中得到，而不是从操作系统。最大的优势在于：

1：非常少（几没有） 堆碎片

2： 比通常的内存申请/释放（比如通过malloc， new等）的方式快另外，你可以得到以下好处：1：检查任何一个指针是否在内存池里2：写一个“堆转储（Heap-Dump）”到你的硬盘（对事后的调试非常有用）

3： 某种“内存泄漏检测（memory-leak detection）”：当你没有释放所有以前分配的内存时，内存池（Memory Pool）会抛出一个断言（assertion）。

SMemoryChunk.h

#ifndef __SMEMORYCHUNK_H__
#define __SMEMORYCHUNK_H__

typedef unsigned char TByte ;

struct SMemoryChunk
{
  TByte *Data;                 //数据 
  std::size_t DataSize;        //该内存块的总大小
  std::size_t UsedSize;        //实际使用的大小
  bool IsAllocationChunk;    
  SMemoryChunk *Next;          //指向链表中下一个块的指针。
};

#endif

IMemoryBlock.h

#ifndef __IMEMORYBLOCK_H__
#define __IMEMORYBLOCK_H__

class IMemoryBlock
{
  public :
    virtual ~IMemoryBlock() {};

    virtual void *GetMemory(const std::size_t &sMemorySize) = 0;
    virtual void FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize) = 0; 

};

#endif

CMemoryPool.h

#ifndef __CMEMORYPOOL_H__
#define __CMEMORYPOOL_H__

#include "IMemoryBlock.h"
#include "SMemoryChunk.h"

static const std::size_t DEFAULT_MEMORY_POOL_SIZE        = 1000;//初始内存池的大小
static const std::size_t DEFAULT_MEMORY_CHUNK_SIZE       = 128;//Chunk的大小
static const std::size_t DEFAULT_MEMORY_SIZE_TO_ALLOCATE = DEFAULT_MEMORY_CHUNK_SIZE * 2;

class CMemoryPool : public IMemoryBlock
{
public:
    CMemoryPool(const std::size_t &sInitialMemoryPoolSize = DEFAULT_MEMORY_POOL_SIZE, 
                const std::size_t &sMemoryChunkSize = DEFAULT_MEMORY_CHUNK_SIZE,
                const std::size_t &sMinimalMemorySizeToAllocate = DEFAULT_MEMORY_SIZE_TO_ALLOCATE,
                bool bSetMemoryData = false
                );

    virtual ~CMemoryPool();

    //从内存池中申请内存
    virtual void* GetMemory(const std::size_t &sMemorySize);
    virtual void  FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize);
    
private:
    //申请内存OS
    bool AllocateMemory(const std::size_t &sMemorySize);
    void FreeAllAllocatedMemory();
    
    //计算可以分多少块
    unsigned int CalculateNeededChunks(const std::size_t &sMemorySize);

    //计算内存池最合适的大小
    std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize);
    
    //建立链表.每个结点Data指针指向内存池中的内存地址
    bool LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock);
    
    //重新计算块(Chunk)的大小1024--896--768--640--512------------
    bool RecalcChunkMemorySize(SMemoryChunk* ptrChunk, unsigned int uiChunkCount);
    
    SMemoryChunk* SetChunkDefaults(SMemoryChunk *ptrChunk);

    //搜索链表找到一个能够持有被申请大小的内存块(Chunk).如果它返回NULL，那么在内存池中没有可用的内存
    SMemoryChunk* FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize);

    std::size_t MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const;
    
    void SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize);

    SMemoryChunk* SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip);

private:

    SMemoryChunk *m_ptrFirstChunk;
    SMemoryChunk *m_ptrLastChunk;   
    SMemoryChunk *m_ptrCursorChunk;

    std::size_t m_sTotalMemoryPoolSize;  //内存池的总大小
    std::size_t m_sUsedMemoryPoolSize;   //以使用内存的大小
    std::size_t m_sFreeMemoryPoolSize;   //可用内存的大小

    std::size_t m_sMemoryChunkSize;      //块(Chunk)的大小
    unsigned int m_uiMemoryChunkCount;   //块(Chunk)的数量
    unsigned int m_uiObjectCount;

    bool m_bSetMemoryData ; 
    std::size_t m_sMinimalMemorySizeToAllocate;

};

#endif


CMemoryPool.h

#include "stdafx.h"
#include "CMemorypool.h"

#include 
       
       
        
        
#include 
        
        
         
         

static const int NEW_ALLOCATED_MEMORY_CONTENT = 0xFF ;


CMemoryPool::CMemoryPool(const std::size_t &sInitialMemoryPoolSize,
                         const std::size_t &sMemoryChunkSize,
                         const std::size_t &sMinimalMemorySizeToAllocate,
                         bool bSetMemoryData)
{
    m_ptrFirstChunk  = NULL;
    m_ptrLastChunk   = NULL;
    m_ptrCursorChunk = NULL;

    m_sTotalMemoryPoolSize = 0;
    m_sUsedMemoryPoolSize  = 0;
    m_sFreeMemoryPoolSize  = 0;

    m_sMemoryChunkSize   = sMemoryChunkSize;
    m_uiMemoryChunkCount = 0;
    m_uiObjectCount      = 0;

    m_bSetMemoryData               = !bSetMemoryData;
    m_sMinimalMemorySizeToAllocate = sMinimalMemorySizeToAllocate;

    AllocateMemory(sInitialMemoryPoolSize);
}

CMemoryPool::~CMemoryPool()
{

}

void* CMemoryPool::GetMemory(const std::size_t &sMemorySize)
{
    std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);  
    SMemoryChunk* ptrChunk = NULL;
    while(!ptrChunk)
    {

        ptrChunk = FindChunkSuitableToHoldMemory(sBestMemBlockSize);

        //ptrChunk等于NULL表示内存池内存不够用
        if(!ptrChunk)
        {
            sBestMemBlockSize = MaxValue(sBestMemBlockSize, CalculateBestMemoryBlockSize(m_sMinimalMemorySizeToAllocate));
            //从OS申请更多的内存
            AllocateMemory(sBestMemBlockSize);
        }
    }
    //下面是找到可用的块(Chunk)代码
    m_sUsedMemoryPoolSize += sBestMemBlockSize;
    m_sFreeMemoryPoolSize -= sBestMemBlockSize;
    m_uiObjectCount++;
    //标记该块(Chunk)已用
    SetMemoryChunkValues(ptrChunk, sBestMemBlockSize);

    return ((void *) ptrChunk->Data);
}

void CMemoryPool::FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize)
{

}

bool CMemoryPool::AllocateMemory(const std::size_t &sMemorySize)
{
    //计算可以分多少块(1000 / 128 = 8)
    unsigned int uiNeededChunks = CalculateNeededChunks(sMemorySize);

    //当内存池的初始大小为1000字节，块(Chunk)大小128字节，分8块还差24字节.怎么办?
    //解决方案:多申请24字节
    std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);

    //向OS申请内存
    TByte *ptrNewMemBlock = (TByte*) malloc(sBestMemBlockSize);

    //分配一个结构体SmemoryChunk的数组来管理内存块
    SMemoryChunk *ptrNewChunks = (SMemoryChunk*) malloc((uiNeededChunks * sizeof(SMemoryChunk))); 

    m_sTotalMemoryPoolSize += sBestMemBlockSize;
    m_sFreeMemoryPoolSize += sBestMemBlockSize;
    m_uiMemoryChunkCount += uiNeededChunks;

    if(m_bSetMemoryData)
    {
        memset(((void *) ptrNewMemBlock), NEW_ALLOCATED_MEMORY_CONTENT, sBestMemBlockSize);
    }

    return LinkChunksToData(ptrNewChunks, uiNeededChunks, ptrNewMemBlock);
}

unsigned int CMemoryPool::CalculateNeededChunks(const std::size_t &sMemorySize)
{
    float f = (float) (((float)sMemorySize) / ((float)m_sMemoryChunkSize));
    return ((unsigned int) ceil(f));
}

std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize)
{
    unsigned int uiNeededChunks = CalculateNeededChunks(sRequestedMemoryBlockSize);
    return std::size_t((uiNeededChunks * m_sMemoryChunkSize));
}

bool CMemoryPool::LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock)
{
    SMemoryChunk *ptrNewChunk = NULL;
    unsigned int uiMemOffSet = 0; 
    bool bAllocationChunkAssigned = false ;
    for(unsigned int i = 0; i < uiChunkCount; i++)
    {    
        //建立链表
        if(!m_ptrFirstChunk)
        {
            m_ptrFirstChunk = SetChunkDefaults(&(ptrNewChunks[0]));
            m_ptrLastChunk = m_ptrFirstChunk;
            m_ptrCursorChunk = m_ptrFirstChunk;
        }
        else
        {
            ptrNewChunk = SetChunkDefaults(&(ptrNewChunks[i]));
            m_ptrLastChunk->Next = ptrNewChunk;
            m_ptrLastChunk = ptrNewChunk;
        }
        //根据块(Chunk)的大小计算下一块的内存偏移地址
        uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize));

        //结点指向内存偏移地址
        m_ptrLastChunk->Data = &(ptrNewMemBlock[uiMemOffSet]);


        if(!bAllocationChunkAssigned)
        {
            m_ptrLastChunk->IsAllocationChunk = true;
            bAllocationChunkAssigned = true;
        }
    }
    return RecalcChunkMemorySize(m_ptrFirstChunk, m_uiMemoryChunkCount);
}

bool CMemoryPool::RecalcChunkMemorySize(SMemoryChunk *ptrChunk, unsigned int uiChunkCount)
{
    unsigned int uiMemOffSet = 0 ;
    for(unsigned int i = 0; i < uiChunkCount; i++)
    {
        if(ptrChunk)
        {
            uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize)) ;
            ptrChunk->DataSize = (((unsigned int) m_sTotalMemoryPoolSize) - uiMemOffSet);
            ptrChunk = ptrChunk->Next ;
        }
        else
        {
            assert(false && "Error : ptrChunk == NULL");
            return false;
        }
    }
    return true;
}

SMemoryChunk* CMemoryPool::SetChunkDefaults(SMemoryChunk* ptrChunk)
{
    if(ptrChunk)
    {
        ptrChunk->Data = NULL;
        ptrChunk->DataSize = 0;
        ptrChunk->UsedSize = 0;
        ptrChunk->IsAllocationChunk = false;
        ptrChunk->Next = NULL;
    }
    return ptrChunk;
}

SMemoryChunk *CMemoryPool::FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize)
{
    unsigned int uiChunksToSkip = 0;
    bool bContinueSearch = true;
    SMemoryChunk *ptrChunk = m_ptrCursorChunk; 
    for(unsigned int i = 0; i < m_uiMemoryChunkCount; i++)
    {
        if(ptrChunk)
        {
            if(ptrChunk == m_ptrLastChunk) 
            {
                ptrChunk = m_ptrFirstChunk;
            }

            if(ptrChunk->DataSize >= sMemorySize)
            {
                if(ptrChunk->UsedSize == 0)
                {
                    m_ptrCursorChunk = ptrChunk;
                    return ptrChunk;
                }
            }
            uiChunksToSkip = CalculateNeededChunks(ptrChunk->UsedSize);
            if(uiChunksToSkip == 0) uiChunksToSkip = 1;
            ptrChunk = SkipChunks(ptrChunk, uiChunksToSkip);
        }
        else
        {
            bContinueSearch = false 
        }
    }
    return NULL;
}

std::size_t CMemoryPool::MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const
{
    if(sValueA > sValueB)
    {
        return sValueA;
    }
    return sValueB;
}

void CMemoryPool::SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize)
{
    if((ptrChunk))
    {
        ptrChunk->UsedSize = sMemBlockSize;
    }
    else
    {
        assert(false && "Error : Invalid NULL-Pointer passed");
    }
}

SMemoryChunk *CMemoryPool::SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip)
{
    SMemoryChunk *ptrCurrentChunk = ptrStartChunk;
    for(unsigned int i = 0; i < uiChunksToSkip; i++)
    {
        if(ptrCurrentChunk)
        {
            ptrCurrentChunk = ptrCurrentChunk->Next;
        }
        else
        {
            assert(false && "Error : Chunk == NULL was not expected.");
            break ;
        }
    }
    return ptrCurrentChunk;
}

测试方法：

// 111.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "CMemoryPool.h"

CMemoryPool* g_pMemPool = NULL;

class testMemoryPool
{
public:
    testMemoryPool(){
    }

    void *operator new(std::size_t ObjectSize)
    {
        return g_pMemPool->GetMemory(ObjectSize) ;
    }

private:
    char a[25];
    bool b;
    long c;
};//sizeof(32);

int _tmain(int argc, _TCHAR* argv[])
{
    g_pMemPool = new CMemoryPool();

    testMemoryPool* test = new testMemoryPool();

    return 0;
}

SearchLife
关注
专栏目录
C++ 软件开发多国语言解决方案汇总
weixin_30872157的博客
07-17 3581
暂时汇总出了以下几种方法 以Unicode为核心 采用 GNU gettext 基于Qt的多语言开发工具：Qt Linguist 以Unicode为核心 参考：http://www.ibm.com/developerworks/cn/linux/l-cn-ccppglb/ 多国语言的存在，使程序员在编码处理上花费了大量时间和精力；然而各种各...
c++
beyondkim
06-12 467
第1章 面向对象程序设计概述 面向过程程序设计 面向对象程序设计 面向对象的软件开发 图书馆图书借阅管理系统的面向对象分析与设计 Coding Conventions (编码规范) Google开源项目风格指南 英文原版：https://github.com/google/styleguide 中文版：https://github.com/zh-google-styleguide/zh-google-styleguide 其中C++ 规范5 万多字，过于庞大 geosoft.no的编码风格指南（英文版） h
c语言标准库内存分配监控,自己写C++标准库容器的内存分配程序
weixin_42509774的博客
05-18 127
该楼层疑似违规已被系统折叠隐藏此楼查看此楼<index=freelist_index(sizeof(T));if(index>=NODENUMS){returnNULL;}my_free_list=pHead->uFreelist+index;//Lock(semid,LOCK_NUM);result=*my_free_list;if(result==...
C/C++内存管理器
weixin_33835690的博客
08-21 632
C标准库提供了malloc,free,calloc,realloc，C++标准库还提供了new, new[], delete, delete[]。这些用来管理内存，看起来够用了，为啥还要自己写一个内存管理器呢？ 原因还是从性能考虑：例如malloc和new是出于通用性考虑的，能处理多线程情况(multithread)。对于单线程的程序，这种额外的功能反而降低性能。 而且还注意到，new/delet...
关于c++内存分配，释放及泄露问题
少壮要努力
08-05 402
防止泄露的问题： 1、malloc与free结合使用 2、new与delete结合使用 3、特别注意：用new创建了一个新对象，记得使用完之后要删除，不然，如果你的程序是一个死循环一直执行的话，所占的内存会越来越大 一定要delete对象，才会恢复正常。有时运行时，所占的物理内存会慢慢变大，这是由于系统不会立刻收回内存，你得多运行一段时间再看是否会有变化。 4、在其它博客上看到的说mem
C++ 快速内存分配
zhuweisky
07-07 3370
                   C++ 快速内存分配                                                        ――zhuweisky  2003.12.10 我们知道，C++中当我们用new在堆中创建一个对象时，会发生两件事情。首先调用operator new分配一定大小的内存空间，然后在此空间上调用构造函数以形成对象。而operator
C++语言学习经验集合.rar
02-25
"经验"一词则意味着这些内容不仅仅是理论知识，还可能涵盖了作者或社区在实际编程过程中遇到的问题和解决方案。 压缩包子文件的"《C语言编程宝典》"可能是其中的一个重要组成部分。C语言是C++的基础，理解C语言的...
数据结构与算法知识要点简明教程（合集）
编程之路
07-23 2335
参考：https://blog.csdn.net/jiaoyangwm/article/details/80808235 本文仅是将他人博客经个人理解转化为简明的知识点，供各位博友快速理解记忆，并非纯原创博客，如需了解详细知识点，请查看参考的各个原创博客。 ...
【重新上本科】在实际问题中，内存赋值所拖累的效率（c++版本）
xceman1997的专栏
02-27 1846
这几天和同事们在讨论技术方案，现有的功能、服务已经实现了，主要是后续代码优化和效率提升。code review过程中发现了一个效率瓶颈。故事大概是这样的，同事需要在一大坨的数据中按照某种标准缩小范围，如：数据池有1T数据，我们根据某种条件过滤，满足条件的有1G数据。在这小范围数据集合中，再进一步做数据处理和选择，如：找最小值或者最大值。同事在缩小数据范围的时候，将所有满足条件的数据都存到了一个bu
2021-08-07
xian1yun1tan1ying的博客
08-07 7753
最近一周手里的程序出现了内存越界，每次一运行就会报错，有时是：malloc_consolidate() : invalid chunk size，有时是：invalid pointer ，有时是段错误。我负责在深度学习训练框架上支持 GPU 之外的另一种硬件加速卡，训练框架的存储分成三级：第一级叫chunk，chunk切分成 block，block再切分成 register，这些存储空间可能在host上，也可能在device上，程序运行的过程中输入数据会从 host 拷贝到 device 上，计算完成后再从
[err] malloc_consolidate(): invalid chunk size
bearrex的博客
08-18 2779
代码】[err] malloc_consolidate(): invalid chunk size。
数组与枚举初始化的最后多一个逗号
weixin_34357928的博客
02-21 270
为什么80%的码农都做不了架构师？>>> ...
从零开始的Linux堆利用(十三)——堆风水
weixin_43044226的博客
06-25 1125
这一节主要包含两个部分，高版本下的House of Rabbit以及堆风水在House of Rabbit中学习到了House of Rabbit的利用方式，这种利用思路通过修改fastbin的fd指针、触发将fastbin放入到unsortedbin、进一步修改fake chunk的大小使chunk放入到largebin进而得到任意地址的写能力。但是这里有一个前提就是之前的glibc版本比较低(2.25)在glibc 2.27中的函数中增加了对fastbin的size的检查 可以看到在之前检查了
glibc2.23-glibc2.29的malloc.c的变化
For Geek
10-17 1561
在pwn堆利用中 往往需要根据glibc的版本对exp进行一个改进 本人根据自身的需要对glibc2.23-glibc2.29在malloc.c在堆分配和回收策略上的变化进行一个记录 最主要的是记录报错信息 Glibc2.23 _int_malloc 从fastbin中分配fast chunk的时候 malloc的时候 会对fastbin->fd指向的chunk 验证一遍它是否在对应的fas...
TensorFlow内存管理bfc算法
qihao
08-22 5236
1. 基本介绍 tensorflow设备内存管理模块实现了一个best-fit with coalescing算法（后文简称bfc算法）。 bfc算法是Doung Lea’s malloc(dlmalloc)的一个非常简单的版本。 它具有内存分配、释放、碎片管理等基本功能。 2. bfc基本算法思想1. 数据结构 整个内存空间由一个按基址升序排列的Chunk双向链表来表示，它们的直接前趋和后继必须在
Boost.ASIO源码：thread_info_base::allocate古怪的内存分配逻辑解析与猜想
weixin_43827934的博客
11-29 638
自我感觉这个内存组织思路很有参考学习价值，故在此总结一下。 thread_info_base介绍 啥是thread_info 要引出thread_info_base就得从scheduler说起，scheduler实际上就是io_service的一个实现，而众所周知（不知者百度），io_service中有一个公共队列和若干个与线程数对应的私有队列，当用户post了数据进来时，随机的某个空闲线程的私有...
Eclipse+C/C++开发环境配置教程
在Eclipse上进行C/C++开发，首先需要安装Eclipse集成开发环境，并且还需要一个C/C++开发的插件，即CDT（C/C++ Development Tools）。本文提供了一个简明教程，旨在帮助初学者避免在配置过程中遇到的常见问题。 1. *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值