一个简单的内存池，源码贡献

最新推荐文章于 2024-09-11 12:18:41 发布
最新推荐文章于 2024-09-11 12:18:41 发布
阅读量680 收藏 1
点赞数
文章标签： iterator features pair class bugs null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mjp_mjp/article/details/4402921
版权

头文件

#ifndef MY_MEMPOOL_H
#define MY_MEMPOOL_H


#define MY_MPN_B    namespace my_mempool{
#define MY_MPN_E    }
#define DECLARE_MY_MEMPOOL    using namespace ::my_mempool;

#include <string>
#include <map>
#include <vector>
using namespace ::std;

MY_MPN_B


/**
 * /ingroup my_memorypool
 *    CMPBase,base class ,non copyable.
 *
 * /par requirements
 * win98 or later/n
 * win2k or later/n
 * MFC/n
 *
 * /version 1.0
 * first version
 *
 * /date 2009-06-03
 *
 * /author Jason
 *
 * /par license
 * This code is absolutely free to use and modify. The code is provided "as is" with
 * no expressed or implied warranty. The author accepts no liability if it causes
 * any damage to your computer, causes your pet to fall ill, increases baldness
 * or makes your car start emitting strange noises when you start it up.
 * This code has no bugs, just undocumented features!
 *
 * /todo
 *
 * /bug
 *
 */
class CMPBase
{
private:
    CMPBase(const CMPBase &){}
    CMPBase & operator = (const CMPBase &){return *this;}
public:
    CMPBase(){}
    virtual ~CMPBase() = 0;
protected:
    int round_up(int  size);
public:
    /**
     * 追加一块内存
     * /param size
     *    追加内存的大小
     * /return
     *    返回追加的内存实际大小
     */
    virtual int append(int size) = 0;
   
    virtual void reap(void) = 0;

    /**
     * 计算总空间
     * /param void
     * /return
     */
    virtual int space_(void) = 0;
    /**
     * 计算分配了多少空间
     * /param void
     * /return
     */
    virtual int malloced(void) = 0;
    /**
     * 计算剩余空间
     * /param void
     * /return
     */
    virtual int freememory(void) = 0;

    /**
     * malloc memory,same to stardard c malloc function
     * /param size
     */
    virtual void * malloc(int size) = 0;
    /**
     * free memory
     * /param mp
     */
    virtual void free(void * mp) = 0;

    virtual void dump(const string & file) {};
};



/**
 * /ingroup my_memorypool
 *    class CMapMemoryPool
 *    简单实现
 * /par requirements
 * win98 or later/n
 * win2k or later/n
 * MFC/n
 *
 * /version 1.0
 * first version
 *
 * /date 2009-06-04
 *
 * /author Jason
 *
 * /par license
 * This code is absolutely free to use and modify. The code is provided "as is" with
 * no expressed or implied warranty. The author accepts no liability if it causes
 * any damage to your computer, causes your pet to fall ill, increases baldness
 * or makes your car start emitting strange noises when you start it up.
 * This code has no bugs, just undocumented features!
 *
 * /todo
 *
 * /bug
 *
 */
class CMapMemoryPool : public CMPBase
{
    enum{DEFAULTSIZE = 2 * 1024 * 1024};
    bool initialized;
public:
    CMapMemoryPool();
    CMapMemoryPool(const int & size);
    virtual ~CMapMemoryPool();


    //尽量大些
    virtual int append(int size);
    virtual void reap(void);
    virtual int space_(void){ return malloced() + freememory();}
    virtual int malloced(void);
    virtual int freememory(void);

    virtual void * malloc(int size);
    virtual void free(void * mp);

    virtual void dump(const string & file);

private:
    enum { mbMed = 0x00, mbHeader = 0x01, mbTail = 0x02};
    struct mem_control_block
    {
        int is_available;
        int flag;//mbHeader,mbMed,mbTail
        int size;
        int blockcounter;
    };
    // pointer , memory control block pointer
    map<unsigned int,unsigned int> free_memory;
    map<unsigned int,unsigned int> malloced_memory;

    typedef map<unsigned int,unsigned int> map_type;

    typedef pair<const unsigned int, unsigned int> map_it;

    int count_space(const map_type & m);

    //void realign_right(const unsigned int & pointer);
    //void realign_left(const unsigned int & pointer);

    class CSimpleCount
    {
    public:
        CSimpleCount()
            :count(0)
        {}

        void operator()(const map_it & t)
        {
            mem_control_block * p = (mem_control_block *)(t.second);
            if(p)
                count += p->size;
        }

        int Count(void)
        {
            return count;
        }
    private:
        int count;
    };

    struct temZone
    {
        void * buf;
        int size;

        temZone()
            :buf(0),size(0)
        {
            ;
        }
        temZone(void * b,int s)
            :buf(b),size(s)
        {
            ;
        }
        temZone(const temZone& t)
            :buf(t.buf),size(t.size)
        {
            ;
        }
        temZone & operator = (const temZone &t)
        {
            buf = t.buf;
            size = t.size;
            return *this;
        }
    };
    vector<temZone> _blocks;

    int blockcounter;
};




/**
 * /ingroup my_memorypool
 *    CGeneralMemoryPool，提供线程安全的实现
 *
 * /par requirements
 * win98 or later/n
 * win2k or later/n
 * MFC/n
 *
 * /version 1.0
 * first version
 *
 * /date 2009-06-03
 *
 * /author Jason
 *
 * /par license
 * This code is absolutely free to use and modify. The code is provided "as is" with
 * no expressed or implied warranty. The author accepts no liability if it causes
 * any damage to your computer, causes your pet to fall ill, increases baldness
 * or makes your car start emitting strange noises when you start it up.
 * This code has no bugs, just undocumented features!
 *
 * /todo
 *
 * /bug
 *
 */
template<class MUTEX__,class MPINSTANCE>
class CGeneralMemoryPool : public CMPBase
{
    class CSimGuard
    {
    public:
        CSimGuard(MUTEX__ & l)
            :lk(l)
        {
            lk.acquire();
        }
        ~CSimGuard(void)
        {
            lk.release();
        }
    private:
        MUTEX__ & lk;
    };
public:
    CGeneralMemoryPool()
    {
        mp_ins = new MPINSTANCE;
    }
    CGeneralMemoryPool(int size)
    {
        mp_ins = new MPINSTANCE(size);
    }
    virtual ~CGeneralMemoryPool(void)
    {
        delete mp_ins;
    }

    virtual int append(int size)
    {
        CSimGuard b(lock__);
        return mp_ins->append(size);
    }
    virtual void reap(void)
    {
        CSimGuard b(lock__);
        mp_ins->reap();
    }
    virtual int space_(void)
    {
        CSimGuard b(lock__);
        return mp_ins->space_();
    }
    virtual int malloced(void)
    {
        CSimGuard b(lock__);
        return mp_ins->malloced();
    }
    virtual int freememory(void)
    {
        CSimGuard b(lock__);
        return mp_ins->freememory();
    }
    virtual void * malloc(int size)
    {
        CSimGuard b(lock__);
        return mp_ins->malloc(size);
    }
    virtual void free(void * mp)
    {
        CSimGuard b(lock__);
        mp_ins->free(mp);
    }
    virtual void dump(const string & file)
    {
        CSimGuard b(lock__);
        mp_ins->dump(file);
    }


private:
    CGeneralMemoryPool(const CGeneralMemoryPool &){}
    CGeneralMemoryPool & operator = (const CGeneralMemoryPool & t){return *this;}

    MUTEX__ lock__;

    MPINSTANCE * mp_ins;

};


/**
 * /ingroup my_memorypool
 *    CObjectPool 提供基于内存池的对象级别的内存管理接口
 *
 * /par requirements
 * win98 or later/n
 * win2k or later/n
 * MFC/n
 *
 * /version 1.0
 * first version
 *
 * /date 2009-06-05
 *
 * /author Jason
 *
 * /par license
 * This code is absolutely free to use and modify. The code is provided "as is" with
 * no expressed or implied warranty. The author accepts no liability if it causes
 * any damage to your computer, causes your pet to fall ill, increases baldness
 * or makes your car start emitting strange noises when you start it up.
 * This code has no bugs, just undocumented features!
 *
 * /todo
 *
 * /bug
 *
 */
template<class _ACEMutex,class MPINSTANCE>
class CObjectPool : public CGeneralMemoryPool<_ACEMutex,MPINSTANCE>
{
    typedef CGeneralMemoryPool<_ACEMutex,MPINSTANCE> supper;
public:
    //这个定义应该会屏蔽超类的定义
    template<class T>
    T* malloc(/*int size*/T*& p)
    {
        void* obj = supper::malloc(sizeof(T)/*size*/);
        ::new (obj) T(/* not args */); // 进行默认构造
        p = (T*)obj;
        return /*(T*)obj*/p;
    }

    // 释放对象
    template<class T>
    void free(T* obj)
    {
        if (obj != 0)
        {
            obj->~T();
            supper::free(obj);
        }
    }
};

MY_MPN_E // namespace my_mempool


#endif /*MY_MEMBLOCK_H*/

cpp文件

#include <stdlib.h>
#include <algorithm>
#include <fstream>

#include "MemPool.h"


MY_MPN_B


CMPBase::~CMPBase()
{
    ;
}
int CMPBase::round_up(int  size)
{
     return (( size + 7) &~ 7);// 按8字节对齐
}


CMapMemoryPool::CMapMemoryPool()
:blockcounter(1),initialized(false)
{
    append(DEFAULTSIZE);
}
CMapMemoryPool::CMapMemoryPool(const int & size)
:blockcounter(1),initialized(false)
{
    append(size);
}
CMapMemoryPool::~CMapMemoryPool()
{
    reap();
}


int CMapMemoryPool::append(int size)
{
    if(size < 1024 * 10)
    {
        size = 1024 * 10;
    }
    size = round_up(size);

    char * p = (char*)::malloc(size);
    if(!p)
        return -1;

    ::memset(p,0,size);

    _blocks.push_back(temZone(p,size));

    mem_control_block * pMCB = (mem_control_block *)p;

    pMCB->flag = mbHeader | mbTail;
    pMCB->is_available = 1;
    pMCB->blockcounter = 0;
    pMCB->size = size;
    pMCB->blockcounter = blockcounter++;

    unsigned int v2,v1;
    v2 = (unsigned int)pMCB;
    v1 = (unsigned int)++pMCB;
    pair<map_type::iterator, bool> r ;
    r = free_memory.insert(make_pair(v1,v2));
    if(r.second)
    {
        initialized = true;
        return 0;
    }

    ::free(p);

    return -1;
}

void CMapMemoryPool::reap(void)
{
    initialized = false;
    for(vector<temZone>::iterator i = _blocks.begin(); i != _blocks.end() ; ++i)
    {
        if(i->buf)
            ::free(i->buf);
    }
    _blocks.clear();
}

int CMapMemoryPool::count_space(const map_type & m)
{
    if(!initialized)
        return -1;
    CSimpleCount counter__;
    for_each(m.begin(),m.end(),counter__);
    return counter__.Count();
}

int CMapMemoryPool::malloced(void)
{
    if(!initialized)
        return -1;
    return count_space(malloced_memory);
}
int CMapMemoryPool::freememory(void)
{
    if(!initialized)
        return -1;
    return count_space(free_memory);
}

void * CMapMemoryPool::malloc(int size)
{
    if(!initialized)
        return NULL;
       
    size = round_up(size);

    mem_control_block * p = NULL, * p1 = NULL;
    map_type::iterator i,i1 = free_memory.end();

    //修改实际内存
    for( i = free_memory.begin(); i != free_memory.end(); ++i)
    {
        p = (mem_control_block *)(i->second);
        if( p && p->size > size )
        {
            if( p->size < size * 2 )
            {
                p->is_available = 0;
                break;
            }

            else// larger ,blocking partition, Jason
            {
                int old_size = p->size;
                p->is_available = 0;

                if(old_size - size < sizeof(mem_control_block))
                {
                    break;
                }

                p->size = size + sizeof(mem_control_block);

                p1 = (mem_control_block*)((char*)p + p->size);
                p1->is_available = 1;
                p1->size = old_size - p->size;
                p1->blockcounter = p->blockcounter;

                if( ( p->flag & mbHeader ) == mbHeader && ( p->flag & mbTail ) == mbTail )
                {
                    p->flag = mbHeader;
                    p1->flag = mbTail;
                }

                else if( ( p->flag & mbTail ) == mbTail ) //尾巴
                {
                    p1->flag = mbTail;
                }

                else //if( ( p->flag | mbHeader ) == 0 ) //头和中间的处理一样
                {
                    p1->flag = mbMed;

                    i1 = ++i;
                    --i;
                    mem_control_block * p3 = (mem_control_block *)(i1->second);

                    if((unsigned int )p1 + p1->size != i1->second ) //不连续
                        break;

                    if(p3->blockcounter == p->blockcounter)// same memory block
                    {
                        p1->size += p3->size;
                        p1->flag = p3->flag;
                    }
                }

                break;
            }
        }//if( p && p->size > size )
    }//for

    //修改表
    if( i != free_memory.end() )
    {
        malloced_memory.insert(*i);

        if(i1 != free_memory.end())
            free_memory.erase(i,i1);
        else
            free_memory.erase(i);

        if(p1)//新块，加入进来了
        {
            char * _p = (char*)(p1+1);
            free_memory.insert(make_pair((unsigned int)_p,(unsigned int)p1));
        }

        return (void*)(++p);
    }

    return NULL;
}

void CMapMemoryPool::free(void * mp)
{
    if(!initialized)
        return ;
       
    mem_control_block * p = NULL, * p1 = NULL;
    map_type::iterator i;
    unsigned int k = (unsigned int)mp;
    i = malloced_memory.find(k);
    if(i != malloced_memory.end())
    {
        p = (mem_control_block *)i->second;
        malloced_memory.erase(i); // i 无效了

        p->is_available = 1;

        map_type::iterator previ,nexti;
        unsigned int _pos,pos_;
        map_type::iterator _i = free_memory.end(), i_ = free_memory.end(), it;
       
        pos_ = (unsigned int)p + p->size + sizeof(mem_control_block);
        _pos = 0;

        for( it = free_memory.begin(); it != free_memory.end() ; ++it)
        {
            p1 = (mem_control_block *)it->second;
           
            if(p1->blockcounter != p->blockcounter)
                continue;

            if( (unsigned) p1 + p1->size == (unsigned)p )//正好是前面的
            {
                _i = it;
            }
            else if( (unsigned) p1 == (unsigned)p + p->size )//正好是后面的
            {
                i_ = it;
                break;
            }
            else if((unsigned) p1 /*+ p1->size*/ > (unsigned)p + p->size )
                break;
        }

        if( _i == free_memory.end() && i_ == free_memory.end() )//没有找到邻接点
        {
            free_memory.insert( make_pair( (unsigned int) p + sizeof(mem_control_block) ,(unsigned int)p ) );
        }
        else if( _i != free_memory.end() && i_ != free_memory.end() ) //前驱后继都有
        {
            mem_control_block * _p, *p_;
            _p = (mem_control_block *)_i->second;
            p_ = (mem_control_block *)i_->second;

            _p->size += p->size + p_->size;
            if(p_->flag == mbTail)
                _p->flag |= p_->flag;

            free_memory.erase(_i,i_);
            free_memory.insert( make_pair( (unsigned int) _p + sizeof(mem_control_block) ,(unsigned int)_p ) );
        }
        else if( _i != free_memory.end() )//有前驱点
        {
            p1 = (mem_control_block *)_i->second;
            if(p->flag == mbTail)
                p1->flag |= p->flag;
            p1->size += p->size;

            free_memory.erase(_i);
            free_memory.insert( make_pair( (unsigned int) p1 + sizeof(mem_control_block) ,(unsigned int)p1 ) );
        }
        else if( i_ != free_memory.end() )//有后继点
        {
            p1 = (mem_control_block *)i_->second;
            if(p1->flag == mbTail)
                p->flag |= p1->flag;
            p->size += p1->size;

            free_memory.erase(i_);
            free_memory.insert( make_pair( (unsigned int) p + sizeof(mem_control_block) ,(unsigned int)p ) );
        }
    }
}

void CMapMemoryPool::dump(const string & file)
{
    if(!initialized)
        return ;
       
    fstream fs;
    fs.open(file.c_str(),/*ios::oct |*/ ios_base::out | ios::binary | ios::ate | ios::app);

    if(!fs.bad())
    {
        for( vector<temZone>::iterator i = _blocks.begin(); i != _blocks.end() ; ++i )
        {
            fs.write((const char *)i->buf,i->size);
        }

        fs.close();
    }
}


MY_MPN_E



 

FirryHere
关注
C++内存池(附源码)
ConstCpp的博客
05-13 5267
C++内存池 （附源码）
内存对齐的malloc、realloc、free
choumin的专栏
04-27 1309
最近需要用到内存对齐的内存分配函数，参考网上的一些实现，自己也试着写了一个，经过测试可以使用。欢迎拍砖，微笑。 0.内存对齐的大小#define CACHE_LINE_SIZE 64 /*内存对齐的大小，我们选用一个cache line的大小*/ #define CACHE_LINE_MASK (CACHE_LINE_SIZE - 1) /*用于计算对齐的掩码*/ 1.内存对齐的malloc(
手游作弊-内存读写实例
qq_38944721的博客
01-04 1万+
关于手游作弊的博客我鸽的有点久了哈哈，这篇文章就和大家讲解下在内存中数据的存储格式，如何读取和修改
CPP_STL——内存池（附源代码）
cute_shuai的博客
07-27 848
内存碎片 讲述内存池之前，先来说一下内存碎片的概念。物理内存实际的存储空间是连续的，内存没有被使用之前，进程刚跑起来的时候确实是顺序使用的，但是在系统中不断有进程提起，退出。这样内存在不停的被申请和释放，可用的物理内存空间不再连续，会产生很多的碎片，这就是内存碎片。 内存碎片过多，将造成内存的可用性降低，实际能用的内存没有剩余那么多，好比把一个亿分别存到一亿张银行卡一样，刷卡的时候每次只能刷一...
malloc 函数详解,虚拟内存与物理内存的联系与区别
qq_25072517的博客
05-06 9531
操作系统有虚拟内存与物理内存的概念。在很久以前，还没有虚拟内存概念的时候，程序寻址用的都是物理地址。程序能寻址的范围是有限的，这取决于CPU的地址线条数。比如在32位平台下，寻址的范围是2^32也就是4G。并且这是固定的，如果没有虚拟内存，且每次开启一个进程都给4G的物理内存，就可能会出现很多问题： 因为我的物理内存时有限的，当有多个进程要执行的时候，都要给4G内存，很显然你内存小一点，这很快就...
APR内存池的学习与实现
博客
01-30 2402
APR内存池的学习与实现 从读大学以来，一直到现在（大学毕业两年半了），在CSDN从来都是一个伸手党。。。今天突然觉得自己也应该为别人贡献点什么才对。于是，就以这章作为开篇吧。 在很早之前，本人在学习Apache中的内存池的实现的时候，尝试过仿照其重新简单实现了下。主要目的是更快得理解它。这篇文章也是基于当初我自己重新实现的代码上写的，其原理是一致的。 那么关于什么是内存池，内存池有哪些好处
Proxool数据库连接池源码解析与Java游戏开发实战
weixin_36474966的博客
09-11 943
本文还有配套的精品资源，点击获取 简介：源码阅读是提升IT专业技能、理解软件运行机制和解决问题的关键。本文探讨了proxool-0.9.0RC3，一个为Spring JDBC提供支持的Java数据库连接池工具，以及其对性能和稳定性的影响。同时，分析了Java游戏源码阅读的重要性，包括对游戏架构、逻辑处理和性能优化的学习。阅读源码有助于深入理解类库工作原理，掌握编程技巧和设计...
LWIP源码学习---动态内存分配（分配策略概述）
AppleJunJun的博客
05-18 1046
写在前面 这是第一篇原创博客，想要从这里开始自己博客之路。由于最近项目中有用到STM32F4+LWIP实现LXI协议，故想借此机会学习LWIP源码，拓展自己在软件方面的知识面（本人方向较侧重于嵌入式硬件），由于了解不深，文章中有错误的地方还望大家批评指正，多多交流，一同进步。 lwip---轻量级软件协议栈 一、概述 LWIP，Low Weight （轻量）IP协议是瑞典计算机研究院开发的...
抓到Netty一个隐藏很深的内存泄露Bug | 详解Recycler对象池的精妙设计与实现
bin的技术小屋
03-19 1177
本文介绍了笔者如何发现了Netty一个隐藏很深的内存泄露相关的Bug，并详细介绍了Bug的修复过程。基于这个契机，详细剖析了对象池在Netty中的一些精妙设计和源码实现
Android 网页浏览器源码.zip
07-19
"Android网页浏览器源码"这个项目提供了一个宝贵的资源，让我们有机会探索和学习如何在Android平台上构建一个功能完善的浏览器应用。以下是对这个主题的详细分析： 首先，源码的重要性不容忽视。对于任何软件工程来...
深入理解Java源码：提升技术功底，深度掌握技术框架，快速定位线上问题
01-08
配合无锁串行化设计思想，Netty确保了消息处理在同一个线程中完成，避免了多线程间的竞争和同步锁，提升了性能。例如，当NioEventLoop接收到消息时，它会直接调用ChannelPipeline，直至到达用户的Handler，期间不...
安卓Android源码——Square.zip
10-14
Square的源码可能涉及到其中的一个或多个层面，帮助开发者提升应用的效率和稳定性。 2. **Square开源项目** Square公司开源了一系列用于Android开发的库，如OkHttp（网络请求库），Retrofit（网络请求的注解式接口...
基于WebRTC构建的C++程序因虚拟内存不足导致闪退问题的排查以及解决办法的探究
热门推荐
dvlinker的技术专栏
10-22 2万+
基于WebRTC的程序因虚拟内存不足导致闪退问题的排查以及解决办法的研究。
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
Ringtones波点音乐-《Lightning Moment》.mp3
10-09
Ringtones波点音乐-《Lightning Moment》.mp3
onnx2onnx-0.3.1.tar.gz
10-09
onnx2onnx-0.3.1.tar
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
实现卡尔曼滤波器,扩展卡尔曼滤波器,双卡尔曼滤波器和平方根卡尔曼滤波器Matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Nginx内存池详解：轻量型服务器的内存管理策略
2. **next**：链接指针，将多个内存池连接成链表，使得内存可以动态扩展。 3. **failed**：记录内存分配失败的次数，用于检测内存池的健康状态。 内存池的管理模块struct ngx_pool_s中包含了ngx_pool_data_t数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值