tmempool.h

韩国英雄王座倒闭后流出来部分源代码

////////////////////////////////////////////////////////////////////////////////////////
//
//
//
//
////////////////////////////////////////////////////////////////////////////////////////

#pragma once
#include <assert.h>

extern void ErrorMsg(const char *pszParam, ...) ;

template < class Type >
class TMemPool 
{

public:

	//	--------------------------------------------------------------------------------
	//	傅农靛 府胶飘 贸烦 包府甫 困茄 畴靛 鸥涝
	//	--------------------------------------------------------------------------------
	struct BlockNode
	{	
		BlockNode * pNext;
		bool bIsUsed  ;
		BlockNode()
		{
			pNext = NULL;
			bIsUsed = false ;
		}
	};

	//	--------------------------------------------------------------------------------
	BlockNode *m_pFreeList;		//	巢酒 乐绰 皋葛府 喉钒 府胶飘
	BlockNode *m_pTailList;		//	皋葛府 喉钒 府胶飘狼 Tail	2003.10.22	Duke Kim眠啊 

	void * m_pMemBlock;

	int m_nNumofBlock;			//	皋葛府 且寸且 喉钒 荐
	int m_nListBlockSize;		//	茄 喉钒 荤捞令
	int m_nAllocCount;			//	且寸等 皋葛府 喉钒 肮荐

	CRITICAL_SECTION	m_cs;

	//	--------------------------------------------------------------------------------
	//	积己磊
	//	--------------------------------------------------------------------------------
	TMemPool(int nNumOfBlock) : m_nNumofBlock(nNumOfBlock), m_pFreeList(NULL), m_pTailList(NULL), m_pMemBlock(NULL), m_nAllocCount(0)
	{
		assert(nNumOfBlock > 0);
		m_nListBlockSize = sizeof(BlockNode) + sizeof(Type);

		Create();
	}

	//	--------------------------------------------------------------------------------
	//	家戈磊
	//	--------------------------------------------------------------------------------
	virtual ~TMemPool()
	{
		Destroy();
	}

	//	--------------------------------------------------------------------------------
	//	皋葛府 且寸
	//	--------------------------------------------------------------------------------
	Type * Alloc()
	{
		BlockNode * pNode = NULL;
		Type * pRet = NULL;

		
		//	Memory Block捞 茄俺 巢篮 版快 NULL阑 馆券 矫糯
		if( ( m_nNumofBlock - m_nAllocCount )	<=	1 )
		{
			return NULL;
		}


		EnterCriticalSection(&m_cs);
		////////////////////////////
	
		
			pNode = m_pFreeList;
			if (pNode != NULL)
			{
				m_pFreeList = m_pFreeList->pNext;
				++m_nAllocCount;
				pRet = reinterpret_cast < Type * > (pNode + 1);

				////////////////////////////////////////////////////////////////////
				// NOTENOTE: 茄锅 荤侩登菌促绰巴阑 钎矫窍扁 困秦 
				// 
				////////////////////////////////////////////////////////////////////

				pNode->bIsUsed = true ;
			}

		////////////////////////////
		LeaveCriticalSection(&m_cs);

		return pRet;
	}


	//	--------------------------------------------------------------------------------
	//	皋葛府 秦力
	//	--------------------------------------------------------------------------------
	bool Free(Type * freeBlock)
	{
		BlockNode * pNode = NULL;
		bool bRet = false;
		

		EnterCriticalSection(&m_cs);
		///////////////////////////

		
		pNode = (reinterpret_cast < BlockNode * > (freeBlock)) - 1;
		
		if (m_nAllocCount > 0)
		{
			//	pNode->pNext	= m_pFreeList;
			//	m_pFreeList		= pNode;
			////////////////////////////////////////////////////////////////////
			// NOTENOTE: 皋葛府俊 促矫 持绰版快 规瘤甫 困秦 
			// 茄锅 荤侩等 皋葛府搁 true 捞固 荤侩秦辑 
			////////////////////////////////////////////////////////////////////
			if (pNode->bIsUsed == true)
				pNode->bIsUsed = false ;
			else
			{
				ErrorMsg("(X) TMemPool Error Memory Refree !!") ;
				LeaveCriticalSection(&m_cs);
				return bRet;
			}

			//	2003.10.22 Duke Kim 眠啊
			m_pTailList->pNext	=	pNode;
			pNode->pNext		=	NULL;
			m_pTailList			=	pNode;

			--m_nAllocCount;
			bRet = true;
		}

		///////////////////////////
		LeaveCriticalSection(&m_cs);

		return bRet;
	}

	//	--------------------------------------------------------------------------------
	//	皋葛府 箭磊甫 馆券矫糯
	//	--------------------------------------------------------------------------------
	int GetCount()
	{
		return m_nAllocCount;
	}


protected:
	
	void Create()
	{

		const int AllocationSize = (m_nListBlockSize) * m_nNumofBlock; // 皋葛府 且寸且 农扁
		m_pMemBlock = VirtualAlloc(NULL, AllocationSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
		assert(m_pMemBlock);

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

		pNode = reinterpret_cast < BlockNode * > ((reinterpret_cast < DWORD > (pNode)) + (m_nNumofBlock - 1) *
		   (m_nListBlockSize));
		
		m_pTailList	=	pNode;		//	LIst Tail历厘 矫糯
		
		for (int i = m_nNumofBlock - 1; i >= 0; i--)
		{
			pNode->pNext = m_pFreeList; // 贸澜俊绰 NULL , 溜 Tail 篮 NULL 肺 茄促.
			m_pFreeList = pNode;
			pNode = reinterpret_cast < BlockNode * > ((reinterpret_cast < DWORD > (pNode)) - m_nListBlockSize);
		}
		
//		pNode = NULL ;
		::InitializeCriticalSectionAndSpinCount( &m_cs , 1000 );

	}

	void Destroy()
	{

		if (m_pMemBlock)
		{
			VirtualFree(m_pMemBlock, 0, MEM_RELEASE);
		}
		::DeleteCriticalSection(&m_cs);
	}

};