vfxmemory.cpp

DirectInput的基本实现 只是基本应用

								pcook->file,pcook->line,pcook->data,pcook->id);
				else
					__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n"),
								pcook->data,pcook->id);
			}

			pcook = (_small_cookie *)((INT_PTR)pcook + newsize);
		}
	}
}
#endif	//end VFX_DEBUG_MEMORY
//-----------------------------------------------------------------------------
large_alloc	*	large_alloc::__plarge_alloc = 0;

large_alloc::large_alloc()
{
	memset(&header,0,sizeof(header));
}

large_alloc::~large_alloc()
{	
	destructor();
}

void large_alloc::destructor()
{
#ifdef VFX_DEBUG_MEMORY
	_vfxMemoryOutputReport();
	Dump();
#endif	//end VFX_DEBUG_MEMORY
}

#ifdef VFX_DEBUG_MEMORY
void * large_alloc::alloc(size_t size,const char * file,unsigned int line)
{
	size = round_up(size);
	_large_cookie * pcook = reinterpret_cast<_large_cookie *>
		(__alloc(size + sizeof(_large_cookie) + sizeof(int *),file,line));

	unsigned int * pdccc = reinterpret_cast<unsigned int *>((INT_PTR)pcook->cookie.data + size);
	*pdccc = c_uMalloc0xCC;
	pcook->dccc = c_uMalloc0xCC;
	pcook->next = header.next;
	pcook->prev = &header;
	if(header.next)
		header.next->prev = pcook;
	header.next = pcook;
	pcook->cookie.file = file;
	pcook->cookie.line = line;
	pcook->cookie.size = size;
	pcook->cookie.id = g_alloc_times++;
	g_memory_obj++;
	g_memoey_used += size;
	if(g_memory_max < g_memoey_used)
		g_memory_max = g_memoey_used;

	return pcook->cookie.data;
}

void large_alloc::free(void * memory,const char * file,unsigned int line)
{
	_large_cookie * pcook = reinterpret_cast<_large_cookie *>
		((INT_PTR)memory - sizeof(_large_cookie) + sizeof(_large_cookie *));
	if(pcook->dccc != c_uMalloc0xCC)//前效验位有问题，很可能越界或错误的指针
	{
		if(file)
			__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed!!!\n"),file,line,memory);
		if(IsBadReadPtr(pcook->cookie.file,4) == 0)
			__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n"),pcook->cookie.file,pcook->cookie.line,memory,pcook->cookie.id);
		else
			__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n"),memory,pcook->cookie.id);
		return ;
	}
	unsigned int * pdccc = reinterpret_cast<unsigned int *>((INT_PTR)memory + pcook->cookie.size);
	if(*pdccc != c_uMalloc0xCC)//后效验位有问题，很可能越界或错误的指针
	{
		if(file)
			__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed!\n"),file,line,memory);
		if(IsBadReadPtr(pcook->cookie.file,4) == 0)
			__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n"),pcook->cookie.file,pcook->cookie.line,memory,pcook->cookie.id);
		else
			__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n"),memory,pcook->cookie.id);
	}

	memset(memory,0xCC,pcook->cookie.size);

	g_memory_obj--;
	g_memoey_used -= pcook->cookie.size;
	if(pcook->prev)
		pcook->prev->next = pcook->next;
	if(pcook->next)
		pcook->next->prev = pcook->prev;
	__free(pcook);
}
#else
void * large_alloc::alloc(size_t size)
{
	_large_cookie * pcook = reinterpret_cast<_large_cookie *>
		(__alloc(size + sizeof(_large_cookie) - sizeof(_small_cookie *)));
	pcook->cookie.size = size;

	return (pcook == 0) ? 0 : pcook->cookie.data;
}

void large_alloc::free(void * memory)
{
	_large_cookie * pcook = reinterpret_cast<_large_cookie *>
		((INT_PTR)memory - sizeof(_large_cookie) + sizeof(_small_cookie *));
	__free(pcook);

}
#endif	//end VFX_DEBUG_MEMORY

#ifdef VFX_DEBUG_MEMORY
void large_alloc::Dump()
{
	_large_cookie * p = header.next;
	while(p)
	{
		if(p->cookie.file)
			__MemoryTrace(vT("%s(%d) : Memory leak! There have %d bytes(%d K) memory had not be delete. Alloc ID : %d\n")
			,p->cookie.file,p->cookie.line,p->cookie.size,(p->cookie.size + 1023) / 1024,p->cookie.id);
		else
			__MemoryTrace(vT("Unkown position(0x%8.8x) : Memory leak! There have %d bytes(%d K) memory had not be delete. Alloc ID : %d\n")
			,p->cookie.data,p->cookie.size,(p->cookie.size + 1023) / 1024,p->cookie.id);
		if(p->dccc != c_uMalloc0xCC)//前效验位有问题，很可能越界或错误的指针
		{
			if(IsBadReadPtr(p,p->cookie.size) == 0)
				__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n")
				,p->cookie.file,p->cookie.line,p->cookie.data,p->cookie.id);
			else
				__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n")
				,p->cookie.data,p->cookie.id);
		}
		unsigned int * pdccc = reinterpret_cast<unsigned int *>((INT_PTR)p->cookie.data + p->cookie.size);
		if(*pdccc != c_uMalloc0xCC)//后效验位有问题，很可能越界或错误的指针
		{
			if(IsBadReadPtr(p,p->cookie.size) == 0)
				__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n")
				,p->cookie.file,p->cookie.line,p->cookie.data,p->cookie.id);
			else
				__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n")
				,p->cookie.data,p->cookie.id);
		}
		p = p->next;
	}
}

void large_alloc::Check()
{
	_large_cookie * p = header.next;
	while(p)
	{
		if(p->dccc != c_uMalloc0xCC)//前效验位有问题，很可能越界或错误的指针
		{
			if(IsBadReadPtr(p,p->cookie.size) == 0)
				__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n")
				,p->cookie.file,p->cookie.line,p->cookie.data,p->cookie.id);
			else
				__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed!!! Alloc ID : %d\n")
				,p->cookie.data,p->cookie.id);
		}
		unsigned int * pdccc = reinterpret_cast<unsigned int *>((INT_PTR)p->cookie.data + p->cookie.size);
		if(*pdccc != c_uMalloc0xCC)//后效验位有问题，很可能越界或错误的指针
		{
			if(IsBadReadPtr(p,p->cookie.size) == 0)
				__MemoryTrace(vT("%s(%d) : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n")
				,p->cookie.file,p->cookie.line,p->cookie.data,p->cookie.id);
			else
				__MemoryTrace(vT("Unkown position : Verify pointer(0x%8.8x) failed! Alloc ID : %d\n")
				,p->cookie.data,p->cookie.id);
		}
		p = p->next;
	}
}
#endif	//end VFX_DEBUG_MEMORY


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
//static large_alloc large_alloc::getalloc();
//static small_alloc small_alloc::getalloc();


#ifdef VFX_DEBUG_MEMORY
static int _vfxMemoryOutputReport()
{
	if(g_memory_max > 0)
	{
		__MemoryTrace(vT("\n"));
		if(g_memory_obj > 0)
			__MemoryTrace(vT("Memory leak : There have %d objects and %d bytes(%d K) memory had not be delete!\n")
			,g_memory_obj,g_memoey_used,(g_memoey_used + 1023)/1024);
		__MemoryTrace(vT("Max memory used : %u bytes(%d K)\n")
			,g_memory_max,(g_memory_max + 1023) / 1024);
		g_memory_max = 0; 
		__MemoryTrace(vT("\n"));
	}
 	return 0;
}
#endif	//end VFX_DEBUG_MEMORY


void _vfxDestructorMemory()
{
#ifdef VFX_DEBUG_MEMORY
	small_alloc::getalloc().destructor();
	large_alloc::getalloc().destructor();
#endif	//end VFX_DEBUG_MEMORY
}

}

using namespace VFX_Memory;

void * _vfxMemoryNew(size_t size,const char * file,unsigned int line)
{
	static __memory_init	memory_init;

#ifdef _MT
	auto_memory_lock	lock;
#endif //end _MT
	
#ifdef VFX_DEBUG_MEMORY
	if(g_alloc_times == g_alloc_break_times)
		__asm int 3;

	if(size > __max_bytes)
		return large_alloc::getalloc().alloc(size,file,line);
	else
		return small_alloc::getalloc().alloc(size,file,line);
#else
	if(size > __max_bytes)
		return large_alloc::getalloc().alloc(size);
	else
		return small_alloc::getalloc().alloc(size);
#endif	//end VFX_DEBUG_MEMORY
}

void _vfxMemoryDelete(void * memory,const char * file,unsigned int line)
{
	if(memory == 0)
		return ;

#ifdef _MT
	auto_memory_lock	lock;
#endif //end _MT

	_small_cookie * p = reinterpret_cast<_small_cookie *> 
		((INT_PTR)memory - sizeof(_small_cookie) + sizeof(_small_cookie *));
	
#ifdef VFX_DEBUG_MEMORY
	if(p->size > __max_bytes)
		large_alloc::getalloc().free(memory,file,line);
	else
		small_alloc::getalloc().free(memory,file,line);
#else
	if(p->size > __max_bytes)
		large_alloc::getalloc().free(memory);
	else
		small_alloc::getalloc().free(memory);
#endif	//end VFX_DEBUG_MEMORY
}


void _vfxMemoryReport()
{
#if VFX_DEBUG_MEMORY
#ifdef _MT
	auto_memory_lock	lock;
#endif //end _MT
	large_alloc::getalloc().Check();
	small_alloc::getalloc().Check();
#endif
}

void _vfxMemorySetBreak(size_t n)
{
#ifdef VFX_DEBUG_MEMORY
	g_alloc_break_times = n;
#endif
}