Chinaunix首页 | 论坛 | 博客

玄冬aigo.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

escarp

  • 博客访问： 1685057
  • 博文数量： 347
  • 博客积分： 9328
  • 博客等级： 中将
  • 技术积分： 2680
  • 用 户 组： 普通用户
  • 注册时间： 2010-07-29 23:45
文章分类

全部博文（347）

文章存档

2016年（1）

2013年（4）

2012年（207）

2011年（85）

2010年（50）

我的朋友
最近访客
推荐博文
相关博文
【转】C++ 内存池

分类： C/C++

2011-01-09 19:20:09

原文地址 http://www.cppblog.com/d3d/archive/2008/11/28/68097.aspx

SMemoryChunk.h

  1. #ifndef __SMEMORYCHUNK_H__
  2. #define __SMEMORYCHUNK_H__

  4. typedef unsigned char TByte ;

  6. struct SMemoryChunk
  7. {
  8.   TByte *Data; //数据

  10.   std::size_t DataSize; //该内存块的总大小

  12.   std::size_t UsedSize; //实际使用的大小

  14.   bool IsAllocationChunk;
  15.   SMemoryChunk *Next; //指向链表中下一个块的指针。

  17. };

  19. #endif

IMemoryBlock.h
  1. #ifndef __IMEMORYBLOCK_H__
  2. #define __IMEMORYBLOCK_H__

  4. class IMemoryBlock
  5. {
  6.   public :
  7.     virtual ~IMemoryBlock() {};

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

  12. };

  14. #endif

CMemoryPool.h
  1. #ifndef __CMEMORYPOOL_H__
  2. #define __CMEMORYPOOL_H__


  5. #include "IMemoryBlock.h"
  6. #include "SMemoryChunk.h"


  9. static const std::size_t DEFAULT_MEMORY_POOL_SIZE = 1000;//初始内存池的大小

  11. static const std::size_t DEFAULT_MEMORY_CHUNK_SIZE = 128;//Chunk的大小

  13. static const std::size_t DEFAULT_MEMORY_SIZE_TO_ALLOCATE = DEFAULT_MEMORY_CHUNK_SIZE * 2;

  15. class CMemoryPool : public IMemoryBlock
  16. {
  17. public:
  18.     CMemoryPool(const std::size_t &sInitialMemoryPoolSize = DEFAULT_MEMORY_POOL_SIZE,
  19.                 const std::size_t &sMemoryChunkSize = DEFAULT_MEMORY_CHUNK_SIZE,
  20.                 const std::size_t &sMinimalMemorySizeToAllocate = DEFAULT_MEMORY_SIZE_TO_ALLOCATE,
  21.                 bool bSetMemoryData = false
  22.                 );


  25.     virtual ~CMemoryPool();

  27.     //从内存池中申请内存

  29.     virtual void* GetMemory(const std::size_t &sMemorySize);
  30.     virtual void FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize);
  31.     
  32. private:
  33.     //申请内存OS

  35.     bool AllocateMemory(const std::size_t &sMemorySize);
  36.     void FreeAllAllocatedMemory();
  37.     SMemoryChunk* FindChunkHoldingPointerTo(void *ptrMemoryBlock);
  38.     void FreeChunks(SMemoryChunk *ptrChunk);
  39.     //计算可以分多少块

  41.     unsigned int CalculateNeededChunks(const std::size_t &sMemorySize);

  43.     //计算内存池最合适的大小

  45.     std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize);
  46.     
  47.     //建立链表.每个结点Data指针指向内存池中的内存地址

  49.     bool LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock);
  50.     
  51.     //重新计算块(Chunk)的大小1024--896--768--640--512------------

  53.     bool RecalcChunkMemorySize(SMemoryChunk* ptrChunk, unsigned int uiChunkCount);
  54.     
  55.     SMemoryChunk* SetChunkDefaults(SMemoryChunk *ptrChunk);
  56.     

  58.     //搜索链表找到一个能够持有被申请大小的内存块(Chunk).如果它返回NULL，那么在内存池中没有可用的内存

  60.     SMemoryChunk* FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize);

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

  66.     SMemoryChunk* SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip);
  67.     
  68.     void DeallocateAllChunks();

  70. private:

  72.     SMemoryChunk *m_ptrFirstChunk;
  73.     SMemoryChunk *m_ptrLastChunk;
  74.     SMemoryChunk *m_ptrCursorChunk;

  76.     std::size_t m_sTotalMemoryPoolSize; //内存池的总大小

  78.     std::size_t m_sUsedMemoryPoolSize; //以使用内存的大小

  80.     std::size_t m_sFreeMemoryPoolSize; //可用内存的大小


  83.     std::size_t m_sMemoryChunkSize; //块(Chunk)的大小

  85.     unsigned int m_uiMemoryChunkCount; //块(Chunk)的数量

  87.     unsigned int m_uiObjectCount;

  89.     bool m_bSetMemoryData ;
  90.     std::size_t m_sMinimalMemorySizeToAllocate;


  93. };

  95. #endif

CMemoryPool.cpp 

  1. #include "stdafx.h"
  2. #include "CMemorypool.h"

  4. #include <math.h>
  5. #include <assert.h>


  8. static const int FREEED_MEMORY_CONTENT = 0xAA;//填充释放的内存

  10. static const int NEW_ALLOCATED_MEMORY_CONTENT = 0xFF;


  13. CMemoryPool::CMemoryPool(const std::size_t &sInitialMemoryPoolSize,
  14.                          const std::size_t &sMemoryChunkSize,
  15.                          const std::size_t &sMinimalMemorySizeToAllocate,
  16.                          bool bSetMemoryData)
  17. {
  18.     m_ptrFirstChunk = NULL;
  19.     m_ptrLastChunk = NULL;
  20.     m_ptrCursorChunk = NULL;

  22.     m_sTotalMemoryPoolSize = 0;
  23.     m_sUsedMemoryPoolSize = 0;
  24.     m_sFreeMemoryPoolSize = 0;

  26.     m_sMemoryChunkSize = sMemoryChunkSize;
  27.     m_uiMemoryChunkCount = 0;
  28.     m_uiObjectCount = 0;

  30.     m_bSetMemoryData = !bSetMemoryData;
  31.     m_sMinimalMemorySizeToAllocate = sMinimalMemorySizeToAllocate;

  33.     AllocateMemory(sInitialMemoryPoolSize);
  34. }

  36. CMemoryPool::~CMemoryPool()
  37. {
  38.     FreeAllAllocatedMemory();
  39.     DeallocateAllChunks();

  41.     assert((m_uiObjectCount == 0) && "警告:内存-泄露:你没有释放全部申请的内存");
  42. }

  44. void CMemoryPool::FreeAllAllocatedMemory()
  45. {
  46.     SMemoryChunk *ptrChunk = m_ptrFirstChunk;
  47.     while(ptrChunk)
  48.     {
  49.         if(ptrChunk->IsAllocationChunk)
  50.         {
  51.             free(((void *) (ptrChunk->Data)));
  52.         }
  53.         ptrChunk = ptrChunk->Next;
  54.     }
  55. }

  57. void CMemoryPool::DeallocateAllChunks()
  58. {
  59.     SMemoryChunk *ptrChunk = m_ptrFirstChunk;
  60.     SMemoryChunk *ptrChunkToDelete = NULL;
  61.     while(ptrChunk)
  62.     {
  63.         if(ptrChunk->IsAllocationChunk)
  64.         {
  65.             if(ptrChunkToDelete)
  66.             {
  67.                 free(((void *) ptrChunkToDelete));
  68.             }
  69.             ptrChunkToDelete = ptrChunk;
  70.         }
  71.         ptrChunk = ptrChunk->Next;
  72.     }
  73. }

  75. void* CMemoryPool::GetMemory(const std::size_t &sMemorySize)
  76. {
  77.     std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);
  78.     SMemoryChunk* ptrChunk = NULL;
  79.     while(!ptrChunk)
  80.     {

  82.         ptrChunk = FindChunkSuitableToHoldMemory(sBestMemBlockSize);

  84.         //ptrChunk等于NULL表示内存池内存不够用

  86.         if(!ptrChunk)
  87.         {
  88.             sBestMemBlockSize = MaxValue(sBestMemBlockSize, CalculateBestMemoryBlockSize(m_sMinimalMemorySizeToAllocate));
  89.             //从OS申请更多的内存

  91.             AllocateMemory(sBestMemBlockSize);
  92.         }
  93.     }
  94.     //下面是找到可用的块(Chunk)代码

  96.     m_sUsedMemoryPoolSize += sBestMemBlockSize;
  97.     m_sFreeMemoryPoolSize -= sBestMemBlockSize;
  98.     m_uiObjectCount++;
  99.     //标记该块(Chunk)已用

  101.     SetMemoryChunkValues(ptrChunk, sBestMemBlockSize);

  103.     return ((void *) ptrChunk->Data);
  104. }

  106. void CMemoryPool::FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize)
  107. {
  108.     SMemoryChunk *ptrChunk = FindChunkHoldingPointerTo(ptrMemoryBlock);
  109.     if(ptrChunk)
  110.     {
  111.         FreeChunks(ptrChunk);
  112.     }
  113.     else
  114.     {
  115.         assert(false && "ERROR : Requested Pointer not in Memory Pool");
  116.     }
  117.     assert((m_uiObjectCount > 0) && "ERROR : Request to delete more Memory then allocated.");
  118.     m_uiObjectCount--;

  120. }

  122. void CMemoryPool::FreeChunks(SMemoryChunk *ptrChunk)
  123. {

  125.     SMemoryChunk *ptrCurrentChunk = ptrChunk ;
  126.     unsigned int uiChunkCount = CalculateNeededChunks(ptrCurrentChunk->UsedSize);
  127.     for(unsigned int i = 0; i < uiChunkCount; i++)
  128.     {
  129.         if(ptrCurrentChunk)
  130.         {

  132.             if(m_bSetMemoryData)
  133.             {
  134.                 memset(((void *) ptrCurrentChunk->Data), FREEED_MEMORY_CONTENT, m_sMemoryChunkSize) ;
  135.             }

  137.             ptrCurrentChunk->UsedSize = 0;

  139.             m_sUsedMemoryPoolSize -= m_sMemoryChunkSize;
  140.             ptrCurrentChunk = ptrCurrentChunk->Next;
  141.         }
  142.     }
  143. }

  145. SMemoryChunk *CMemoryPool::FindChunkHoldingPointerTo(void *ptrMemoryBlock)
  146. {
  147.     SMemoryChunk *ptrTempChunk = m_ptrFirstChunk;
  148.     while(ptrTempChunk)
  149.     {
  150.         if(ptrTempChunk->Data == ((TByte *) ptrMemoryBlock))
  151.         {
  152.             break;
  153.         }
  154.         ptrTempChunk = ptrTempChunk->Next;
  155.     }
  156.     return ptrTempChunk;
  157. }

  159. bool CMemoryPool::AllocateMemory(const std::size_t &sMemorySize)
  160. {
  161.     //计算可以分多少块(1000 / 128 = 8)

  163.     unsigned int uiNeededChunks = CalculateNeededChunks(sMemorySize);

  165.     //当内存池的初始大小为1000字节，块(Chunk)大小128字节，分8块还差24字节.怎么办?

  167.     //解决方案:多申请24字节

  169.     std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);

  171.     //向OS申请内存

  173.     TByte *ptrNewMemBlock = (TByte*) malloc(sBestMemBlockSize);

  175.     //分配一个结构体SmemoryChunk的数组来管理内存块

  177.     SMemoryChunk *ptrNewChunks = (SMemoryChunk*) malloc((uiNeededChunks * sizeof(SMemoryChunk)));


  180.     m_sTotalMemoryPoolSize += sBestMemBlockSize;
  181.     m_sFreeMemoryPoolSize += sBestMemBlockSize;
  182.     m_uiMemoryChunkCount += uiNeededChunks;


  185.     if(m_bSetMemoryData)
  186.     {
  187.         memset(((void *) ptrNewMemBlock), NEW_ALLOCATED_MEMORY_CONTENT, sBestMemBlockSize);
  188.     }

  190.     return LinkChunksToData(ptrNewChunks, uiNeededChunks, ptrNewMemBlock);

  192. }

  194. unsigned int CMemoryPool::CalculateNeededChunks(const std::size_t &sMemorySize)
  195. {
  196.     float f = (float) (((float)sMemorySize) / ((float)m_sMemoryChunkSize));
  197.     return ((unsigned int) ceil(f));
  198. }

  200. std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize)
  201. {
  202.     unsigned int uiNeededChunks = CalculateNeededChunks(sRequestedMemoryBlockSize);
  203.     return std::size_t((uiNeededChunks * m_sMemoryChunkSize));
  204. }

  206. bool CMemoryPool::LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock)
  207. {

  209.     SMemoryChunk *ptrNewChunk = NULL;
  210.     unsigned int uiMemOffSet = 0;
  211.     bool bAllocationChunkAssigned = false;
  212.     for(unsigned int i = 0; i < uiChunkCount; i++)
  213.     {
  214.         //建立链表

  216.         if(!m_ptrFirstChunk)
  217.         {
  218.             m_ptrFirstChunk = SetChunkDefaults(&(ptrNewChunks[0]));
  219.             m_ptrLastChunk = m_ptrFirstChunk;
  220.             m_ptrCursorChunk = m_ptrFirstChunk;
  221.         }
  222.         else
  223.         {
  224.             ptrNewChunk = SetChunkDefaults(&(ptrNewChunks[i]));
  225.             m_ptrLastChunk->Next = ptrNewChunk;
  226.             m_ptrLastChunk = ptrNewChunk;
  227.         }
  228.         //根据块(Chunk)的大小计算下一块的内存偏移地址

  230.         uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize));

  232.         //结点指向内存偏移地址

  234.         m_ptrLastChunk->Data = &(ptrNewMemBlock[uiMemOffSet]);


  237.         if(!bAllocationChunkAssigned)
  238.         {
  239.             m_ptrLastChunk->IsAllocationChunk = true;
  240.             bAllocationChunkAssigned = true;
  241.         }
  242.     }


  245.     return RecalcChunkMemorySize(m_ptrFirstChunk, m_uiMemoryChunkCount);

  247. }


  250. bool CMemoryPool::RecalcChunkMemorySize(SMemoryChunk *ptrChunk, unsigned int uiChunkCount)
  251. {
  252.     unsigned int uiMemOffSet = 0 ;
  253.     for(unsigned int i = 0; i < uiChunkCount; i++)
  254.     {
  255.         if(ptrChunk)
  256.         {
  257.             uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize)) ;
  258.             ptrChunk->DataSize = (((unsigned int) m_sTotalMemoryPoolSize) - uiMemOffSet);
  259.             ptrChunk = ptrChunk->Next;
  260.         }
  261.         else
  262.         {
  263.             assert(false && "Error : ptrChunk == NULL");
  264.             return false;
  265.         }
  266.     }
  267.     return true;
  268. }

  270. SMemoryChunk* CMemoryPool::SetChunkDefaults(SMemoryChunk* ptrChunk)
  271. {
  272.     if(ptrChunk)
  273.     {
  274.         ptrChunk->Data = NULL;
  275.         ptrChunk->DataSize = 0;
  276.         ptrChunk->UsedSize = 0;
  277.         ptrChunk->IsAllocationChunk = false;
  278.         ptrChunk->Next = NULL;
  279.     }
  280.     return ptrChunk;
  281. }

  283. //这里还没看明白

  285. SMemoryChunk *CMemoryPool::FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize)
  286. {
  287.     unsigned int uiChunksToSkip = 0;
  288.     bool bContinueSearch = true;
  289.     SMemoryChunk *ptrChunk = m_ptrCursorChunk;
  290.     for(unsigned int i = 0; i < m_uiMemoryChunkCount; i++)
  291.     {
  292.         if(ptrChunk)
  293.         {
  294.             if(ptrChunk == m_ptrLastChunk)
  295.             {
  296.                 ptrChunk = m_ptrFirstChunk;
  297.             }

  299.             if(ptrChunk->DataSize >= sMemorySize)
  300.             {
  301.                 if(ptrChunk->UsedSize == 0)
  302.                 {
  303.                     m_ptrCursorChunk = ptrChunk;
  304.                     return ptrChunk;
  305.                 }
  306.             }
  307.             uiChunksToSkip = CalculateNeededChunks(ptrChunk->UsedSize);
  308.             if(uiChunksToSkip == 0) uiChunksToSkip = 1;
  309.             ptrChunk = SkipChunks(ptrChunk, uiChunksToSkip);
  310.         }
  311.         else
  312.         {
  313.             bContinueSearch = false;
  314.         }
  315.     }
  316.     return NULL;
  317. }

  319. std::size_t CMemoryPool::MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const
  320. {
  321.     if(sValueA > sValueB)
  322.     {
  323.         return sValueA;
  324.     }
  325.     return sValueB;
  326. }

  328. void CMemoryPool::SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize)
  329. {
  330.     if((ptrChunk))
  331.     {
  332.         ptrChunk->UsedSize = sMemBlockSize;
  333.     }
  334.     else
  335.     {
  336.         assert(false && "Error : Invalid NULL-Pointer passed");
  337.     }
  338. }

  340. SMemoryChunk *CMemoryPool::SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip)
  341. {
  342.     SMemoryChunk *ptrCurrentChunk = ptrStartChunk;
  343.     for(unsigned int i = 0; i < uiChunksToSkip; i++)
  344.     {
  345.         if(ptrCurrentChunk)
  346.         {
  347.             ptrCurrentChunk = ptrCurrentChunk->Next;
  348.         }
  349.         else
  350.         {

  352.             assert(false && "Error : Chunk == NULL was not expected.");
  353.             break ;
  354.         }
  355.     }
  356.     return ptrCurrentChunk;
  357. }


测试方法:

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

  3. //


  6. #include "stdafx.h"

  8. #include "CMemoryPool.h"

  10. CMemoryPool* g_pMemPool = NULL;

  12. class testMemoryPool
  13. {
  14. public:
  15.     testMemoryPool(){
  16.     }
  17.     virtual ~testMemoryPool(){
  18.     }
  19.     void *operator new(std::size_t ObjectSize)
  20.     {
  21.         return g_pMemPool->GetMemory(ObjectSize) ;
  22.     }

  24.     void operator delete(void *ptrObject, std::size_t ObjectSize)
  25.     {
  26.         g_pMemPool->FreeMemory(ptrObject, ObjectSize) ;
  27.     }

  29. public:
  30.     char a[512];
  31.     bool b;
  32.     long c;
  33. };//sizeof(32);



  37. int _tmain(int argc, _TCHAR* argv[])
  38. {

  40.     g_pMemPool = new CMemoryPool();

  42.     testMemoryPool* test = new testMemoryPool();
  43.     if(test){
  44.         delete test;
  45.         test = NULL;
  46.     }

  48.     if(g_pMemPool)
  49.         delete g_pMemPool ;

  51.     return 0;
  52. }
阅读(1355) | 评论(0) | 转发(1) |
0

上一篇：[原]Visual Studio 2008集成C++代码格式化插件

下一篇：网址收藏

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6