cmmempooler.h

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

#ifndef  __MATRIX_MEMPOOL_H
#define  __MATRIX_MEMPOOL_H

#include <assert.h>

namespace MatrixCore
{
	namespace Network
	{
		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()
			  {
				  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);
						  pNode->bAtive = TRUE; 
					  }
				  }
				  ////////////////////////////
				  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)
				  {
					  if(pNode->bAtive == FALSE)
					  {
						  // 捞固 馆吵茄 皋葛府芭唱 静绊 乐绰 皋葛府啊 酒聪促
						  LeaveCriticalSection(&m_csFree);
						  return FALSE;
					  }

					  pNode->bAtive = FALSE;
					  m_pEndNode->pNext = pNode;
					  m_pEndNode = pNode;
					  m_pEndNode->pNext = NULL;

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

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

				  return bRet;
			  }

			  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 肺 茄促.
					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
			{
				BOOL  bAtive;
				Node* pNext;
				Node()
				{
					bAtive = FALSE;
					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