C++内存池

原文地址 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; //数据
9.   std::size_t DataSize; //该内存块的总大小
10.   std::size_t UsedSize; //实际使用的大小
11.   bool IsAllocationChunk;
12.   SMemoryChunk *Next; //指向链表中下一个块的指针。
13. };
14. #endif

IMemoryBlock.h

1. #ifndef __IMEMORYBLOCK_H__
2. #define __IMEMORYBLOCK_H__
   
3. class IMemoryBlock
4. {
5.   public :
6.     virtual ~IMemoryBlock() {};
7.     virtual void *GetMemory(const std::size_t &sMemorySize) = 0;
8.     virtual void FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize) = 0;
9. };
10. #endif

CMemoryPool.h

1. #ifndef __CMEMORYPOOL_H__
2. #define __CMEMORYPOOL_H__
3. #include "IMemoryBlock.h"
4. #include "SMemoryChunk.h"
   
5. static const std::size_t DEFAULT_MEMORY_POOL_SIZE = 1000;//初始内存池的大小
6. static const std::size_t DEFAULT_MEMORY_CHUNK_SIZE = 128;//Chunk的大小
7. static const std::size_t DEFAULT_MEMORY_SIZE_TO_ALLOCATE = DEFAULT_MEMORY_CHUNK_SIZE * 2;
9. class CMemoryPool : public IMemoryBlock
10. {
11. public:
12.     CMemoryPool(const std::size_t &sInitialMemoryPoolSize = DEFAULT_MEMORY_POOL_SIZE,
13.                 const std::size_t &sMemoryChunkSize = DEFAULT_MEMORY_CHUNK_SIZE,
14.                 const std::size_t &sMinimalMemorySizeToAllocate = DEFAULT_MEMORY_SIZE_TO_ALLOCATE,
15.                 bool bSetMemoryData = false
16.                 );
    
17.     virtual ~CMemoryPool();
18.     //从内存池中申请内存
19.     virtual void* GetMemory(const std::size_t &sMemorySize);
20.     virtual void FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize);
    
21. private:
22.     //申请内存OS
23.     bool AllocateMemory(const std::size_t &sMemorySize);
24.     void FreeAllAllocatedMemory();
25.     SMemoryChunk* FindChunkHoldingPointerTo(void *ptrMemoryBlock);
26.     void FreeChunks(SMemoryChunk *ptrChunk);
    
27.     //计算可以分多少块
28.   unsigned int CalculateNeededChunks(const std::size_t &sMemorySize);
    
29.     //计算内存池最合适的大小
30.     std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize); 
    
31.     //建立链表.每个结点Data指针指向内存池中的内存地址
32.     bool LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock);
34.    //重新计算块(Chunk)的大小1024--896--768--640--512------------
35.     bool RecalcChunkMemorySize(SMemoryChunk* ptrChunk, unsigned int uiChunkCount);  
36.     SMemoryChunk* SetChunkDefaults(SMemoryChunk *ptrChunk); 
    
37.     //搜索链表找到一个能够持有被申请大小的内存块(Chunk).如果它返回NULL，那么在内存池中没有可用的内存
38.     SMemoryChunk* FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize);
39.     std::size_t MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const; 
40.     void SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize);
41.    SMemoryChunk* SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip);    
42.     void DeallocateAllChunks();
43. private:
44.     SMemoryChunk *m_ptrFirstChunk;
45.     SMemoryChunk *m_ptrLastChunk;
46.     SMemoryChunk *m_ptrCursorChunk;
48.     std::size_t m_sTotalMemoryPoolSize; //内存池的总大小
49.     std::size_t m_sUsedMemoryPoolSize; //以使用内存的大小
50.     std::size_t m_sFreeMemoryPoolSize; //可用内存的大小
51.     std::size_t m_sMemoryChunkSize; //块(Chunk)的大小    
52.      unsigned int m_uiMemoryChunkCount; //块(Chunk)的数量
53.     unsigned int m_uiObjectCount;
54.     bool m_bSetMemoryData ;
55.     std::size_t m_sMinimalMemorySizeToAllocate;
56. };
57. #endif

CMemoryPool.cpp 

1. #include "stdafx.h"
2. #include "CMemorypool.h"
3. #include <math.h>
4. #include <assert.h>
5. static const int FREEED_MEMORY_CONTENT = 0xAA;//填充释放的内存
6. static const int NEW_ALLOCATED_MEMORY_CONTENT = 0xFF;
   
7. CMemoryPool::CMemoryPool(const std::size_t &sInitialMemoryPoolSize,
8.                          const std::size_t &sMemoryChunkSize,
9.                          const std::size_t &sMinimalMemorySizeToAllocate,
10.                          bool bSetMemoryData)
11. {
12.     m_ptrFirstChunk = NULL;
13.     m_ptrLastChunk = NULL;
14.     m_ptrCursorChunk = NULL;
15.     m_sTotalMemoryPoolSize = 0;
16.     m_sUsedMemoryPoolSize = 0;
17.     m_sFreeMemoryPoolSize = 0;
18.      m_sMemoryChunkSize = sMemoryChunkSize;
19.     m_uiMemoryChunkCount = 0;
20.     m_uiObjectCount = 0;
21.     m_bSetMemoryData = !bSetMemoryData;
22.     m_sMinimalMemorySizeToAllocate = sMinimalMemorySizeToAllocate;
24.     AllocateMemory(sInitialMemoryPoolSize);
25. }
    
26. CMemoryPool::~CMemoryPool()
27. {
28.     FreeAllAllocatedMemory();
29.     DeallocateAllChunks();
30.     assert((m_uiObjectCount == 0) && "警告:内存-泄露:你没有释放全部申请的内存");
31. }
    
32. void CMemoryPool::FreeAllAllocatedMemory()
33. {
34.     SMemoryChunk *ptrChunk = m_ptrFirstChunk;
35.     while(ptrChunk)
36.     {
37.         if(ptrChunk->IsAllocationChunk)
38.         {
39.             free(((void *) (ptrChunk->Data)));
40.         }
41.         ptrChunk = ptrChunk->Next;
42.     }
43. }
45. void CMemoryPool::DeallocateAllChunks()
46. {
47.     SMemoryChunk *ptrChunk = m_ptrFirstChunk;
48.     SMemoryChunk *ptrChunkToDelete = NULL;
49.     while(ptrChunk)
50.     {
51.         if(ptrChunk->IsAllocationChunk)
52.         {
53.             if(ptrChunkToDelete)
54.             {
55.                 free(((void *) ptrChunkToDelete));
56.             }
57.             ptrChunkToDelete = ptrChunk;       
58.         }
    
59.         ptrChunk = ptrChunk->Next;
60.     }
61. }
63. void* CMemoryPool::GetMemory(const std::size_t &sMemorySize)
64. {
65.     std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);
66.     SMemoryChunk* ptrChunk = NULL;
    
67.     while(!ptrChunk)
68.     {
69.         ptrChunk = FindChunkSuitableToHoldMemory(sBestMemBlockSize);
    
70.         //ptrChunk等于NULL表示内存池内存不够用
71.         if(!ptrChunk)
72.         {
73.             sBestMemBlockSize = MaxValue(sBestMemBlockSize, CalculateBestMemoryBlockSize(m_sMinimalMemorySizeToAllocate));
74.             //从OS申请更多的内存
75.             AllocateMemory(sBestMemBlockSize);
76.         }
77.     }
    
78.     //下面是找到可用的块(Chunk)代码
79.     m_sUsedMemoryPoolSize += sBestMemBlockSize;
80.     m_sFreeMemoryPoolSize -= sBestMemBlockSize;
81.     m_uiObjectCount++;
    
82.     //标记该块(Chunk)已用
83.     SetMemoryChunkValues(ptrChunk, sBestMemBlockSize);
85.     return ((void *) ptrChunk->Data);
86. }
    
87. void CMemoryPool::FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize)
    {
88.     SMemoryChunk *ptrChunk = FindChunkHoldingPointerTo(ptrMemoryBlock);
89.     if(ptrChunk)
90.     {
91.         FreeChunks(ptrChunk);
92.     }
93.     else
94.     {
95.         assert(false && "ERROR : Requested Pointer not in Memory Pool");
96.     }
        assert((m_uiObjectCount > 0) && "ERROR : Request to delete more Memory then allocated.");
        m_uiObjectCount--;
97. }
99. void CMemoryPool::FreeChunks(SMemoryChunk *ptrChunk)
100. {
101.     SMemoryChunk *ptrCurrentChunk = ptrChunk ;
102.     unsigned int uiChunkCount = CalculateNeededChunks(ptrCurrentChunk->UsedSize);
103.     for(unsigned int i = 0; i < uiChunkCount; i++)
104.     {
105.         if(ptrCurrentChunk)
106.         {
107.             if(m_bSetMemoryData)
108.             {
109.                 memset(((void *) ptrCurrentChunk->Data), FREEED_MEMORY_CONTENT, m_sMemoryChunkSize) ;
110.             }
111.             ptrCurrentChunk->UsedSize = 0;
                m_sUsedMemoryPoolSize -= m_sMemoryChunkSize;
112.             ptrCurrentChunk = ptrCurrentChunk->Next;
113.         }
114.     }
115. }
     
116. SMemoryChunk *CMemoryPool::FindChunkHoldingPointerTo(void *ptrMemoryBlock)
117. {
         SMemoryChunk *ptrTempChunk = m_ptrFirstChunk;
     
118.     while(ptrTempChunk)
119.     {
120.         if(ptrTempChunk->Data == ((TByte *) ptrMemoryBlock))
121.         {
122.             break;
123.         }
124.         ptrTempChunk = ptrTempChunk->Next;
125.     }
126.     return ptrTempChunk;
127. }
     
128. bool CMemoryPool::AllocateMemory(const std::size_t &sMemorySize)
129. {
130.     //计算可以分多少块(1000 / 128 = 8)
131.     unsigned int uiNeededChunks = CalculateNeededChunks(sMemorySize);
     
132.     //当内存池的初始大小为1000字节，块(Chunk)大小128字节，分8块还差24字节.怎么办?
133.     //解决方案:多申请24字节
134.     std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize);
135.     
136.      //向OS申请内存
137.     TByte *ptrNewMemBlock = (TByte*) malloc(sBestMemBlockSize);
     
138.     //分配一个结构体SmemoryChunk的数组来管理内存块
139.     SMemoryChunk *ptrNewChunks = (SMemoryChunk*) malloc((uiNeededChunks * sizeof(SMemoryChunk)));
     
140.     m_sTotalMemoryPoolSize += sBestMemBlockSize;
141.     m_sFreeMemoryPoolSize += sBestMemBlockSize;
142.     m_uiMemoryChunkCount += uiNeededChunks;
     
143.     if(m_bSetMemoryData)
144.     {
145.         memset(((void *) ptrNewMemBlock), NEW_ALLOCATED_MEMORY_CONTENT, sBestMemBlockSize);
146.     }
     
147.     return LinkChunksToData(ptrNewChunks, uiNeededChunks, ptrNewMemBlock);
148. }
     
149. unsigned int CMemoryPool::CalculateNeededChunks(const std::size_t &sMemorySize)
     {
         float f = (float) (((float)sMemorySize) / ((float)m_sMemoryChunkSize));
150.     return ((unsigned int) ceil(f));
151. }
     
152. std::size_t CMemoryPool::CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize)
153. {
154.     unsigned int uiNeededChunks = CalculateNeededChunks(sRequestedMemoryBlockSize);
155.     return std::size_t((uiNeededChunks * m_sMemoryChunkSize));
156. }
     
157. bool CMemoryPool::LinkChunksToData(SMemoryChunk* ptrNewChunks, unsigned int uiChunkCount, TByte* ptrNewMemBlock)
     {
158.     SMemoryChunk *ptrNewChunk = NULL;
159.     unsigned int uiMemOffSet = 0;
160.     bool bAllocationChunkAssigned = false;
161.     for(unsigned int i = 0; i < uiChunkCount; i++)
162.     {
163.         //建立链表
164.         if(!m_ptrFirstChunk)
165.         {
166.             m_ptrFirstChunk = SetChunkDefaults(&(ptrNewChunks[0]));
167.             m_ptrLastChunk = m_ptrFirstChunk;
168.             m_ptrCursorChunk = m_ptrFirstChunk;
169.         }
170.         else
171.         {
172.             ptrNewChunk = SetChunkDefaults(&(ptrNewChunks[i]));
173.             m_ptrLastChunk->Next = ptrNewChunk;
174.             m_ptrLastChunk = ptrNewChunk;
175.         }
     
176.         //根据块(Chunk)的大小计算下一块的内存偏移地址
177.         uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize));
     
178.         //结点指向内存偏移地址
179.         m_ptrLastChunk->Data = &(ptrNewMemBlock[uiMemOffSet]);
     
180.         if(!bAllocationChunkAssigned)
181.         {
182.             m_ptrLastChunk->IsAllocationChunk = true;
183.             bAllocationChunkAssigned = true;
184.         }
185.     }
     
186.     return RecalcChunkMemorySize(m_ptrFirstChunk, m_uiMemoryChunkCount);
187. }
     
188. bool CMemoryPool::RecalcChunkMemorySize(SMemoryChunk *ptrChunk, unsigned int uiChunkCount)
189. {
190.     unsigned int uiMemOffSet = 0 ;
191.     for(unsigned int i = 0; i < uiChunkCount; i++)
192.     {
193.         if(ptrChunk)
194.         {
195.             uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize)) ;
196.             ptrChunk->DataSize = (((unsigned int) m_sTotalMemoryPoolSize) - uiMemOffSet);
197.             ptrChunk = ptrChunk->Next;
198.         }
199.         else
200.         {
201.             assert(false && "Error : ptrChunk == NULL");
202.             return false;
203.         }
204.     }
205.     return true;
206. }
     
207. SMemoryChunk* CMemoryPool::SetChunkDefaults(SMemoryChunk* ptrChunk)
208. {
         if(ptrChunk)
209.     {
210.         ptrChunk->Data = NULL;
211.         ptrChunk->DataSize = 0;
212.         ptrChunk->UsedSize = 0;
213.         ptrChunk->IsAllocationChunk = false;
214.         ptrChunk->Next = NULL;
215.     }
216.     return ptrChunk;
217. }
     
218. //这里还没看明白
219. SMemoryChunk *CMemoryPool::FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize)
220. {
221.     unsigned int uiChunksToSkip = 0;
222.     bool bContinueSearch = true;
223.     SMemoryChunk *ptrChunk = m_ptrCursorChunk;
224.     for(unsigned int i = 0; i < m_uiMemoryChunkCount; i++)
         {
             if(ptrChunk)
             {
                 if(ptrChunk == m_ptrLastChunk)
                 {
                     ptrChunk = m_ptrFirstChunk;
                 }
     
225.             if(ptrChunk->DataSize >= sMemorySize)
                 {
                     if(ptrChunk->UsedSize == 0)
                     {
                         m_ptrCursorChunk = ptrChunk;
                         return ptrChunk;
                     }
226.             }
227.             uiChunksToSkip = CalculateNeededChunks(ptrChunk->UsedSize);
228.             if(uiChunksToSkip == 0)
229.                   uiChunksToSkip = 1;
     
230.             ptrChunk = SkipChunks(ptrChunk, uiChunksToSkip);
231.         }
232.         else
233.         {
234.             bContinueSearch = false;
235.         }
236.     }
237.     return NULL;
238. }
     
239. std::size_t CMemoryPool::MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const
240. {
241.     if(sValueA > sValueB)
242.     {
243.         return sValueA;
244.     }
245.     return sValueB;
246. }
     
247. void CMemoryPool::SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize)
248. {
249.     if((ptrChunk))
250.     {
251.         ptrChunk->UsedSize = sMemBlockSize;
252.     }
253.     else
254.     {
255.         assert(false && "Error : Invalid NULL-Pointer passed");
256.     }
257. }
     
258. SMemoryChunk *CMemoryPool::SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip)
259. {
260.     SMemoryChunk *ptrCurrentChunk = ptrStartChunk;
261.     for(unsigned int i = 0; i < uiChunksToSkip; i++)
262.     {
263.         if(ptrCurrentChunk)
264.         {
265.             ptrCurrentChunk = ptrCurrentChunk->Next;
266.         }
267.         else
268.         {
269.             assert(false && "Error : Chunk == NULL was not expected.");
270.             break ;
271.         }
272.     }
273.     return ptrCurrentChunk;
274. }

测试方法:

1. // 111.cpp : 定义控制台应用程序的入口点。
   #include "stdafx.h"
   #include "CMemoryPool.h"
   
2. CMemoryPool* g_pMemPool = NULL;
3. 
   class testMemoryPool
4. {
5. public:
6.     testMemoryPool(){
7.     }
8.     virtual ~testMemoryPool(){
9.     }
10.     void *operator new(std::size_t ObjectSize)
11.     {
12.         return g_pMemPool->GetMemory(ObjectSize) ;
        }
    
13.     void operator delete(void *ptrObject, std::size_t ObjectSize)
14.     {
15.         g_pMemPool->FreeMemory(ptrObject, ObjectSize) ;
16.     }
    
17. public:
18.     char a[512];
19.     bool b;
20.     long c;
21. };//sizeof(32);
    
23. int _tmain(int argc, _TCHAR* argv[])
    {
        g_pMemPool = new CMemoryPool();
        testMemoryPool* test = new testMemoryPool();
24.     if(test){
25.         delete test;
26.         test = NULL;
27.     }
    
28.     if(g_pMemPool)
29.         delete g_pMemPool ;
        return 0;
30. }