linux c++ 内存池的简单实现

http://www.codeproject.com/KB/cpp/MemoryPool.aspx

http://www.cnblogs.com/rosesmall/archive/2012/04/27/2473931.html

译者点评：一个简单的内存池实现，附有源码，简单易懂，适合入门。

 

概述

在c/c++中，内存分配（如malloc或new）会使用很多时间。

一个程序会随着长时间的运行和内存的申请释放而变得越来越慢，内存也会随着时间逐渐碎片化。特别是高频率的进行小内存申请释放，此问题变得尤其严重。

 

解决方案：定制内存池

为解决上述问题，一个(可能的)的解决方案就是使用内存池。

 

“内存池”在初始化时，分配一个大块内存（称 原始内存块），并且将此内存分割为一些小的内存块。当你需要请求分配内存时，则从内存池中取出事先分配好的内存，而不是向OS申请。内存池最大的优势在于：

1、极少的（甚至没有）堆碎片整理

2、较之普通内存分配(如malloc,new)，有着更快的速度

 

额外的，你还将获得如下好处：

1、检测任意的指针是否指向内存池内

2、生成"heap-dump"

3、各种 内存泄漏 检测：当你没有释放之前申请的内存，内存池将抛出断言

 

如何工作？

让我们看看内存池的UML模型图：

图中简要的描述了CMemoryPool class，更多的细节请查看源码中class声明。

 

那么，CMemoryPool如何实际工作？

 

关于 MemoryChunks

正如你在UML图中所看到的，内存池维护着一个SMemoryChunk链表，并管理着三个指向SMemoryChunk结构的指针(m_ptrFirstChunk, m_ptrLastChunk, and m_ptrCursorChunk)。这些指针指向SMemoryChunk链表的不同位置。让我们更深入的观察SMemoryChunk：(在内存池实现中，SMemoryChunk封装了原始内存块的各个部分 -- 译者注)

typedef struct SMemoryChunk

{

  TByte *Data ;             // 常规数据指针

  std::size_t DataSize ;    // 内存块容量

  std::size_t UsedSize ;    // 内存块当前使用大小

  bool IsAllocationChunk ;  // 为true时, 内存块已被分配，可用free之类的函数释放

  SMemoryChunk *Next ;      // 指向内存块链表中的下一个内存块，可能为null

第一步：预分配内存

当你调用CMemoryPool的构造函数，内存池会向OS申请原始内存块。

/******************

Constructor

******************/

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 ;

  // Allocate the Initial amount of Memory from the Operating-System...

  AllocateMemory(sInitialMemoryPoolSize) ;

}

所有的成员的函数初始化在此完成，最后AllocateMemory将完成向OS申请原始内存块的任务。

/******************

AllocateMemory

******************/

<CODE>bool CMemoryPool::AllocateMemory(const std::size_t &sMemorySize)

{

  std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize) ;

  // allocate from Operating System

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

  ...

那么，内存池如何来管理这些数据呢？

第二步：内存分块

回忆前述，内存池管理使用SMemoryChunk链表来管理数据。在向OS申请原始内存块后，

我们还没有在其上建立SMemoryChunk。

图中所示的为初始化分配后的内存池。

我们需要分配一组SMemoryChunk，用于管理原始内存块:

//(AllocateMemory() continued) : 

  ...

  unsigned int uiNeededChunks = CalculateNeededChunks(sMemorySize) ;

  // allocate Chunk-Array to Manage the Memory

  SMemoryChunk *ptrNewChunks = 

    (SMemoryChunk *) malloc((uiNeededChunks * sizeof(SMemoryChunk))) ;

  assert(((ptrNewMemBlock) && (ptrNewChunks)) 

                           && "Error : System ran out of Memory") ;

  ...

CalculateNeededChunks函数用于计算需要分配的SMemoryChunk的数量。分配后，ptrNewChunks指向这组SMemoryChunk。注意，SMemoryChunk中目前只是持有垃圾数据，我们还没有为SMemoryChunk的成员关联至原始内存块。

 

最后，AllocateMemory函数将为所有的SMemoryChunk关联至原始内存块。

//(AllocateMemory() continued) : 

  ...

  // Associate the allocated Memory-Block with the Linked-List of MemoryChunks

  return LinkChunksToData(ptrNewChunks, uiNeededChunks, ptrNewMemBlock) ;

让我们进入LinkChunksToData中一窥究竟：

/******************

LinkChunksToData

******************/

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 ;

    }

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

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

    //　第一个SMemoryChunk被称为“AllocationChunk”。

    // 这意味着,它持有原始内存块的指针并能够利用它释放原始内存块

    if(!bAllocationChunkAssigned)

    {

      m_ptrLastChunk->IsAllocationChunk = true ;

      bAllocationChunkAssigned = true ;

    }

  }

  return RecalcChunkMemorySize(m_ptrFirstChunk, m_uiMemoryChunkCount) ;

}

让我们一步步的来看这个重要的函数：第一行检查在SMemoryChunk链表中是否已经有了可用的

SMemoryChunk：

  ...

  if(!m_ptrFirstChunk)

  ...

在最初始进入循环，此条件不成立。那么，我们为一些内部的成员进行关联。

 ...

  m_ptrFirstChunk = SetChunkDefaults(&(ptrNewChunks[0])) ;

  m_ptrLastChunk = m_ptrFirstChunk ;

  m_ptrCursorChunk = m_ptrFirstChunk ;

  ...

m_ptrFirstChunk这时指向SMemoryChunk中的第一个元素。每一个SMemoryChunk管理的内存块大小由m_sMemoryChunkSize指定。这些内存块来自于原始内存块，偏移量

uiMemOffSet指示着每一个SMemoryChunk所管理的内存起始点处于原始内存块的何处。

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

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

额外的，每个新的SMemoryChunk都将被指定为新的m_ptrLastChunk。

  ...

  m_ptrLastChunk->Next = ptrNewChunk ;

  m_ptrLastChunk = ptrNewChunk ;

  ...

经过循环之后，内存池中的SMemoryChunk链表将被成功的与原始内存块关联。

最终，我们重新计算每一个SMemoryChunk能管理到的内存尺寸。这个步骤相当耗时，并且必须在每次从ＯＳ附加新的内存到内存池后调用。所有被计算出的尺寸，将被DataSize成员持有。

/******************

RecalcChunkMemorySize

******************/

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 ;

}

在RecalcChunkMemorySize之后，每一个SMemoryChunk将知道自己需要释放多大的内存。因此，这使得 确定某个SMemoryChunk能否持有一个指定大小的内存 将变得非常容易：当DataSize成员大于或等于请求的内存尺寸并且UsedSize成员值为0，这时此SMemoryChunk将能够满足用户的需要。让我们来看一个具体的例子来加深对这个机制的理解，假设内存池为600字节，并且每个SMemoryChunk为100字节。

 

第三步：向内存池请求内存

现在，如果用户向内存池请求内存，那会发生什么呢？最开始，所有的SMemoryChunk在内存池中都是闲置可用状态：

让我们看看GetMemory函数吧：

/******************

GetMemory

******************/

void *CMemoryPool::GetMemory(const std::size_t &sMemorySize)

{

  std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize) ;  

  SMemoryChunk *ptrChunk = NULL ;

  while(!ptrChunk)

  {

    // 搜索是否有符合条件的SMemoryChunk？

    ptrChunk = FindChunkSuitableToHoldMemory(sBestMemBlockSize) ;

    if(!ptrChunk)

    {

	  // 没有SMemoryChunk符合条件

	  // 内存池太小了，需要向OS申请新的内存

	  sBestMemBlockSize = MaxValue(sBestMemBlockSize, CalculateBestMemoryBlockSize(m_sMinimalMemorySizeToAllocate)) ;

      AllocateMemory(sBestMemBlockSize) ;

    }

  }

  // 一个合适的SMemoryChunk被找到

  // 校正其 TotalSize/UsedSize 成员的值

  m_sUsedMemoryPoolSize += sBestMemBlockSize ;

  m_sFreeMemoryPoolSize -= sBestMemBlockSize ;

  m_uiObjectCount++ ;

  SetMemoryChunkValues(ptrChunk, sBestMemBlockSize) ;

  // 最终将内存指针返回给用户

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

}

当用户向内存池发出请求，内存池搜索SMemoryChunk链表，并在其中找到满足条件的SMemoryChunk，“满足条件”意味着：

1、DataSize必须大于或等于请求的大小

2、UsedSize必须为0

FindChunkSuitableToHoldMemory如果其返回NULL，那么就表示在内存池中没有可用的内存。这将会引发AllocateMemory函数的调用（前述），此函数会向OS申请更多的内存。

如果返回非NULL，那么便找到了可用的SMemoryChunk。

 

示例

假设，用户向内存池申请２５０字节：

如你所见，每一个SMemoryChunk管理１００字节，所以，２５０字节并不是１００的整数倍。这会引发什么情况呢？GetMemory将会返回指向第一个SMemoryChunk的指针，并设置其的UsedSize成员为300字节，因为300是100的整数倍数值中最小的，并且其大于250。多出的50字节称为"memory overhead".

当FindChunkSuitableToHoldMemory寻找可用的SMemoryChunk时，它将只会从一个闲置的SMemoryChunk跳到另一个闲置的SMemoryChunk。这意味着，如果又有申请内存的请求达到，例子中的第四个SMemoryChunk将是寻找的起始点。

 

如何使用代码

代码的使用简单而直接：

只需要在你的程序中包含"CMemoryPool.h"，并附加源码文件至你的IDE/makefile：

• CMemoryPool.h
• CMemoryPool.cpp
• IMemoryBlock.h
• SMemoryChunk.h

你需要创建一个CMemoryPool实例，并从中分配内存。所有的内存池配置都在CMemoryPool的构造函数中被完成。

 

使用示例

MemPool::CMemoryPool *g_ptrMemPool = new MemPool::CMemoryPool() ;

char *ptrCharArray = (char *) g_ptrMemPool->GetMemory(100) ;

...

g_ptrMemPool->FreeMemory(ptrCharArray, 100) ;

delete g_ptrMemPool ;

兴趣点

内存诊断

你可以调用WriteMemoryDumpToFile函数来输出内存诊断信息文件。让我们看下源码附带的MyTestClass_OPOverload类的构造函数。（此类重载了new和delete操作，使用了内存池操作）

	MyTestClass_OPOverload()

	{

	  m_cMyArray[0] = 'H' ;

	  m_cMyArray[1] = 'e' ;

	  m_cMyArray[2] = 'l' ;

	  m_cMyArray[3] = 'l' ;

	  m_cMyArray[4] = 'o' ;

	  m_cMyArray[5] = NULL ;

	  m_strMyString = "This is a small Test-String" ;

	  m_iMyInt = 12345 ;

	  m_fFloatValue = 23456.7890f ;

      m_fDoubleValue = 6789.012345 ;

      Next = this ;

	}

MyTestClass *ptrTestClass = new MyTestClass ; 

g_ptrMemPool->WriteMemoryDumpToFile("MemoryDump.bin") ;

让我们看看内存诊断文件的内容：

如你所见，这是MyTestClass_OPOverload所有的成员在内存中的表示。

速度测试

我在windows下完成了一个简单的速度测试（使用timeGetTime()），结果显示内存池的使用可以大大增加程序的速度。所有的测试均使用vs2003，debug模式编译（测试机器：Intel Pentium IV Processor (32 bit), 1GB RAM, MS Windows XP Professional）

//Array-test (Memory Pool): 

for(unsigned int j = 0; j < TestCount; j++)

{

    // ArraySize = 1000

    char *ptrArray = (char *) g_ptrMemPool->GetMemory(ArraySize)  ;

    g_ptrMemPool->FreeMemory(ptrArray, ArraySize) ;

}

//Array-test (Heap): 

for(unsigned int j = 0; j < TestCount; j++)

{

    // ArraySize = 1000

    char *ptrArray = (char *) malloc(ArraySize)  ;

    free(ptrArray) ;

}

//Class-Test for MemoryPool and Heap (重载了new与delete)

for(unsigned int j = 0; j < TestCount; j++)

{

    MyTestClass *ptrTestClass = new MyTestClass ;

    delete ptrTestClass ;

}

 

关于代码

代码在ms windows与linux的如下c++编译器通过测试：

• Microsoft Visual C++ 6.0
• Microsoft Visual C++ .NET 2003
• MinGW (GCC) 3.4.4 (Windows)
• GCC 4.0.X (Debian GNU Linux)

vc6.0的项目文件与vs2003的项目文件已经包含在源码中。在64位的环境下使用应该没有问题。

注意：此内存池并非线程安全的。

 

待办事项

此内存池实现远远不够完善，待办事项如下：

1、对于海量的内存，memory overhead可能很大

2、一些CalculateNeededChunks函数的调用可以通过重构某些函数来被剥离，之后速度可能会更快。

3、更多的稳定性测试(尤其是对长时间运行的程序)

4、线程安全的实现

 

以下代码是在linux环境下编译调试过的：

BasicIncludes.h

/******************
BasicIncludes.h
******************/

/*!\file BasicIncludes.h
 * \brief Contains some Basic Include-files used almost everywhere
 *        (like iostream, assert, stdlib, etc.).
 */

#ifndef __INC_BasicIncludes_h__
#define __INC_BasicIncludes_h__

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>

#include <iostream>
#include <fstream>

// for MSVC++ 6.0
/*
namespace std
{
    typedef unsigned int size_t ;
}
*/

#endif /* __INC_BasicIncludes_h__ */

IMemoryBlock.h

/******************
IMemoryBlock.h
******************/

/*!\file IMemoryBlock.h
 * \brief Contains the "IMemoryBlock" Class-defintion.
 *        This is the (abstract) interface for the actual MemoryPool-Class.
 */


#ifndef __INC_IMemoryBlock_h__
#define __INC_IMemoryBlock_h__

#include "../BasicIncludes.h"

/*!\namespace MemPool
 * \brief MemoryPool Namespace
 *
 * This Namespace contains all classes and typedefs needed by
 * the MemoryPool implementation.
 * The MemoryPool has its own namespace because some typedefs
 * (e.g. TByte) may intefer with other toolkits if the
 * MemoryPool would be in the global namespace.
 */
namespace MemPool
{

/*!\typedef unsigned char TByte ;
 * \brief Byte (= 8 Bit) Typedefinition.
 */
typedef unsigned char TByte ;

/*!\class IMemoryBlock
 * \brief Interface Class (pure Virtual) for the MemoryPool
 *
 * Abstract Base-Class (interface) for the MemoryPool.
 * Introduces Basic Operations like Geting/Freeing Memory.
 */
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 /* __INC_IMemoryBlock_h__ */

SMemoryChunk.h

/******************
SMemoryChunk.h
******************/

/*!\file SMemoryChunk.h
 * \brief Contains the "SMemoryChunk" Type-definition.
 */

#ifndef __INC_SMemoryChunk_h__
#define __INC_SMemoryChunk_h__

#include "IMemoryBlock.h"

namespace MemPool
{

/*!\class SMemoryChunk
 * \brief Memory Chunk Struct
 *
 * This struct will hold (and manage) the actual allocated Memory.
 * Every MemoryChunk will point to a MemoryBlock, and another SMemoryChunk,
 * thus creating a linked-list of MemoryChunks.
 */
typedef struct SMemoryChunk
{
  TByte *Data ;                //!< The actual Data
  std::size_t DataSize ;    //!< Size of the "Data"-Block
  std::size_t UsedSize ;    //!< actual used Size
  bool IsAllocationChunk ;    //!< true, when this MemoryChunks Points to a "Data"-Block which can be deallocated via "free()"
  SMemoryChunk *Next ;        //!< Pointer to the Next MemoryChunk in the List (may be NULL)

} SMemoryChunk ;

}

#endif /* __INC_SMemoryChunk_h__ */

CMemoryPool.h

/******************
CMemoryPool.h
******************/

/*!\file CMemoryPool.h
 * \brief Contains the "CMemoryPool" Class-defintion.
 */

#ifndef __INC_CMemoryPool_h__
#define __INC_CMemoryPool_h__

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

namespace MemPool
{

static const std::size_t DEFAULT_MEMORY_POOL_SIZE        = 1000 ;                          //!< Initial MemoryPool size (in Bytes)
static const std::size_t DEFAULT_MEMORY_CHUNK_SIZE       = 128 ;                           //!< Default MemoryChunkSize (in Bytes)
static const std::size_t DEFAULT_MEMORY_SIZE_TO_ALLOCATE = DEFAULT_MEMORY_CHUNK_SIZE * 2 ; //!< Default Minimal Memory-Size (in Bytes) to Allocate. 

/*!\class CMemoryPool
 * \brief MemoryPool-Class
 *
 * This class is the actual implementation of the IMemoryBlock - Interface.
 * It is responsible for all MemoryRequests (GetMemory() / FreeMemory()) and
 * manages the allocation/deallocation of Memory from the Operating-System.
 */
class CMemoryPool : public IMemoryBlock
{
  public :
    /*!
    Contructor
    \param [IN] sInitialMemoryPoolSize The Initial Size (in Bytes) of the Memory Pool
    \param [IN] sMemoryChunkSize The Size (in Bytes) each MemoryChunk can Manage. 
                A low sMemoryChunkSize increases the MemoryPool runtime (bad), but decreases the Memory-overhead/fragmentation (good)
    \param [IN] sMinimalMemorySizeToAllocate The Minimal amount of Memory which is allocated (in Bytes).
                That means, every time you have to allocate more Memory from the Operating-System,
                <b>at least</b> sMinimalMemorySizeToAllocate Bytes are allocated.
                When you have to request small amount of Memory very often, this will speed up
                the MemoryPool, beacause when you allocate a new Memory from the OS,
                you will allocate a small "Buffer" automatically, wich will prevent you from
                requesting OS-memory too often.
    \param [IN] bSetMemoryData Set to true, if you want to set all allocated/freed Memory to a specific
                Value. Very usefull for debugging, but has a negativ impact on the runtime.
    */
    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() ; //!< Destructor

    /*!
      Get "sMemorySize" Bytes from the Memory Pool.
      \param [IN] sMemorySize       Sizes (in Bytes) of Memory.
      \return                       Pointer to a Memory-Block of "sMemorySize" Bytes, or NULL if an error occured. 
    */
    virtual void *GetMemory(const std::size_t &sMemorySize) ;
    
    /*!
      Free the allocated memory again....
      \param [IN] ptrMemoryBlock    Pointer to a Block of Memory, which is to be freed (previoulsy allocated via "GetMemory()").
      \param [IN] sMemorySize       Sizes (in Bytes) of Memory.
    */
    virtual void FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize) ;

    /*!
      Writes the contents of the MemoryPool to a File.
      Note : This file can be quite large (several MB).
      \param [IN] strFileName      FileName of the MemoryDump.
      \return                      true on success, false otherwise 
    */
    bool WriteMemoryDumpToFile(const std::string &strFileName) ;
    /*!
      Check, if a Pointer is in the Memory-Pool.
      Note : This Checks only if a pointer is inside the Memory-Pool,
             and <b>not</b> if the Memory contains meaningfull data.
      \param [IN] ptrPointer       Pointer to a Memory-Block which is to be checked.
      \return                      true, if the Pointer could be found in the Memory-Pool, false otherwise.
    */
    bool IsValidPointer(void *ptrPointer) ;
 
  private :
    /*!
      Will Allocate <b>at least</b> "sMemorySize" Bytes of Memory from the Operating-System.
      The Memory will be cut into Pieces and Managed by the MemoryChunk-Linked-List.
      (See LinkChunksToData() for details).
      \param [IN] sMemorySize      The Memory-Size (in Bytes) to allocate
      \return                      true, if the Memory could be allocated, false otherwise (e.g. System is out of Memory, etc.)
    */
    bool AllocateMemory(const std::size_t &sMemorySize) ;
    void FreeAllAllocatedMemory() ; //!< Will free all Aloocated Memory to the Operating-System again.

    unsigned int CalculateNeededChunks(const std::size_t &sMemorySize) ; //!< \return the Number of MemoryChunks needed to Manage "sMemorySize" Bytes.
    std::size_t CalculateBestMemoryBlockSize(const std::size_t &sRequestedMemoryBlockSize) ; //!< return the amount of Memory which is best Managed by the MemoryChunks.

    SMemoryChunk *FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize) ; //!< \return a Chunk which can hold the requested amount of memory, or NULL, if none was found.
    SMemoryChunk *FindChunkHoldingPointerTo(void *ptrMemoryBlock) ; //!< Find a Chunk which "Data"-Member is Pointing to the given "ptrMemoryBlock", or NULL if none was found.

    SMemoryChunk *SkipChunks(SMemoryChunk *ptrStartChunk, unsigned int uiChunksToSkip) ; //!< Skip the given amount of Chunks, starting from the given ptrStartChunk. \return the Chunk at the "skipping"-Position.
    SMemoryChunk *SetChunkDefaults(SMemoryChunk *ptrChunk) ; //!< Set "Default"-Values to the given Chunk

    void FreeChunks(SMemoryChunk *ptrChunk) ; //!< Makes the memory linked to the given Chunk available in the MemoryPool again (by setting the "UsedSize"-Member to 0).
    void DeallocateAllChunks() ; //!< Deallocates all Memory needed by the Chunks back to the Operating-System.

    bool LinkChunksToData(SMemoryChunk *ptrNewChunk, unsigned int uiChunkCount, TByte *ptrNewMemBlock) ; //!< Link the given Memory-Block to the Linked-List of MemoryChunks...
    void SetMemoryChunkValues(SMemoryChunk *ptrChunk, const std::size_t &sMemBlockSize) ; //!< Set the "UsedSize"-Member of the given "ptrChunk" to "sMemBlockSize".
    bool RecalcChunkMemorySize(SMemoryChunk *ptrChunks, unsigned int uiChunkCount) ; //!< Recalcs the "DataSize"-Member of all Chunks whe the Memory-Pool grows (via "AllocateMemory()")

    std::size_t MaxValue(const std::size_t &sValueA, const std::size_t &sValueB) const ; //!< \return the greatest of the two input values (A or B)
    
    SMemoryChunk *m_ptrFirstChunk ;  //!< Pointer to the first Chunk in the Linked-List of Memory Chunks
    SMemoryChunk *m_ptrLastChunk ;   //!< Pointer to the last Chunk in the Linked-List of Memory Chunks
    SMemoryChunk *m_ptrCursorChunk ; //!< Cursor-Chunk. Used to speed up the navigation in the linked-List.

    std::size_t m_sTotalMemoryPoolSize ;  //!< Total Memory-Pool size in Bytes
    std::size_t m_sUsedMemoryPoolSize ;   //!< amount of used Memory in Bytes
    std::size_t m_sFreeMemoryPoolSize ;   //!< amount of free Memory in Bytes

    std::size_t m_sMemoryChunkSize ;     //!< amount of Memory which can be Managed by a single MemoryChunk.
    unsigned int m_uiMemoryChunkCount ;  //!< Total amount of "SMemoryChunk"-Objects in the Memory-Pool.
    unsigned int m_uiObjectCount ;       //!< Counter for "GetMemory()" / "FreeMemory()"-Operation. Counts (indirectly) the number of "Objects" inside the mem-Pool.

    bool m_bSetMemoryData ;                      //!< Set to "true", if you want to set all (de)allocated Memory to a predefined Value (via "memset()"). Usefull for debugging.
    std::size_t m_sMinimalMemorySizeToAllocate ; //!< The minimal amount of Memory which can be allocated via "AllocateMemory()".
} ;

}

#endif /* __INC_CMemoryPool_h__ */

CMemoryPool.cpp

/******************
CMemoryPool.cpp
******************/

/*!\file CMemoryPool.cpp
 * \brief CMemoryPool implementation.
 */

#include "../BasicIncludes.h"
#include "SMemoryChunk.h"
#include "CMemoryPool.h"
#include <string.h>
using namespace std;

namespace MemPool
{

static const int FREEED_MEMORY_CONTENT        = 0xAA ; //!< Value for freed memory  
static const int NEW_ALLOCATED_MEMORY_CONTENT = 0xFF ; //!< Initial Value for new allocated memory 

/******************
Constructor
******************/
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 ;

 // Allocate the Initial amount of Memory from the Operating-System...
 AllocateMemory(sInitialMemoryPoolSize) ;
}

/******************
Destructor
******************/
CMemoryPool::~CMemoryPool()
{
  FreeAllAllocatedMemory() ;
  DeallocateAllChunks() ;
   
  // Check for possible Memory-Leaks...
  assert((m_uiObjectCount == 0) && "WARNING : Memory-Leak : You have not freed all allocated Memory") ;
}

/******************
GetMemory
******************/
void *CMemoryPool::GetMemory(const std::size_t &sMemorySize)
{
  std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize) ;  
  SMemoryChunk *ptrChunk = NULL ;
  while(!ptrChunk)
  {
    // Is a Chunks available to hold the requested amount of Memory ?
    ptrChunk = FindChunkSuitableToHoldMemory(sBestMemBlockSize) ;
    if(!ptrChunk)
    {
      // No chunk can be found
      // => Memory-Pool is to small. We have to request 
      //    more Memory from the Operating-System....
      sBestMemBlockSize = MaxValue(sBestMemBlockSize, CalculateBestMemoryBlockSize(m_sMinimalMemorySizeToAllocate)) ;
      AllocateMemory(sBestMemBlockSize) ;
    }
  }

  // Finally, a suitable Chunk was found.
  // Adjust the Values of the internal "TotalSize"/"UsedSize" Members and 
  // the Values of the MemoryChunk itself.
  m_sUsedMemoryPoolSize += sBestMemBlockSize ;
  m_sFreeMemoryPoolSize -= sBestMemBlockSize ;
  m_uiObjectCount++ ;
  SetMemoryChunkValues(ptrChunk, sBestMemBlockSize) ;

  // eventually, return the Pointer to the User
  return ((void *) ptrChunk->Data) ;
}

/******************
FreeMemory
******************/
void CMemoryPool::FreeMemory(void *ptrMemoryBlock, const std::size_t &sMemoryBlockSize)
{
  // Search all Chunks for the one holding the "ptrMemoryBlock"-Pointer
  // ("SMemoryChunk->Data == ptrMemoryBlock"). Eventually, free that Chunks,
  // so it beecomes available to the Memory-Pool again...
  SMemoryChunk *ptrChunk = FindChunkHoldingPointerTo(ptrMemoryBlock) ;
  if(ptrChunk)
  {
      //std::cerr << "Freed Chunks OK (Used memPool Size : " << m_sUsedMemoryPoolSize << ")" << std::endl ;
      FreeChunks(ptrChunk) ;
  }
  else
  {
      assert(false && "ERROR : Requested Pointer not in Memory Pool") ;
  }
  assert((m_uiObjectCount > 0) && "ERROR : Request to delete more Memory then allocated.") ;
  m_uiObjectCount-- ;
}

/******************
AllocateMemory
******************/
bool CMemoryPool::AllocateMemory(const std::size_t &sMemorySize)
{
  // This function will allocate *at least* "sMemorySize"-Bytes from the Operating-System.

  // How it works :
  // Calculate the amount of "SMemoryChunks" needed to manage the requested MemorySize.
  // Every MemoryChunk can manage only a certain amount of Memory
  // (set by the "m_sMemoryChunkSize"-Member of the Memory-Pool).
  //
  // Also, calculate the "Best" Memory-Block size to allocate from the 
  // Operating-System, so that all allocated Memory can be assigned to a
  // Memory Chunk.
  // Example : 
  //    You want to Allocate 120 Bytes, but every "SMemoryChunk" can only handle
  //    50 Bytes ("m_sMemoryChunkSize = 50").
  //    So, "CalculateNeededChunks()" will return the Number of Chunks needed to
  //    manage 120 Bytes. Since it is not possible to divide 120 Bytes in to
  //    50 Byte Chunks, "CalculateNeededChunks()" returns 3.
  //    ==> 3 Chunks can Manage 150 Bytes of data (50 * 3 = 150), so
  //        the requested 120 Bytes will fit into this Block.
  //    "CalculateBestMemoryBlockSize()" will return the amount of memory needed
  //    to *perfectly* subdivide the allocated Memory into "m_sMemoryChunkSize" (= 50) Byte
  //    pieces. -> "CalculateBestMemoryBlockSize()" returns 150.
  //    So, 150 Bytes of memory are allocated from the Operating-System and
  //    subdivided into 3 Memory-Chunks (each holding a Pointer to 50 Bytes of the allocated memory).
  //    Since only 120 Bytes are requested, we have a Memory-Overhead of 
  //    150 - 120 = 30 Bytes. 
  //    Note, that the Memory-overhead is not a bad thing, because we can use 
  //    that memory later (it remains in the Memory-Pool).
  //

  unsigned int uiNeededChunks = CalculateNeededChunks(sMemorySize) ;
  std::size_t sBestMemBlockSize = CalculateBestMemoryBlockSize(sMemorySize) ;

  TByte *ptrNewMemBlock = (TByte *) malloc(sBestMemBlockSize) ; // allocate from Operating System
  SMemoryChunk *ptrNewChunks = (SMemoryChunk *) malloc((uiNeededChunks * sizeof(SMemoryChunk))) ; // allocate Chunk-Array to Manage the Memory
  assert(((ptrNewMemBlock) && (ptrNewChunks)) && "Error : System ran out of Memory") ;

  // Adjust internal Values (Total/Free Memory, etc.)
  m_sTotalMemoryPoolSize += sBestMemBlockSize ;
  m_sFreeMemoryPoolSize += sBestMemBlockSize ;
  m_uiMemoryChunkCount += uiNeededChunks ;

  // Usefull for Debugging : Set the Memory-Content to a defined Value
  if(m_bSetMemoryData)
  {
    memset(((void *) ptrNewMemBlock), NEW_ALLOCATED_MEMORY_CONTENT, sBestMemBlockSize) ;
  }

  // Associate the allocated Memory-Block with the Linked-List of MemoryChunks
  return LinkChunksToData(ptrNewChunks, uiNeededChunks, ptrNewMemBlock) ;
}

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

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

/******************
FreeChunks
******************/
void CMemoryPool::FreeChunks(SMemoryChunk *ptrChunk)
{
  // Make the Used Memory of the given Chunk available
  // to the Memory Pool again.

  SMemoryChunk *ptrCurrentChunk = ptrChunk ;
  unsigned int uiChunkCount = CalculateNeededChunks(ptrCurrentChunk->UsedSize);
  for(unsigned int i = 0; i < uiChunkCount; i++)
  {
    if(ptrCurrentChunk)
    {
      // Step 1 : Set the allocated Memory to 'FREEED_MEMORY_CONTENT'
      // Note : This is fully Optional, but usefull for debugging
      if(m_bSetMemoryData)
      {
        memset(((void *) ptrCurrentChunk->Data), FREEED_MEMORY_CONTENT, m_sMemoryChunkSize) ;
      }

      // Step 2 : Set the Used-Size to Zero
      ptrCurrentChunk->UsedSize = 0 ;

      // Step 3 : Adjust Memory-Pool Values and goto next Chunk
      m_sUsedMemoryPoolSize -= m_sMemoryChunkSize ;
      ptrCurrentChunk = ptrCurrentChunk->Next ;
    }
  }
}


/******************
FindChunkSuitableToHoldMemory
******************/
SMemoryChunk *CMemoryPool::FindChunkSuitableToHoldMemory(const std::size_t &sMemorySize)
{
  // Find a Chunk to hold *at least* "sMemorySize" Bytes.
  unsigned int uiChunksToSkip = 0 ;
  bool bContinueSearch = true ;
  SMemoryChunk *ptrChunk = m_ptrCursorChunk ; // Start search at Cursor-Pos.
  for(unsigned int i = 0; i < m_uiMemoryChunkCount; i++)
  {
    if(ptrChunk)
    {
      if(ptrChunk == m_ptrLastChunk) // End of List reached : Start over from the beginning
      {
        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 ;
}

/******************
SkipChunks
******************/
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
        {
            // Will occur, if you try to Skip more Chunks than actually available
            // from your "ptrStartChunk" 
            assert(false && "Error : Chunk == NULL was not expected.") ;
            break ;
        }
    }
    return ptrCurrentChunk ;
}

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

/******************
WriteMemoryDumpToFile
******************/
bool CMemoryPool::WriteMemoryDumpToFile(const std::string &strFileName)
{
  bool bWriteSuccesfull = false ;
  std::ofstream ofOutputFile ;
  ofOutputFile.open(strFileName.c_str(), std::ofstream::out | std::ofstream::binary) ;

  SMemoryChunk *ptrCurrentChunk = m_ptrFirstChunk ;
  while(ptrCurrentChunk)
  {
    if(ofOutputFile.good())
    {
        ofOutputFile.write(((char *)ptrCurrentChunk->Data), ((std::streamsize) m_sMemoryChunkSize)) ;
      bWriteSuccesfull = true ;
    }
    ptrCurrentChunk = ptrCurrentChunk->Next ;
  }
  ofOutputFile.close() ;
  return bWriteSuccesfull ;
}

/******************
LinkChunksToData
******************/
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 ;
    }
    
    uiMemOffSet = (i * ((unsigned int) m_sMemoryChunkSize)) ;
    m_ptrLastChunk->Data = &(ptrNewMemBlock[uiMemOffSet]) ;

    // The first Chunk assigned to the new Memory-Block will be 
    // a "AllocationChunk". This means, this Chunks stores the
    // "original" Pointer to the MemBlock and is responsible for
    // "free()"ing the Memory later....
    if(!bAllocationChunkAssigned)
    {
        m_ptrLastChunk->IsAllocationChunk = true ;
        bAllocationChunkAssigned = true ;
    }
  }
  return RecalcChunkMemorySize(m_ptrFirstChunk, m_uiMemoryChunkCount) ;
}

/******************
RecalcChunkMemorySize
******************/
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 ;
}

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

/******************
FindChunkHoldingPointerTo
******************/
SMemoryChunk *CMemoryPool::FindChunkHoldingPointerTo(void *ptrMemoryBlock)
{
    SMemoryChunk *ptrTempChunk = m_ptrFirstChunk ;
    while(ptrTempChunk)
    {
        if(ptrTempChunk->Data == ((TByte *) ptrMemoryBlock))
        {
            break ;
        }
        ptrTempChunk = ptrTempChunk->Next ;
    }
    return ptrTempChunk ;
}

/******************
FreeAllAllocatedMemory
******************/
void CMemoryPool::FreeAllAllocatedMemory()
{
    SMemoryChunk *ptrChunk = m_ptrFirstChunk ;
    while(ptrChunk)
    {
        if(ptrChunk->IsAllocationChunk)
        {
            free(((void *) (ptrChunk->Data))) ;
        }
        ptrChunk = ptrChunk->Next ;
    }
}

/******************
DeallocateAllChunks
******************/
void CMemoryPool::DeallocateAllChunks()
{
  SMemoryChunk *ptrChunk = m_ptrFirstChunk ;
  SMemoryChunk *ptrChunkToDelete = NULL ;
  while(ptrChunk)
  {
    if(ptrChunk->IsAllocationChunk)
    {    
        if(ptrChunkToDelete)
        {
            free(((void *) ptrChunkToDelete)) ;
        }
        ptrChunkToDelete = ptrChunk ;
    }
    ptrChunk = ptrChunk->Next ;
  }
}

/******************
IsValidPointer
******************/
bool CMemoryPool::IsValidPointer(void *ptrPointer)
{
    SMemoryChunk *ptrChunk = m_ptrFirstChunk ;
    while(ptrChunk)
    {
        if(ptrChunk->Data == ((TByte *) ptrPointer))
        {
            return true ;
        }
        ptrChunk = ptrChunk->Next ;
    }
    return false ;
}

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

}

main.cpp

/******************
main.cpp
******************/

/*!\file main.cpp
 * \brief Test-Program Main (Entry Point for the application).
 */

#include "BasicIncludes.h"
#include "MemPool/CMemoryPool.h"
#include <sys/time.h>
#include <iostream>
using namespace std;


MemPool::CMemoryPool *g_ptrMemPool = NULL  ; //!< Global MemoryPool (Testing purpose)
unsigned int TestCount             = 50000 ; //!< Nr of (de-)allocations (Testing purpose)
unsigned int ArraySize             = 1000  ; //!< Size of the "Testing"-Array

long calculateUsedTime(const struct timeval &start, const struct timeval &end);

struct dd    //alignment for four Bytes
{
    char a;
    char b;
    double  d; 
    short  c;
};

class myclass
{
public:
    myclass()
    {
        printf("myclass sizeof(myclass)=%d\n", sizeof(myclass));
    }
    virtual ~myclass(){}

private:
    int a;
    //int b;
};

/*! \class MyTestClass_OPOverload
 *  \brief Test Class (Operator new/delete overloaded)
 *
 * The only purpose of this class is the testing of the Memory-Pool.
 */
class MyTestClass_OPOverload
{
public :
    MyTestClass_OPOverload()
    {
      m_cMyArray[0] = 'H' ;
      m_cMyArray[1] = 'e' ;
      m_cMyArray[2] = 'l' ;
      m_cMyArray[3] = 'l' ;
      m_cMyArray[4] = 'o' ;
      m_cMyArray[5] = NULL ;
      m_strMyString = "This is a small Test-String" ;
      m_iMyInt = 12345 ;

      m_fFloatValue = 23456.7890f ;
      m_fDoubleValue = 6789.012345 ;

      Next = this ;
    }

    virtual ~MyTestClass_OPOverload() {} ;

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

    void operator delete(void *ptrObject, std::size_t ObjectSize)
    {
        g_ptrMemPool->FreeMemory(ptrObject, ObjectSize) ;
    }
private :
   // Test-Data
   char m_cMyArray[25] ;
   unsigned char m_BigArray[10000] ;
   std::string m_strMyString ;
   int m_iMyInt ;
   MyTestClass_OPOverload *Next ;
   float m_fFloatValue ;
   double m_fDoubleValue ;
} ;

/*! \class MyTestClass
 *  \brief Test Class ("Original" new/delete operator)
 *
 * The only purpose of this class is the testing of the Memory-Pool.
 */
class MyTestClass
{
public :
    MyTestClass()
    {
      m_cMyArray[0] = 'H' ;
      m_cMyArray[1] = 'e' ;
      m_cMyArray[2] = 'l' ;
      m_cMyArray[3] = 'l' ;
      m_cMyArray[4] = 'o' ;
      m_cMyArray[5] = NULL ;
      m_strMyString = "This is a small Test-String" ;
      m_iMyInt = 12345 ;

      m_fFloatValue = 23456.7890f ;
      m_fDoubleValue = 6789.012345 ;

      Next = this ;
    }

    virtual ~MyTestClass() {} ;
private :
   // Test-Data
   char m_cMyArray[25] ;
   unsigned char m_BigArray[10000] ;
   std::string m_strMyString ;
   int m_iMyInt ;
   MyTestClass *Next ;
   float m_fFloatValue ;
   double m_fDoubleValue ;
} ;

/******************
CreateGlobalMemPool
******************/
void CreateGlobalMemPool()
{
  std::cerr << "Creating MemoryPool...." ;
  g_ptrMemPool = new MemPool::CMemoryPool() ;
  std::cerr << "OK" << std::endl ;
}

/******************
DestroyGlobalMemPool
******************/
void DestroyGlobalMemPool()
{
  std::cerr << "Deleting MemPool...." ;
  if(g_ptrMemPool) ::delete g_ptrMemPool ;
  std::cerr << "OK" << std::endl ;
}

/******************
TestAllocationSpeedClassMemPool
******************/
void TestAllocationSpeedClassMemPool()
{
  std::cerr << "Allocating Memory (Object Size MyTestClass_OPOverload : " << sizeof(MyTestClass_OPOverload) << ")..." ;
  
  struct timeval start;
  gettimeofday(&start, NULL);
  for(unsigned int j = 0; j < TestCount; j++)
  {
    MyTestClass_OPOverload *ptrTestClass = new MyTestClass_OPOverload ;
    delete ptrTestClass ;
  }
 
  struct timeval end;
  gettimeofday(&end, NULL);
  long usedtime = calculateUsedTime(start, end);
  std::cerr << "OK" << std::endl ;

  std::cerr << "Result for MemPool(Class Test) : " << (usedtime/1000) << " ms" << std::endl;
}


/******************
TestAllocationSpeedClassHeap
******************/
void TestAllocationSpeedClassHeap()
{
  std::cerr << "Allocating Memory (Object Size MyTestClass : " << sizeof(MyTestClass) << ")..." ;
  struct timeval start;
  gettimeofday(&start, NULL);
  for(unsigned int j = 0; j < TestCount; j++)
  {
    MyTestClass *ptrTestClass = new MyTestClass ;
    delete ptrTestClass ;
  }
  struct timeval end;
  gettimeofday(&end, NULL);
  long usedtime = calculateUsedTime(start, end);
  
  std::cerr << "OK" << std::endl ;
  std::cerr << "Result for Heap(Class Test)    : " << usedtime/1000 << " ms" << std::endl ;
}

/******************
TestAllocationSpeedArrayMemPool
******************/
void TestAllocationSpeedArrayMemPool()
{
  std::cerr << "Allocating Memory (Object Size : " << ArraySize << ")..." ;
  
  struct timeval start;
  gettimeofday(&start, NULL);
  for(unsigned int j = 0; j < TestCount; j++)
  {
      char *ptrArray = (char *) g_ptrMemPool->GetMemory(ArraySize)  ;
      g_ptrMemPool->FreeMemory(ptrArray, ArraySize) ;
  }
  
  struct timeval end;
  gettimeofday(&end, NULL);
  long usedtime = calculateUsedTime(start, end);
  
  std::cerr << "OK" << std::endl ;
  std::cerr << "Result for MemPool(Array-Test) : " << usedtime/1000 << " ms" << std::endl ;
}

/******************
TestAllocationSpeedArrayHeap
******************/
void TestAllocationSpeedArrayHeap()
{
  std::cerr << "Allocating Memory (Object Size : " << ArraySize << ")..." ;

  struct timeval start;
  gettimeofday(&start, NULL);
  for(unsigned int j = 0; j < TestCount; j++)
  {
     char *ptrArray = (char *) malloc(ArraySize)  ;
     free(ptrArray) ;
  }

  struct timeval end;
  gettimeofday(&end, NULL);
  long usedtime = calculateUsedTime(start, end);
  
  std::cerr << "OK" << std::endl ;
  std::cerr << "Result for Heap(Array-Test)    : " << usedtime/1000 << " ms" << std::endl ;
}



/******************
WriteMemoryDumpToFile
******************/
void WriteMemoryDumpToFile()
{
  std::cerr << "Writing MemoryDump to File..." ;
  g_ptrMemPool->WriteMemoryDumpToFile("MemoryDump.bin") ;
  std::cerr << "OK" << std::endl ;
}

long calculateUsedTime(const struct timeval &start, const struct timeval &end)
{
    long usedtime_us = 0;
    if((end.tv_usec - start.tv_usec) > 0 )
        usedtime_us = (end.tv_sec - start.tv_sec)*1000000 + end.tv_usec - start.tv_usec;
    else
        usedtime_us = (end.tv_sec - start.tv_sec -1)*1000000 + end.tv_usec + 1000000 - start.tv_usec;
    return usedtime_us;
}


/******************
main
******************/
int main(int argc, char *argv[])
{   
    struct dd f={0};
    printf("sizeof(f)=%d\n", sizeof(f));
    printf("&f.a=0x%0x, &f.d=0x%0x, &f.c=0x%0x\n", &(f.a), &(f.d), &(f.c));
    
    myclass *aa = new myclass;
    printf("sizeof(myclass)=%d\n", sizeof(myclass));
    
    printf("sizeof(float)=%d,sizeof(double)=%d, sizeof(int)=%d, sizeof(std::string)=%d\n", 
    sizeof(float), sizeof(double), sizeof(int), sizeof(std::string));

    std::cout << "MemoryPool Program started..." << std::endl ;
    CreateGlobalMemPool() ;

    TestAllocationSpeedArrayMemPool() ;
    TestAllocationSpeedArrayHeap() ;

    TestAllocationSpeedClassMemPool() ;
    TestAllocationSpeedClassHeap() ;

    WriteMemoryDumpToFile() ;

    DestroyGlobalMemPool() ;
    std::cout << "MemoryPool Program finished..." << std::endl ;
    return 0 ;
}

 Makefile

objects = main.o CMemoryPool.o

memorypool:$(objects)
    g++ -o memorypool $(objects)

main.o:    main.cpp BasicIncludes.h ./MemPool/CMemoryPool.h
    g++ -c main.cpp

CMemoryPool.o:./MemPool/CMemoryPool.cpp  ./MemPool/CMemoryPool.h  
    g++ -c ./MemPool/CMemoryPool.cpp
    
clean:
    rm -f memorypool $(objects)