mempooler.h

Soul的源代码,类似于劲舞团之类的游戏

#ifndef  __MATRIX_MEMPOOL_H
#define  __MATRIX_MEMPOOL_H

#include <assert.h>


template<class Type>
class CMMemPooler
{
public:
	// 积己磊 
	CMMemPooler(int iNumOfBlock):
	  m_iNumOfBlock(iNumOfBlock),
		  m_pFreeNode(NULL),
		  m_pMemBlock(NULL),
		  m_pEndNode(NULL),
		  m_nPackCount(0)
	  {
		  assert(iNumOfBlock>0);
		  m_iBlockSize = sizeof(Node) + sizeof(Type);
		  Create();
	  }

	  // 家戈磊
	  ~CMMemPooler()
	  {
		  Destroy();
	  }

	  // 皋葛府 且寸 
	  Type* Alloc(int* iIndex )
	  {
		  Node* pNode = NULL;
		  Type* pRet = NULL;

		  EnterCriticalSection(&m_csAlloc);
		  ////////////////////////////
		  //茄俺绰 咯蜡肺..
		  if(m_nPackCount < m_iNumOfBlock - 1)
		  {
			  pNode = m_pFreeNode;
			  if(pNode!=NULL)
			  {
				  m_pFreeNode = m_pFreeNode->pNext;
				  // 滴俺 鞍捞 遏 吧府绰 何盒 吝夸
				  InterlockedIncrement(&m_nPackCount);
				  pRet=reinterpret_cast<Type*>(pNode+1);
				  *iIndex = pNode->iIndex;
			  }
		  }
		  ////////////////////////////
		  LeaveCriticalSection(&m_csAlloc);

		  return pRet;
	  }

	  BOOL Free(Type* pFreeNode)
	  {
		  // freeBlock 林家蔼捞 劝寸等 皋葛府 林家蔼 荤捞牢瘤 厚背茄促.

		  //
		  if(reinterpret_cast<DWORD>(m_pMemBlock) > reinterpret_cast<DWORD>(pFreeNode) 
			  || reinterpret_cast<DWORD>(m_pMemBlock) + m_AllocationSize  <reinterpret_cast<DWORD>(pFreeNode))
		  {
			  return FALSE;
		  }

		  Node* pNode=NULL;
		  BOOL bRet=FALSE;

		  EnterCriticalSection(&m_csFree);
		  ///////////////////////////

		  pNode=( reinterpret_cast<Node*>(pFreeNode) )-1;
		  if(m_nPackCount>0)
		  {
			  m_pEndNode->pNext = pNode;
			  m_pEndNode = pNode;
			  m_pEndNode->pNext = NULL;

			  // 滴俺 鞍捞 遏 吧府绰 何盒 吝夸
			  InterlockedDecrement(&m_nPackCount);
			  bRet=TRUE;
		  }

		  ///////////////////////////
		  LeaveCriticalSection(&m_csFree);

		  return bRet;
	  }

	  Type* operator[](int i)
	  {
		  Node* pNode = reinterpret_cast<Node*>(m_pMemBlock);
		  return reinterpret_cast<Type*>( (reinterpret_cast<DWORD>(pNode) ) + (i-1) * (m_iBlockSize) +sizeof(Node) );
	  }

	  int GetCount()
	  {
		  return m_nPackCount;
	  }


protected:
	void Create()
	{
		m_AllocationSize = (m_iBlockSize) * m_iNumOfBlock; // 皋葛府 且寸且 农扁 
		m_pMemBlock = VirtualAlloc(NULL,m_AllocationSize,MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
		assert(m_pMemBlock);

		Node* pNode = reinterpret_cast<Node*>(m_pMemBlock);

		m_pEndNode = pNode = reinterpret_cast<Node*>( (reinterpret_cast<DWORD>(pNode) ) + (m_iNumOfBlock-1) * (m_iBlockSize) );
		for(int i=m_iNumOfBlock - 1; i>=0; i--)
		{
			pNode->pNext = m_pFreeNode; // 贸澜俊绰 NULL , 溜 Tail 篮 NULL 肺 茄促.
			pNode->iIndex = i + 1;
			m_pFreeNode = pNode;
			pNode = reinterpret_cast<Node*>( (reinterpret_cast<DWORD>(pNode) ) - m_iBlockSize);

		}

		InitializeCriticalSectionAndSpinCount(&m_csAlloc,400);
		InitializeCriticalSectionAndSpinCount(&m_csFree,400);

	}

	void Destroy()
	{        

		if(m_pMemBlock)
		{
			VirtualFree(m_pMemBlock,0,MEM_RELEASE);
		}
		DeleteCriticalSection(&m_csAlloc);
		DeleteCriticalSection(&m_csFree);
	}


	struct Node
	{
		int iIndex;
		Node* pNext;
		Node()
		{
			pNext=NULL;
		}
	};



protected:
	int m_AllocationSize;
	Node* m_pFreeNode;				//	巢酒 乐绰 皋葛府 喉钒 畴靛
	Node* m_pEndNode;				//	畴靛狼 场何盒.
	void* m_pMemBlock;

	int m_iNumOfBlock;				//	皋葛府 且寸且 喉钒 荐
	int m_iBlockSize;				//	茄 喉钒 荤捞令 
	volatile long m_nPackCount;		//	且寸等 皋葛府 喉钒 肮荐

	CRITICAL_SECTION m_csAlloc;			 
	CRITICAL_SECTION m_csFree;			 
};

#endif