여우네 가족이야기

/*****************************************************************************
* Name : mempool.h
* Author : Lee, Kwang - Han
* Homepage : www.keiwalk.net
* Birthday : 2004.09.13
* Last Update : 2005.2
*
******************************************************************************/

// mempool.h: interface for the CMemPool class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MEMPOOL_H__46A89EFB_EEDD_44B7_8F76_6344042B0601__INCLUDED_)
#define AFX_MEMPOOL_H__46A89EFB_EEDD_44B7_8F76_6344042B0601__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "lock.h"

#define DECLARE_HEAP \
public: \
void* operator new[](size_t size) \
{ \
return m_spMemPool.Allocate(size); \
} \
void operator delete[](void* pDoomed) \
{ \
m_spMemPool.Free(pDoomed); \
} \
void* operator new(size_t size) \
{ \
return m_spMemPool.Allocate(size); \
} \
void operator delete(void* pDoomed) \
{ \
m_spMemPool.Free(pDoomed); \
} \
private: \
static CMemPool m_spMemPool;

#define DEFINE_HEAP(className, count) CMemPool className::m_spMemPool(sizeof(className), count);

template
class CMemPool
{
public:
CMemPool(const int& nObjSize, const int& nObjCount)
{
InitMemPool(nObjSize, nObjCount);
};

~CMemPool()
{
ReleasePool();
}

public:
static inline BOOL InitMemPool(const int& nObjSize, const int& nObjCount)
{
if(m_spAllocMem != NULL)
return FALSE;

m_nMaxObjCount = nObjCount;
if(nObjSize > 0)
{
m_nObjSize = nObjSize;
if(Allocate(m_nObjSize, nObjCount) == FALSE)
return FALSE;
}

return TRUE;
}

static inline void ReleasePool()
{
if(m_spAllocMem != NULL)
free(m_spAllocMem);
}

static inline BOOL Allocate(const size_t& size, const int& count)
{
if(m_spAllocMem != NULL)
return FALSE;

int nBitSize = (count >> 3) + (int)(count % 8 > 0); // 비트 체크를 넣기 위한 공간 사이즈
if(nBitSize % 4 != 0)
nBitSize += (4 - (nBitSize & 3));
m_nMaxCountQueue = count + 1;
int nSeqSize = sizeof(int) * m_nMaxCountQueue; // seq 넘버를 넣기위한 공간 사이즈..
m_nTotalSize = nBitSize + nSeqSize + size * count;

m_spAllocMem = (char*)malloc(m_nTotalSize); // ALLOC!
if(m_spAllocMem == NULL)
return FALSE;

m_slpData = m_spAllocMem + nBitSize + nSeqSize;
m_slpBitSet = m_spAllocMem + nSeqSize;
memset(m_slpBitSet, 0, nBitSize);

// 모든 블럭을 사용 가능으로 체크한다.
for(int i = 0; i < count; i++)
Push(i);

return TRUE;
}

static inline void* Allocate(const size_t& size)
{
if(size <= 0)
return NULL;

m_sLock.Lock();

void* pMem = Pop();
// 카운트++
m_sLock.Unlock();

return pMem;
}

static inline void Free(void* pDoomed)
{
if(pDoomed == NULL)
return;

m_sLock.Lock();
int seq = (int)((char*)pDoomed - m_slpData) / m_nObjSize;
Push(seq);
// 카운트--
m_sLock.Unlock();
}

private:

static inline void* Pop()
{
if(m_nRearMarker == m_nFrontMarker)
return NULL; // Underflow (더 이상 할당된게 없다)

char* lpSeq = m_spAllocMem;
int seq = *((int*)lpSeq + m_nFrontMarker);
m_slpBitSet[seq >> 3] |= (1 << (seq & 7)); // 해당 비트 1로..

m_nFrontMarker = ++m_nFrontMarker % m_nMaxCountQueue;
return (Type*)m_slpData + seq;
}

static inline BOOL Push(const int& seq)
{
if((m_nRearMarker + 1) % m_nMaxCountQueue == m_nFrontMarker)
return FALSE; // Overflow

char* lpSeq = m_spAllocMem;
*((int*)lpSeq + m_nRearMarker) = seq;
m_slpBitSet[seq >> 3] &= ~(1 << (seq % 7)); // 해당 비트 0으로...

m_nRearMarker = ++m_nRearMarker % m_nMaxCountQueue;
return TRUE;
}

private:
static char* m_spAllocMem;
static char* m_slpData;
static char* m_slpBitSet; // multimap 으로 변경할 수 있을것 같음

static int m_nTotalSize; // 전체 할당 사이즈
static int m_nMaxObjCount; // 메모리 풀에 넣을 객체 개수..
static int m_nAllocObjCount; // 메모리 풀에서 꺼낸 객체 수
static size_t m_nObjSize; // 객체 사이즈

// 환형큐를 위한 변수들..
static int m_nMaxCountQueue; // 힙에 seq 넘버를 넣을 공간의 count (m_nMaxObjCount + 1)
static int m_nFrontMarker;
static int m_nRearMarker;

static ELock m_sLock; // CRITICAL_SECTION
};

template char* CMemPool::m_spAllocMem = NULL;
template char* CMemPool::m_slpData = NULL;
template char* CMemPool::m_slpBitSet = NULL;
template int CMemPool::m_nTotalSize = 0;
template int CMemPool::m_nMaxObjCount = 0;
template size_t CMemPool::m_nObjSize = 0;
template int CMemPool::m_nAllocObjCount = 0;
template int CMemPool::m_nMaxCountQueue = 0;
template int CMemPool::m_nFrontMarker = 0;
template int CMemPool::m_nRearMarker = 0;
template ELock CMemPool::m_sLock;

#endif // !defined(AFX_MEMPOOL_H__46A89EFB_EEDD_44B7_8F76_6344042B0601__INCLUDED_)