固定的，高效的内存池实现机器应用

固定的，高效的内存池实现，代码如下：

 

#ifndef __FIXOBJPOOL_H__
#define __FIXOBJPOOL_H__

//
// 高效、固定大小、小数量内存池，思想来自LOKI
//
#include "stdafx.h"

namespace loki
{
 template <int blocksize, unsigned short blockcount>
 class CFixMemPool
 {
  typedef unsigned short blockcount_type;
 public:
  CFixMemPool()
  {
   // 空间大小限制
   GNASSERT(blocksize >= sizeof(blockcount_type));

   m_poBuff = new char[blocksize * blockcount];
   GNASSERT(m_poBuff);
   
   // 作标记
   blockcount_type i = 0;
   for (char* p = m_poBuff; i < blockcount; p += blocksize)
   {
    *(blockcount_type*)p = ++i;
   }

   m_nFreeBlckCount = blockcount;
   m_tCurAvailableBlock = 0;
  }
  virtual ~CFixMemPool()
  {
   if (m_poBuff)
   {
    delete [] m_poBuff;
    m_poBuff = NULL;
   }
  }

  // 获取内存块
  char* Allocate(int nSize)
  {
   GNASSERT(nSize == blocksize);

   if (m_nFreeBlckCount <= 0)
   {
    goto ACK;
   }

   char* poBuff = m_poBuff + (m_tCurAvailableBlock * blocksize);
   GNASSERT(poBuff);
   m_tCurAvailableBlock = *(blockcount_type*)poBuff;

   m_nFreeBlckCount--;
   GNASSERT(m_nFreeBlckCount >= 0);
   return poBuff;
        ACK:
   return NULL;
  }

     // 释放内存块
  void Dellocate(char* poBuff)
  {
   if (NULL == poBuff)
   {
    return;
   }

   *(blockcount_type*)poBuff = m_tCurAvailableBlock;
   m_tCurAvailableBlock = static_cast<blockcount_type>(static_cast<int>(poBuff - m_poBuff) / blocksize);
   GNASSERT(m_tCurAvailableBlock < blocksize);

   m_nFreeBlckCount++;
   GNASSERT(m_nFreeBlckCount >= 0);
  }

 protected:
     char* m_poBuff;                        // 内存块区域
  int m_nFreeBlckCount;                  // 自由块数量
  blockcount_type m_tCurAvailableBlock;  // 当前可分配的自由块
 };
}

#endif

 

上述代码有如下的应用：

  1，全局的内存池获取，代码如下：

#ifndef __GLOBALMEMPOOLMGR_H__
#define __GLOBALMEMPOOLMGR_H__

#include "singleton.h"
#include "fixmempool.h"
#include "noncopy.h"
using namespace loki;

//
// 内存管理模块
//
class CGlobalMemPoolCtrl : public Gavin::CNonCopy
{
 DECLARE_SINGLETON(CGlobalMemPoolCtrl);
private:
 CGlobalMemPoolCtrl() {}
 ~CGlobalMemPoolCtrl() {}

public:
 // 内存块的操作，获取和释放
 template<int BLOCKSIZE, unsigned short BLOCKCOUNT>
 inline void OptMem(char*& poBuff, bool bFetch = false)
 {
  // 认真理解下面的代码，非常棒
  static CFixMemPool<BLOCKSIZE, BLOCKCOUNT> s_oFixeObjPool;
  if (bFetch)
  {
   poBuff = s_oFixeObjPool.Allocate(BLOCKSIZE);
  }
  else
  {
   s_oFixeObjPool.Dellocate(poBuff);
  }
 }
};

#define GLOBALMEMCTRL CGlobalMemPoolCtrl::Instance()

//
// 获取内存, 自动释放
//
template<int BLOCKSIZE, unsigned short BLOCKCOUNT>
struct SShellGlobalMem
{
public:
 inline SShellGlobalMem()
 {
  GLOBALMEMCTRL->OptMem<BLOCKSIZE, BLOCKCOUNT>(m_poBuff, true);
 }
 inline ~SShellGlobalMem()
 {
  GLOBALMEMCTRL->OptMem<BLOCKSIZE, BLOCKCOUNT>(m_poBuff, false);
 }

 char* GetData() { return m_poBuff; }
 int   GetSize() { return BLOCKSIZE; }

private:
 char* m_poBuff;
};

#endif

 

2，固定大小的对象池分配器,代码如下：

#ifndef __FIXOBJALLOCATOR_H__
#define __FIXOBJALLOCATOR_H__

//
// 固定的，高效对象分配池
//
#include "fixmempool.h"
#include "commontraints.h"
#include <new>
using namespace loki;

template<typename T, int SIZE>
class CFixObjAllocator : public Gavin::CCommonTraits<T>
{
public:
 CFixObjAllocator() {}
 virtual ~CFixObjAllocator() {}

public:
 // 获取对象
 value_type*  FetchObj()
 {
  char* poBuff = m_oFixMemPool.Allocate(sizeof(value_type));
  if (poBuff)
  {
   new (poBuff) value_type();
   return reinterpret_cast<value_type*>(poBuff);
  }
  else
  {
   return NULL;
  }
 }

 // 释放对象
 void ReleaseObj(value_type* poT)
 {
  if (NULL == poT)
  {
   return;
  }
  poT->~value_type();
  m_oFixMemPool.Dellocate(reinterpret_cast<char*>(poT));
 }

protected:
 CFixMemPool<sizeof(value_type), SIZE> m_oFixMemPool;
};

 

#endif