/mmgr.cpp

Large files files are truncated, but you can click here to view the full file

// ---------------------------------------------------------------------------------------------------------------------------------

//                                                      

//                                                      

//  _ __ ___  _ __ ___   __ _ _ __      ___ _ __  _ __  

// | '_ ` _ \| '_ ` _ \ / _` | '__|    / __| '_ \| '_ \ 

// | | | | | | | | | | | (_| | |    _ | (__| |_) | |_) |

// |_| |_| |_|_| |_| |_|\__, |_|   (_) \___| .__/| .__/ 

//                       __/ |             | |   | |    

//                      |___/              |_|   |_|    

//

// Memory manager & tracking software

//

// Best viewed with 8-character tabs and (at least) 132 columns

//

// ---------------------------------------------------------------------------------------------------------------------------------

//

// Restrictions & freedoms pertaining to usage and redistribution of this software:

//

//  * This software is 100% free

//  * If you use this software (in part or in whole) you must credit the author.

//  * This software may not be re-distributed (in part or in whole) in a modified

//    form without clear documentation on how to obtain a copy of the original work.

//  * You may not use this software to directly or indirectly cause harm to others.

//  * This software is provided as-is and without warrantee. Use at your own risk.

//

// For more information, visit HTTP://www.FluidStudios.com

//

// ---------------------------------------------------------------------------------------------------------------------------------

// Originally created on 12/22/2000 by Paul Nettle

//

// Copyright 2000, Fluid Studios, Inc., all rights reserved.

// ---------------------------------------------------------------------------------------------------------------------------------

//

// !!IMPORTANT!!

//

// This software is self-documented with periodic comments. Before you start using this software, perform a search for the string

// "-DOC-" to locate pertinent information about how to use this software.

//

// You are also encouraged to read the comment blocks throughout this source file. They will help you understand how this memory

// tracking software works, so you can better utilize it within your applications.

//

// NOTES:

//

// 1. If you get compiler errors having to do with set_new_handler, then go through this source and search/replace

//    "std::set_new_handler" with "set_new_handler".

//

// 2. This code purposely uses no external routines that allocate RAM (other than the raw allocation routines, such as malloc). We

//    do this because we want this to be as self-contained as possible. As an example, we don't use assert, because when running

//    under WIN32, the assert brings up a dialog box, which allocates RAM. Doing this in the middle of an allocation would be bad.

//

// 3. When trying to override new/delete under MFC (which has its own version of global new/delete) the linker will complain. In

//    order to fix this error, use the compiler option: /FORCE, which will force it to build an executable even with linker errors.

//    Be sure to check those errors each time you compile, otherwise, you may miss a valid linker error.

//

// 4. If you see something that looks odd to you or seems like a strange way of going about doing something, then consider that this

//    code was carefully thought out. If something looks odd, then just assume I've got a good reason for doing it that way (an

//    example is the use of the class MemStaticTimeTracker.)

//

// 5. With MFC applications, you will need to comment out any occurance of "#define new DEBUG_NEW" from all source files.

//

// 6. Include file dependencies are _very_important_ for getting the MMGR to integrate nicely into your application. Be careful if

//    you're including standard includes from within your own project inclues; that will break this very specific dependency order. 

//    It should look like this:

//

//		#include <stdio.h>   // Standard includes MUST come first

//		#include <stdlib.h>  //

//		#include <streamio>  //

//

//		#include "mmgr.h"    // mmgr.h MUST come next

//

//		#include "myfile1.h" // Project includes MUST come last

//		#include "myfile2.h" //

//		#include "myfile3.h" //

//

// ---------------------------------------------------------------------------------------------------------------------------------



//#include "stdafx.h"

#include <iostream>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include <time.h>

#include <stdarg.h>

#include <new>



#ifndef	WIN32

#include <unistd.h>

#endif



#include "mmgr.h"



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- If you're like me, it's hard to gain trust in foreign code. This memory manager will try to INDUCE your code to crash (for

// very good reasons... like making bugs obvious as early as possible.) Some people may be inclined to remove this memory tracking

// software if it causes crashes that didn't exist previously. In reality, these new crashes are the BEST reason for using this

// software!

//

// Whether this software causes your application to crash, or if it reports errors, you need to be able to TRUST this software. To

// this end, you are given some very simple debugging tools.

// 

// The quickest way to locate problems is to enable the STRESS_TEST macro (below.) This should catch 95% of the crashes before they

// occur by validating every allocation each time this memory manager performs an allocation function. If that doesn't work, keep

// reading...

//

// If you enable the TEST_MEMORY_MANAGER #define (below), this memory manager will log an entry in the memory.log file each time it

// enters and exits one of its primary allocation handling routines. Each call that succeeds should place an "ENTER" and an "EXIT"

// into the log. If the program crashes within the memory manager, it will log an "ENTER", but not an "EXIT". The log will also

// report the name of the routine.

//

// Just because this memory manager crashes does not mean that there is a bug here! First, an application could inadvertantly damage

// the heap, causing malloc(), realloc() or free() to crash. Also, an application could inadvertantly damage some of the memory used

// by this memory tracking software, causing it to crash in much the same way that a damaged heap would affect the standard

// allocation routines.

//

// In the event of a crash within this code, the first thing you'll want to do is to locate the actual line of code that is

// crashing. You can do this by adding log() entries throughout the routine that crashes, repeating this process until you narrow

// in on the offending line of code. If the crash happens in a standard C allocation routine (i.e. malloc, realloc or free) don't

// bother contacting me, your application has damaged the heap. You can help find the culprit in your code by enabling the

// STRESS_TEST macro (below.)

//

// If you truely suspect a bug in this memory manager (and you had better be sure about it! :) you can contact me at

// midnight@FluidStudios.com. Before you do, however, check for a newer version at:

//

//	http://www.FluidStudios.com/publications.html

//

// When using this debugging aid, make sure that you are NOT setting the alwaysLogAll variable on, otherwise the log could be

// cluttered and hard to read.

// ---------------------------------------------------------------------------------------------------------------------------------



//#define	TEST_MEMORY_MANAGER



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Enable this sucker if you really want to stress-test your app's memory usage, or to help find hard-to-find bugs

// ---------------------------------------------------------------------------------------------------------------------------------



//#define	STRESS_TEST



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Enable this sucker if you want to stress-test your app's error-handling. Set RANDOM_FAIL to the percentage of failures you

//       want to test with (0 = none, >100 = all failures).

// ---------------------------------------------------------------------------------------------------------------------------------



//#define	RANDOM_FAILURE 10.0



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Locals -- modify these flags to suit your needs

// ---------------------------------------------------------------------------------------------------------------------------------



#ifdef	STRESS_TEST

static	const	unsigned int	hashBits               = 12;

static		bool		randomWipe             = true;

static		bool		alwaysValidateAll      = true;

static		bool		alwaysLogAll           = true;

static		bool		alwaysWipeAll          = true;

static		bool		cleanupLogOnFirstRun   = true;

static	const	unsigned int	paddingSize            = 1024; // An extra 8K per allocation!

#else

static	const	unsigned int	hashBits               = 12;

static		bool		randomWipe             = false;

static		bool		alwaysValidateAll      = false;

static		bool		alwaysLogAll           = false;

static		bool		alwaysWipeAll          = true;

static		bool		cleanupLogOnFirstRun   = true;

static	const	unsigned int	paddingSize            = 4;

#endif



// ---------------------------------------------------------------------------------------------------------------------------------

// We define our own assert, because we don't want to bring up an assertion dialog, since that allocates RAM. Our new assert

// simply declares a forced breakpoint.

//

// The BEOS assert added by Arvid Norberg <arvid@iname.com>.

// ---------------------------------------------------------------------------------------------------------------------------------



#ifdef	WIN32

	#ifdef	_DEBUG

	#define	m_assert(x) if ((x) == false) __asm { int 3 }

	#else

	#define	m_assert(x) {}

	#endif

#elif defined(__BEOS__)

	#ifdef DEBUG

		extern void debugger(const char *message);

		#define	m_assert(x) if ((x) == false) debugger("mmgr: assert failed")

	#else

		#define m_assert(x) {}

	#endif

#else	// Linux uses assert, which we can use safely, since it doesn't bring up a dialog within the program.

	#define	m_assert(cond) assert(cond)

#endif



// ---------------------------------------------------------------------------------------------------------------------------------

// Here, we turn off our macros because any place in this source file where the word 'new' or the word 'delete' (etc.)

// appear will be expanded by the macro. So to avoid problems using them within this source file, we'll just #undef them.

// ---------------------------------------------------------------------------------------------------------------------------------



#undef	new

#undef	delete

#undef	malloc

#undef	calloc

#undef	realloc

#undef	free



// ---------------------------------------------------------------------------------------------------------------------------------

// Defaults for the constants & statics in the MemoryManager class

// ---------------------------------------------------------------------------------------------------------------------------------



const		unsigned int	m_alloc_unknown        = 0;

const		unsigned int	m_alloc_new            = 1;

const		unsigned int	m_alloc_new_array      = 2;

const		unsigned int	m_alloc_malloc         = 3;

const		unsigned int	m_alloc_calloc         = 4;

const		unsigned int	m_alloc_realloc        = 5;

const		unsigned int	m_alloc_delete         = 6;

const		unsigned int	m_alloc_delete_array   = 7;

const		unsigned int	m_alloc_free           = 8;



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Get to know these values. They represent the values that will be used to fill unused and deallocated RAM.

// ---------------------------------------------------------------------------------------------------------------------------------



static		unsigned int	prefixPattern          = 0xbaadf00d; // Fill pattern for bytes preceeding allocated blocks

static		unsigned int	postfixPattern         = 0xdeadc0de; // Fill pattern for bytes following allocated blocks

static		unsigned int	unusedPattern          = 0xfeedface; // Fill pattern for freshly allocated blocks

static		unsigned int	releasedPattern        = 0xdeadbeef; // Fill pattern for deallocated blocks



// ---------------------------------------------------------------------------------------------------------------------------------

// Other locals

// ---------------------------------------------------------------------------------------------------------------------------------



static	const	unsigned int	hashSize               = 1 << hashBits;

static	const	char		*allocationTypes[]     = {"Unknown",

							  "new",     "new[]",  "malloc",   "calloc",

							  "realloc", "delete", "delete[]", "free"};

static		sAllocUnit	*hashTable[hashSize];

static		sAllocUnit	*reservoir;

static		unsigned int	currentAllocationCount = 0;

static		unsigned int	breakOnAllocationCount = 0;

static		sMStats		stats;

static	const	char		*sourceFile            = "??";

static	const	char		*sourceFunc            = "??";

static		unsigned int	sourceLine             = 0;

static		bool		staticDeinitTime       = false;

static		sAllocUnit	**reservoirBuffer      = NULL;

static		unsigned int	reservoirBufferSize    = 0;

static const	char		*memoryLogFile         = "memory.log";

static const	char		*memoryLeakLogFile     = "memleaks.log";

static		void		doCleanupLogOnFirstRun();



// ---------------------------------------------------------------------------------------------------------------------------------

// Local functions only

// ---------------------------------------------------------------------------------------------------------------------------------



static	void	log(const char *format, ...)

{

	// Cleanup the log?



	if (cleanupLogOnFirstRun) doCleanupLogOnFirstRun();



	// Build the buffer



	static char buffer[2048];

	va_list	ap;

	va_start(ap, format);

	vsprintf(buffer, format, ap);

	va_end(ap);



	// Open the log file



	FILE	*fp = fopen(memoryLogFile, "ab");



	// If you hit this assert, then the memory logger is unable to log information to a file (can't open the file for some

	// reason.) You can interrogate the variable 'buffer' to see what was supposed to be logged (but won't be.)

	m_assert(fp);



	if (!fp) return;



	// Spit out the data to the log



	fprintf(fp, "%s\r\n", buffer);

	fclose(fp);

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	doCleanupLogOnFirstRun()

{

	if (cleanupLogOnFirstRun)

	{

		unlink(memoryLogFile);

		cleanupLogOnFirstRun = false;



		// Print a header for the log



		time_t	t = time(NULL);

		log("--------------------------------------------------------------------------------");

		log("");

		log("      %s - Memory logging file created on %s", memoryLogFile, asctime(localtime(&t)));

		log("--------------------------------------------------------------------------------");

		log("");

		log("This file contains a log of all memory operations performed during the last run.");

		log("");

		log("Interrogate this file to track errors or to help track down memory-related");

		log("issues. You can do this by tracing the allocations performed by a specific owner");

		log("or by tracking a specific address through a series of allocations and");

		log("reallocations.");

		log("");

		log("There is a lot of useful information here which, when used creatively, can be");

		log("extremely helpful.");

		log("");

		log("Note that the following guides are used throughout this file:");

		log("");

		log("   [!] - Error");

		log("   [+] - Allocation");

		log("   [~] - Reallocation");

		log("   [-] - Deallocation");

		log("   [I] - Generic information");

		log("   [F] - Failure induced for the purpose of stress-testing your application");

		log("   [D] - Information used for debugging this memory manager");

		log("");

		log("...so, to find all errors in the file, search for \"[!]\"");

		log("");

		log("--------------------------------------------------------------------------------");

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	const char	*sourceFileStripper(const char *sourceFile)

{

	char	*ptr = strrchr(sourceFile, '\\');

	if (ptr) return ptr + 1;

	ptr = strrchr(sourceFile, '/');

	if (ptr) return ptr + 1;

	return sourceFile;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	const char	*ownerString(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc)

{

	static	char	str[90];

	memset(str, 0, sizeof(str));

	sprintf(str, "%s(%05d)::%s", sourceFileStripper(sourceFile), sourceLine, sourceFunc);

	return str;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	const char	*insertCommas(unsigned int value)

{

	static	char	str[30];

	memset(str, 0, sizeof(str));



	sprintf(str, "%u", value);

	if (strlen(str) > 3)

	{

		memmove(&str[strlen(str)-3], &str[strlen(str)-4], 4);

		str[strlen(str) - 4] = ',';

	}

	if (strlen(str) > 7)

	{

		memmove(&str[strlen(str)-7], &str[strlen(str)-8], 8);

		str[strlen(str) - 8] = ',';

	}

	if (strlen(str) > 11)

	{

		memmove(&str[strlen(str)-11], &str[strlen(str)-12], 12);

		str[strlen(str) - 12] = ',';

	}



	return str;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	const char	*memorySizeString(unsigned long size)

{

	static	char	str[90];

	     if (size > (1024*1024))	sprintf(str, "%10s (%7.2fM)", insertCommas(size), static_cast<float>(size) / (1024.0f * 1024.0f));

	else if (size > 1024)		sprintf(str, "%10s (%7.2fK)", insertCommas(size), static_cast<float>(size) / 1024.0f);

	else				sprintf(str, "%10s bytes     ", insertCommas(size));

	return str;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	sAllocUnit	*findAllocUnit(const void *reportedAddress)

{

	// Just in case...

	m_assert(reportedAddress != NULL);



	// Use the address to locate the hash index. Note that we shift off the lower four bits. This is because most allocated

	// addresses will be on four-, eight- or even sixteen-byte boundaries. If we didn't do this, the hash index would not have

	// very good coverage.



	unsigned int	hashIndex = (reinterpret_cast<unsigned int>(const_cast<void *>(reportedAddress)) >> 4) & (hashSize - 1);

	sAllocUnit	*ptr = hashTable[hashIndex];

	while(ptr)

	{

		if (ptr->reportedAddress == reportedAddress) return ptr;

		ptr = ptr->next;

	}



	return NULL;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	size_t	calculateActualSize(const size_t reportedSize)

{

	// We use DWORDS as our padding, and a long is guaranteed to be 4 bytes, but an int is not (ANSI defines an int as

	// being the standard word size for a processor; on a 32-bit machine, that's 4 bytes, but on a 64-bit machine, it's

	// 8 bytes, which means an int can actually be larger than a long.)



	return reportedSize + paddingSize * sizeof(long) * 2;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	size_t	calculateReportedSize(const size_t actualSize)

{

	// We use DWORDS as our padding, and a long is guaranteed to be 4 bytes, but an int is not (ANSI defines an int as

	// being the standard word size for a processor; on a 32-bit machine, that's 4 bytes, but on a 64-bit machine, it's

	// 8 bytes, which means an int can actually be larger than a long.)



	return actualSize - paddingSize * sizeof(long) * 2;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	*calculateReportedAddress(const void *actualAddress)

{

	// We allow this...



	if (!actualAddress) return NULL;



	// JUst account for the padding



	return reinterpret_cast<void *>(const_cast<char *>(reinterpret_cast<const char *>(actualAddress) + sizeof(long) * paddingSize));

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	wipeWithPattern(sAllocUnit *allocUnit, unsigned long pattern, const unsigned int originalReportedSize = 0)

{

	// For a serious test run, we use wipes of random a random value. However, if this causes a crash, we don't want it to

	// crash in a differnt place each time, so we specifically DO NOT call srand. If, by chance your program calls srand(),

	// you may wish to disable that when running with a random wipe test. This will make any crashes more consistent so they

	// can be tracked down easier.



	if (randomWipe)

	{

		pattern = ((rand() & 0xff) << 24) | ((rand() & 0xff) << 16) | ((rand() & 0xff) << 8) | (rand() & 0xff);

	}



	// -DOC- We should wipe with 0's if we're not in debug mode, so we can help hide bugs if possible when we release the

	// product. So uncomment the following line for releases.

	//

	// Note that the "alwaysWipeAll" should be turned on for this to have effect, otherwise it won't do much good. But we'll

	// leave it this way (as an option) because this does slow things down.

//	pattern = 0;



	// This part of the operation is optional



	if (alwaysWipeAll && allocUnit->reportedSize > originalReportedSize)

	{

		// Fill the bulk



		long	*lptr = reinterpret_cast<long *>(reinterpret_cast<char *>(allocUnit->reportedAddress) + originalReportedSize);

		int	length = static_cast<int>(allocUnit->reportedSize - originalReportedSize);

		int	i;

		for (i = 0; i < (length >> 2); i++, lptr++)

		{

			*lptr = pattern;

		}



		// Fill the remainder



		unsigned int	shiftCount = 0;

		char		*cptr = reinterpret_cast<char *>(lptr);

		for (i = 0; i < (length & 0x3); i++, cptr++, shiftCount += 8)

		{

			*cptr = static_cast<char>((pattern & (0xff << shiftCount)) >> shiftCount);

		}

	}



	// Write in the prefix/postfix bytes



	long		*pre = reinterpret_cast<long *>(allocUnit->actualAddress);

	long		*post = reinterpret_cast<long *>(reinterpret_cast<char *>(allocUnit->actualAddress) + allocUnit->actualSize - paddingSize * sizeof(long));

	for (unsigned int i = 0; i < paddingSize; i++, pre++, post++)

	{

		*pre = prefixPattern;

		*post = postfixPattern;

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	dumpAllocations(FILE *fp)

{

	fprintf(fp, "Alloc.   Addr       Size       Addr       Size                        BreakOn BreakOn              \r\n");

	fprintf(fp, "Number Reported   Reported    Actual     Actual     Unused    Method  Dealloc Realloc Allocated by \r\n");

	fprintf(fp, "------ ---------- ---------- ---------- ---------- ---------- -------- ------- ------- --------------------------------------------------- \r\n");





	for (unsigned int i = 0; i < hashSize; i++)

	{

		sAllocUnit *ptr = hashTable[i];

		while(ptr)

		{

			fprintf(fp, "%06d 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X %-8s    %c       %c    %s\r\n",

				ptr->allocationNumber,

				reinterpret_cast<unsigned int>(ptr->reportedAddress), ptr->reportedSize,

				reinterpret_cast<unsigned int>(ptr->actualAddress), ptr->actualSize,

				m_calcUnused(ptr),

				allocationTypes[ptr->allocationType],

				ptr->breakOnDealloc ? 'Y':'N',

				ptr->breakOnRealloc ? 'Y':'N',

				ownerString(ptr->sourceFile, ptr->sourceLine, ptr->sourceFunc));

			ptr = ptr->next;

		}

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	dumpLeakReport()

{

	// Open the report file



	FILE	*fp = fopen(memoryLeakLogFile, "w+b");



	// If you hit this assert, then the memory report generator is unable to log information to a file (can't open the file for

	// some reason.)

	m_assert(fp);

	if (!fp) return;



	// Any leaks?



	// Header



	static  char    timeString[25];

	memset(timeString, 0, sizeof(timeString));

	time_t  t = time(NULL);

	struct  tm *tme = localtime(&t);

	fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n");

	fprintf(fp, "|                                          Memory leak report for:  %02d/%02d/%04d %02d:%02d:%02d                                            |\r\n", tme->tm_mon + 1, tme->tm_mday, tme->tm_year + 1900, tme->tm_hour, tme->tm_min, tme->tm_sec);

	fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n");

	fprintf(fp, "\r\n");

	fprintf(fp, "\r\n");

	if (stats.totalAllocUnitCount)

	{

		fprintf(fp, "%d memory leak%s found:\r\n", stats.totalAllocUnitCount, stats.totalAllocUnitCount == 1 ? "":"s");

	}

	else

	{

		fprintf(fp, "Congratulations! No memory leaks found!\r\n");



		// We can finally free up our own memory allocations



		if (reservoirBuffer)

		{

			for (unsigned int i = 0; i < reservoirBufferSize; i++)

			{

				free(reservoirBuffer[i]);

			}

			free(reservoirBuffer);

			reservoirBuffer = 0;

			reservoirBufferSize = 0;

			reservoir = NULL;

		}

	}

	fprintf(fp, "\r\n");



	if (stats.totalAllocUnitCount)

	{

		dumpAllocations(fp);

	}



	fclose(fp);

}



// ---------------------------------------------------------------------------------------------------------------------------------

// We use a static class to let us know when we're in the midst of static deinitialization

// ---------------------------------------------------------------------------------------------------------------------------------



class	MemStaticTimeTracker

{

public:

	MemStaticTimeTracker() {doCleanupLogOnFirstRun();}

	~MemStaticTimeTracker() {staticDeinitTime = true; dumpLeakReport();}

};

static	MemStaticTimeTracker	mstt;



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Flags & options -- Call these routines to enable/disable the following options

// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_alwaysValidateAll()

{

	// Force a validation of all allocation units each time we enter this software

	return alwaysValidateAll;

}



// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_alwaysLogAll()

{

	// Force a log of every allocation & deallocation into memory.log

	return alwaysLogAll;

}



// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_alwaysWipeAll()

{

	// Force this software to always wipe memory with a pattern when it is being allocated/dallocated

	return alwaysWipeAll;

}



// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_randomeWipe()

{

	// Force this software to use a random pattern when wiping memory -- good for stress testing

	return randomWipe;

}



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Simply call this routine with the address of an allocated block of RAM, to cause it to force a breakpoint when it is

// reallocated.

// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_breakOnRealloc(void *reportedAddress)

{

	// Locate the existing allocation unit



	sAllocUnit	*au = findAllocUnit(reportedAddress);



	// If you hit this assert, you tried to set a breakpoint on reallocation for an address that doesn't exist. Interrogate the

	// stack frame or the variable 'au' to see which allocation this is.

	m_assert(au != NULL);



	// If you hit this assert, you tried to set a breakpoint on reallocation for an address that wasn't allocated in a way that

	// is compatible with reallocation.

	m_assert(au->allocationType == m_alloc_malloc ||

		 au->allocationType == m_alloc_calloc ||

		 au->allocationType == m_alloc_realloc);



	return au->breakOnRealloc;

}



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- Simply call this routine with the address of an allocated block of RAM, to cause it to force a breakpoint when it is

// deallocated.

// ---------------------------------------------------------------------------------------------------------------------------------



bool	&m_breakOnDealloc(void *reportedAddress)

{

	// Locate the existing allocation unit



	sAllocUnit	*au = findAllocUnit(reportedAddress);



	// If you hit this assert, you tried to set a breakpoint on deallocation for an address that doesn't exist. Interrogate the

	// stack frame or the variable 'au' to see which allocation this is.

	m_assert(au != NULL);



	return au->breakOnDealloc;

}



// ---------------------------------------------------------------------------------------------------------------------------------

// -DOC- When tracking down a difficult bug, use this routine to force a breakpoint on a specific allocation count

// ---------------------------------------------------------------------------------------------------------------------------------



void	m_breakOnAllocation(unsigned int count)

{

	breakOnAllocationCount = count;

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Used by the macros

// ---------------------------------------------------------------------------------------------------------------------------------



void	m_setOwner(const char *file, const unsigned int line, const char *func)

{

	// You're probably wondering about this...

	//

	// It's important for this memory manager to primarily work with global new/delete in their original forms (i.e. with

	// no extra parameters.) In order to do this, we use macros that call this function prior to operators new & delete. This

	// is fine... usually. Here's what actually happens when you use this macro to delete an object:

	//

	// m_setOwner(__FILE__, __LINE__, __FUNCTION__) --> object::~object() --> delete

	//

	// Note that the compiler inserts a call to the object's destructor just prior to calling our overridden operator delete.

	// But what happens when we delete an object whose destructor deletes another object, whose desctuctor deletes another

	// object? Here's a diagram (indentation follows stack depth):

	//

	// m_setOwner(...) -> ~obj1()                          // original call to delete obj1

	//     m_setOwner(...) -> ~obj2()                      // obj1's destructor deletes obj2

	//         m_setOwner(...) -> ~obj3()                  // obj2's destructor deletes obj3

	//             ...                                     // obj3's destructor just does some stuff

	//         delete                                      // back in obj2's destructor, we call delete

	//     delete                                          // back in obj1's destructor, we call delete

	// delete                                              // back to our original call, we call delete

	//

	// Because m_setOwner() just sets up some static variables (below) it's important that each call to m_setOwner() and

	// successive calls to new/delete alternate. However, in this case, three calls to m_setOwner() happen in succession

	// followed by three calls to delete in succession (with a few calls to destructors mixed in for fun.) This means that

	// only the final call to delete (in this chain of events) will have the proper reporting, and the first two in the chain

	// will not have ANY owner-reporting information. The deletes will still work fine, we just won't know who called us.

	//

	// "Then build a stack, my friend!" you might think... but it's a very common thing that people will be working with third-

	// party libraries (including MFC under Windows) which is not compiled with this memory manager's macros. In those cases,

	// m_setOwner() is never called, and rightfully should not have the proper trace-back information. So if one of the

	// destructors in the chain ends up being a call to a delete from a non-mmgr-compiled library, the stack will get confused.

	//

	// I've been unable to find a solution to this problem, but at least we can detect it and report the data before we

	// lose it. That's what this is all about. It makes it somewhat confusing to read in the logs, but at least ALL the

	// information is present...

	//

	// There's a caveat here... The compiler is not required to call operator delete if the value being deleted is NULL.

	// In this case, any call to delete with a NULL will sill call m_setOwner(), which will make m_setOwner() think that

	// there is a destructor chain becuase we setup the variables, but nothing gets called to clear them. Because of this

	// we report a "Possible destructor chain".

	//

	// Thanks to J. Woznack (from Kodiak Interactive Software Studios -- www.kodiakgames.com) for pointing this out.



	if (sourceLine && alwaysLogAll)

	{

		log("[I] NOTE! Possible destructor chain: previous owner is %s", ownerString(sourceFile, sourceLine, sourceFunc));

	}



	// Okay... save this stuff off so we can keep track of the caller



	sourceFile = file;

	sourceLine = line;

	sourceFunc = func;

}



// ---------------------------------------------------------------------------------------------------------------------------------



static	void	resetGlobals()

{

	sourceFile = "??";

	sourceLine = 0;

	sourceFunc = "??";

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Global new/new[]

//

// These are the standard new/new[] operators. They are merely interface functions that operate like normal new/new[], but use our

// memory tracking routines.

// ---------------------------------------------------------------------------------------------------------------------------------



void	*operator new(size_t reportedSize)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: new");

	#endif



	// Save these off...



	const	char		*file = sourceFile;

	const	unsigned int	line = sourceLine;

	const	char		*func = sourceFunc;



	// ANSI says: allocation requests of 0 bytes will still return a valid value



	if (reportedSize == 0) reportedSize = 1;



	// ANSI says: loop continuously because the error handler could possibly free up some memory



	for(;;)

	{

		// Try the allocation



		void	*ptr = m_allocator(file, line, func, m_alloc_new, reportedSize);

		if (ptr)

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new");

			#endif

			return ptr;

		}



		// There isn't a way to determine the new handler, except through setting it. So we'll just set it to NULL, then

		// set it back again.



		new_handler	nh = std::set_new_handler(0);

		std::set_new_handler(nh);



		// If there is an error handler, call it



		if (nh)

		{

			(*nh)();

		}



		// Otherwise, throw the exception



		else

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new");

			#endif

			throw std::bad_alloc();

		}

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------



void	*operator new[](size_t reportedSize)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: new[]");

	#endif



	// Save these off...



	const	char		*file = sourceFile;

	const	unsigned int	line = sourceLine;

	const	char		*func = sourceFunc;



	// The ANSI standard says that allocation requests of 0 bytes will still return a valid value



	if (reportedSize == 0) reportedSize = 1;



	// ANSI says: loop continuously because the error handler could possibly free up some memory



	for(;;)

	{

		// Try the allocation



		void	*ptr = m_allocator(file, line, func, m_alloc_new_array, reportedSize);

		if (ptr)

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new[]");

			#endif

			return ptr;

		}



		// There isn't a way to determine the new handler, except through setting it. So we'll just set it to NULL, then

		// set it back again.



		new_handler	nh = std::set_new_handler(0);

		std::set_new_handler(nh);



		// If there is an error handler, call it



		if (nh)

		{

			(*nh)();

		}



		// Otherwise, throw the exception



		else

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new[]");

			#endif

			throw std::bad_alloc();

		}

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Other global new/new[]

//

// These are the standard new/new[] operators as used by Microsoft's memory tracker. We don't want them interfering with our memory

// tracking efforts. Like the previous versions, these are merely interface functions that operate like normal new/new[], but use

// our memory tracking routines.

// ---------------------------------------------------------------------------------------------------------------------------------



void	*operator new(size_t reportedSize, const char *sourceFile, int sourceLine)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: new");

	#endif



	// The ANSI standard says that allocation requests of 0 bytes will still return a valid value



	if (reportedSize == 0) reportedSize = 1;



	// ANSI says: loop continuously because the error handler could possibly free up some memory



	for(;;)

	{

		// Try the allocation



		void	*ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new, reportedSize);

		if (ptr)

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new");

			#endif

			return ptr;

		}



		// There isn't a way to determine the new handler, except through setting it. So we'll just set it to NULL, then

		// set it back again.



		new_handler	nh = std::set_new_handler(0);

		std::set_new_handler(nh);



		// If there is an error handler, call it



		if (nh)

		{

			(*nh)();

		}



		// Otherwise, throw the exception



		else

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new");

			#endif

			throw std::bad_alloc();

		}

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------



void	*operator new[](size_t reportedSize, const char *sourceFile, int sourceLine)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: new[]");

	#endif



	// The ANSI standard says that allocation requests of 0 bytes will still return a valid value



	if (reportedSize == 0) reportedSize = 1;



	// ANSI says: loop continuously because the error handler could possibly free up some memory



	for(;;)

	{

		// Try the allocation



		void	*ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new_array, reportedSize);

		if (ptr)

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new[]");

			#endif

			return ptr;

		}



		// There isn't a way to determine the new handler, except through setting it. So we'll just set it to NULL, then

		// set it back again.



		new_handler	nh = std::set_new_handler(0);

		std::set_new_handler(nh);



		// If there is an error handler, call it



		if (nh)

		{

			(*nh)();

		}



		// Otherwise, throw the exception



		else

		{

			#ifdef TEST_MEMORY_MANAGER

			log("[D] EXIT : new[]");

			#endif

			throw std::bad_alloc();

		}

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Global delete/delete[]

//

// These are the standard delete/delete[] operators. They are merely interface functions that operate like normal delete/delete[],

// but use our memory tracking routines.

// ---------------------------------------------------------------------------------------------------------------------------------



void	operator delete(void *reportedAddress)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: delete");

	#endif



	// ANSI says: delete & delete[] allow NULL pointers (they do nothing)



	if (reportedAddress) m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete, reportedAddress);

	else if (alwaysLogAll) log("[-] ----- %8s of NULL                      by %s", allocationTypes[m_alloc_delete], ownerString(sourceFile, sourceLine, sourceFunc));



	// Resetting the globals insures that if at some later time, somebody calls our memory manager from an unknown

	// source (i.e. they didn't include our H file) then we won't think it was the last allocation.



	resetGlobals();



	#ifdef TEST_MEMORY_MANAGER

	log("[D] EXIT : delete");

	#endif

}



// ---------------------------------------------------------------------------------------------------------------------------------



void	operator delete[](void *reportedAddress)

{

	#ifdef TEST_MEMORY_MANAGER

	log("[D] ENTER: delete[]");

	#endif



	// ANSI says: delete & delete[] allow NULL pointers (they do nothing)



	if (reportedAddress) m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete_array, reportedAddress);

	else if (alwaysLogAll)

		log("[-] ----- %8s of NULL                      by %s", allocationTypes[m_alloc_delete_array], ownerString(sourceFile, sourceLine, sourceFunc));



	// Resetting the globals insures that if at some later time, somebody calls our memory manager from an unknown

	// source (i.e. they didn't include our H file) then we won't think it was the last allocation.



	resetGlobals();



	#ifdef TEST_MEMORY_MANAGER

	log("[D] EXIT : delete[]");

	#endif

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Allocate memory and track it

// ---------------------------------------------------------------------------------------------------------------------------------



void	*m_allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, const unsigned int allocationType, const size_t reportedSize)

{

	try

	{

		#ifdef TEST_MEMORY_MANAGER

		log("[D] ENTER: m_allocator()");

		#endif



		// Increase our allocation count



		currentAllocationCount++;



		// Log the request



		if (alwaysLogAll) log("[+] %05d %8s of size 0x%08X(%08d) by %s", currentAllocationCount, allocationTypes[allocationType], reportedSize, reportedSize, ownerString(sourceFile, sourceLine, sourceFunc));



		// If you hit this assert, you requested a breakpoint on a specific allocation count

		m_assert(currentAllocationCount != breakOnAllocationCount);



		// If necessary, grow the reservoir of unused allocation units



		if (!reservoir)

		{

			// Allocate 256 reservoir elements



			reservoir = (sAllocUnit *) malloc(sizeof(sAllocUnit) * 256);



			// If you hit this assert, then the memory manager failed to allocate internal memory for tracking the

			// allocations

			m_assert(reservoir != NULL);



			// Danger Will Robinson!



			if (reservoir == NULL) throw "Unable to allocate RAM for internal memory tracking data";



			// Build a linked-list of the elements in our reservoir



			memset(reservoir, 0, sizeof(sAllocUnit) * 256);

			for (unsigned int i = 0; i < 256 - 1; i++)

			{

				reservoir[i].next = &reservoir[i+1];

			}



			// Add this address to our reservoirBuffer so we can free it later



			sAllocUnit	**temp = (sAllocUnit **) realloc(reservoirBuffer, (reservoirBufferSize + 1) * sizeof(sAllocUnit *));

			m_assert(temp);

			if (temp)

			{

				reservoirBuffer = temp;

				reservoirBuffer[reservoirBufferSize++] = reservoir;

			}

		}



		// Logical flow says this should never happen...

		m_assert(reservoir != NULL);



		// Grab a new allocaton unit from the front of the reservoir



		sAllocUnit	*au = reservoir;

		reservoir = au->next;



		// Populate it with some real data



		memset(au, 0, sizeof(sAllocUnit));

		au->actualSize        = calculateActualSize(reportedSize);

		#ifdef RANDOM_FAILURE

		double	a = rand();

		double	b = RAND_MAX / 100.0 * RANDOM_FAILURE;

		if (a > b)

		{

			au->actualAddress = malloc(au->actualSize);

		}

		else

		{

			log("[F] Random faiure");

			au->actualAddress = NULL;

		}

		#else

		au->actualAddress     = malloc(au->actualSize);

		#endif

		au->reportedSize      = reportedSize;

		au->reportedAddress   = calculateReportedAddress(au->actualAddress);

		au->allocationType    = allocationType;

		au->sourceLine        = sourceLine;

		au->allocationNumber  = currentAllocationCount;

		if (sourceFile) strncpy(au->sourceFile, sourceFileStripper(sourceFile), sizeof(au->sourceFile) - 1);

		else		strcpy (au->sourceFile, "??");

		if (sourceFunc) strncpy(au->sourceFunc, sourceFunc, sizeof(au->sourceFunc) - 1);

		else		strcpy (au->sourceFunc, "??");



		// We don't want to assert with random failures, because we want the application to deal with them.



		#ifndef RANDOM_FAILURE

		// If you hit this assert, then the requested allocation simply failed (you're out of memory.) Interrogate the

		// variable 'au' or the stack frame to see what you were trying to do.

		m_assert(au->actualAddress != NULL);

		#endif



		if (au->actualAddress == NULL)

		{

			throw "Request for allocation failed. Out of memory.";

		}



		// If you hit this assert, then this allocation was made from a source that isn't setup to use this memory tracking

		// software, use the stack frame to locate the source and include our H file.

		m_assert(allocationType != m_alloc_unknown);



		// Insert the new allocation into the hash table



		unsigned int	hashIndex = (reinterpret_cast<unsigned int>(au->reportedAddress) >> 4) & (hashSize - 1);

		if (hashTable[hashIndex]) hashTable[hashIndex]->prev = au;

		au->next = hashTable[hashIndex];

		au->prev = NULL;

		hashTable[hashIndex] = au;



		// Account for the new allocatin unit in our stats



		stats.totalReportedMemory += static_cast<unsigned int>(au->reportedSize);

		stats.totalActualMemory   += static_cast<unsigned int>(au->actualSize);

		stats.totalAllocUnitCount++;

		if (stats.totalReportedMemory > stats.peakReportedMemory) stats.peakReportedMemory = stats.totalReportedMemory;

		if (stats.totalActualMemory   > stats.peakActualMemory)   stats.peakActualMemory   = stats.totalActualMemory;

		if (stats.totalAllocUnitCount > stats.peakAllocUnitCount) stats.peakAllocUnitCount = stats.totalAllocUnitCount;

		stats.accumulatedReportedMemory += static_cast<unsigned int>(au->reportedSize);

		stats.accumulatedActualMemory += static_cast<unsigned int>(au->actualSize);

		stats.accumulatedAllocUnitCount++;



		// Prepare the allocation unit for use (wipe it with recognizable garbage)



		wipeWithPattern(au, unusedPattern);



		// calloc() expects the reported memory address range to be filled with 0's



		if (allocationType == m_alloc_calloc)

		{

			memset(au->reportedAddress, 0, au->reportedSize);

		}



		// Validate every single allocated unit in memory



		if (alwaysValidateAll) m_validateAllAllocUnits();



		// Log the result



		if (alwaysLogAll) log("[+] ---->             addr 0x%08X", reinterpret_cast<unsigned int>(au->reportedAddress));



		// Resetting the globals insures that if at some later time, somebody calls our memory manager from an unknown

		// source (i.e. they didn't include our H file) then we won't think it was the last allocation.



		resetGlobals();



		// Return the (reported) address of the new allocation unit



		#ifdef TEST_MEMORY_MANAGER

		log("[D] EXIT : m_allocator()");

		#endif



		return au->reportedAddress;

	}

	catch(const char *err)

	{

		// Deal with the errors



		log("[!] %s", err);

		resetGlobals();



		#ifdef TEST_MEMORY_MANAGER

		log("[D] EXIT : m_allocator()");

		#endif



		return NULL;

	}

}



// ---------------------------------------------------------------------------------------------------------------------------------

// Reallocate memory and track it

// ---------------------------------------------------------------------------------------------------------------------------------



void	*m_reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress)

{

	try

	{

		#ifdef TEST_MEMORY_MANAGER

		log("[D] ENTER: m_reallocator()");

		#endif



		// C…

Large files files are truncated, but you can click here to view the full file