bigmem.cpp

绝对好东东

// BigMem.cpp: implementation of the CBigMem class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "RSAUtil.h"
#include "BigMem.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void CBigMem::_FreeAllResources()
{
	ReportMemLeak();
	for (int i = 0; i < m_nSlotUsed; i++)
	{
		if (m_pb[i]) delete m_pb[i];
		m_pb[i] = NULL;
	}
	memset(m_pb, 0, sizeof(m_pb));
	m_nSlotUsed		= 0;
	m_nPosAllocated	= 0;
}

CBigMem::CBigMem(int nSlotSize)
{
	memset(m_pb, 0, sizeof(m_pb));

	m_nSlotSize		= nSlotSize;
	m_nSlotUsed		= 0;
	//make m_nPosAllocated bigger than m_nSlotSize
	//force allocate new slot
	m_nPosAllocated	= nSlotSize << 1; 
	m_nRef			= 0;
}

CBigMem::~CBigMem()
{
	_FreeAllResources();
}

CBigMem* CBigMem::Create(int nSlotSize) 
{ 
	return new CBigMem(nSlotSize); 
}

int CBigMem::Refrence()	
{ 
	return ++m_nRef; 
}

int CBigMem::Release()	
{ 
	int nr = m_nRef--; 
	if (m_nRef <= 0) 
		delete this; 
	return nr; 
}

BOOL CBigMem::_AllocSlot(int nSlotSize)
{
	m_nSlotSize	= nSlotSize;
	m_pb[m_nSlotUsed++] = new BYTE [nSlotSize];
	ASSERT(m_nSlotUsed > 0 && m_nSlotUsed <= SLOT_COUNT);
	if (!(m_nSlotUsed > 0 && m_nSlotUsed <= SLOT_COUNT)) _asm int 3;
	m_nPosAllocated = 0;
	return true;
}

PVOID CBigMem::Alloc(int nSize)
{
	nSize += 3;
	nSize &= ~3;

	int nSizeNeed = nSize + 2 * sizeof(TBigMemBlock);
	ASSERT(nSize > 0 && nSizeNeed <= m_nSlotSize);
	ASSERT(m_nSlotUsed >= 0 && m_nSlotUsed <= SLOT_COUNT);
	if (m_nPosAllocated + nSizeNeed > m_nSlotSize)
	{
		_AllocSlot(m_nSlotSize);
	}
	ASSERT(m_nPosAllocated + nSizeNeed <= m_nSlotSize);
	TBigMemBlock* pbmb = (TBigMemBlock*)(m_pb[m_nSlotUsed - 1] + m_nPosAllocated);
	
	pbmb->dwAllocFlags = BIGMEM_ALLOCATED;
	pbmb->dwSize = nSize;
	
	m_nPosAllocated += nSize + sizeof(TBigMemBlock);

	TBigMemBlock* pbmbNext = (TBigMemBlock*)((PBYTE)pbmb + m_nPosAllocated);
	pbmbNext->dwAllocFlags = BIGMEM_LAST;
	pbmbNext->dwSize = 0;

	return pbmb + 1;
}

PVOID CBigMem::Realloc(PVOID pvOld, int nNewSize)
{
	TBigMemBlock* pbmb = NULL;
	if (pvOld)
	{
		pbmb = (TBigMemBlock*)(((PBYTE)pvOld) - sizeof(TBigMemBlock));
		if (nNewSize <= (int)pbmb->dwSize) return pvOld;
	}
	PVOID pvNew = Alloc(nNewSize);
	if (pvOld) 
	{
		memcpy(pvNew, pvOld, pbmb->dwSize);
		Free(pvOld);
	}
	return pvNew;
}

void CBigMem::Free(PVOID pv)
{
	TBigMemBlock* pbmb = (TBigMemBlock*)((PBYTE)pv - sizeof(TBigMemBlock));
	ASSERT((pbmb + 1) == pv);
	
	ASSERT(BIGMEM_ALLOCATED == pbmb->dwAllocFlags);
	pbmb->dwAllocFlags = BIGMEM_FREED;
	return;
}

#if defined(_DEBUG)

void CBigMem::ReportMemLeak()
{
#if 0
	for (int i = 0; i < m_nSlotUsed; i++)
	{
		ASSERT(m_pb[i]);
		{
			TBigMemBlock* pbmb = (TBigMemBlock*)m_pb[i];
			
			while(true)
			{
				if (BIGMEM_LAST == pbmb->dwAllocFlags)
				{
					break;
				}
				if (BIGMEM_FREED != pbmb->dwAllocFlags)
				{
					//dump this mem block
					TRACE("\nerror block = %08x", pbmb);
				}
				PBYTE pb = (PBYTE)pbmb;
				pb += pbmb->dwSize + sizeof(TBigMemBlock);
				pbmb = (TBigMemBlock*)pb;
			}
		}
	}
#endif
}

#endif /*_DEBUG*/