diff --git a/Make/makedefs.linux b/Make/makedefs.linux index 79c6efb4b..db7c0ae02 100644 --- a/Make/makedefs.linux +++ b/Make/makedefs.linux @@ -10,16 +10,16 @@ C++ = g++ YFLAGS = -d LCINCS += -I/usr/X11R6/include LC++INCS += ${LCINCS} -CFLAGS = -O2 -W -Wall $(LCINCS) -'CFLAGS = -g -DOSG_USE_MEMORY_MANAGER -W -Wall $(LCINCS) +#CFLAGS = -O2 -W -Wall $(LCINCS) +CFLAGS = -g -DOSG_USE_MEMORY_MANAGER -W -Wall $(LCINCS) C++FLAGS = ${CFLAGS} CPPFLAGS = ${CFLAGS} SO_EXT = so DL_EXT = so -LDFLAGS = -O2 -W -Wall -L/usr/X11R6/lib -#LDFLAGS = -g -W -Wall -L/usr/X11R6/lib +#LDFLAGS = -O2 -W -Wall -L/usr/X11R6/lib +LDFLAGS = -g -W -Wall -L/usr/X11R6/lib LINKERARGS = -Xlinker DYNAMICLIBRARYLIB = -ldl diff --git a/include/osgUtil/SceneView b/include/osgUtil/SceneView index ca78bc45d..518a1147f 100644 --- a/include/osgUtil/SceneView +++ b/include/osgUtil/SceneView @@ -80,9 +80,12 @@ class OSGUTIL_EXPORT SceneView : public osg::Referenced /** Set the DisplaySettings. */ inline void setDisplaySettings(osg::DisplaySettings* vs) { _displaySettings = vs; } - /** Get the DisplaySettings */ + /** Get the const DisplaySettings */ inline const osg::DisplaySettings* getDisplaySettings() const { return _displaySettings.get(); } + /** Get the DisplaySettings */ + inline osg::DisplaySettings* getDisplaySettings() { return _displaySettings.get(); } + /** Set the background color used in glClearColor(). Defaults to an off blue color.*/ diff --git a/src/Demos/osgconv/osgconv.cpp b/src/Demos/osgconv/osgconv.cpp index 2cbb0df48..2a637ce3e 100644 --- a/src/Demos/osgconv/osgconv.cpp +++ b/src/Demos/osgconv/osgconv.cpp @@ -206,12 +206,12 @@ int main( int argc, char **argv ) fileNames.pop_back(); } - osg::Node* root = osgDB::readNodeFiles(fileNames); + osg::ref_ptr root = osgDB::readNodeFiles(fileNames); if( do_convert ) - root = oc.convert( root ); + root = oc.convert( root.get() ); - if (root) + if (root.valid()) { osgDB::writeNodeFile(*root,fileNameOut); osg::notify(osg::NOTICE)<<"Data written to '"< // Standard includes MUST come first -// #include // -// #include // +// #include // Standard includes MUST come first +// #include // +// #include // // -// #include "mmgr.h" // mmgr.h MUST come next +// #include "mmgr.h" // mmgr.h MUST come next // -// #include "myfile1.h" // Project includes MUST come last -// #include "myfile2.h" // -// #include "myfile3.h" // +// #include "myfile1.h" // Project includes MUST come last +// #include "myfile2.h" // +// #include "myfile3.h" // // // --------------------------------------------------------------------------------------------------------------------------------- #include @@ -59,7 +59,7 @@ #include #include -#ifndef WIN32 +#ifndef WIN32 #include #endif @@ -97,47 +97,47 @@ // If you truely suspect a bug in this memory manager (and you had better be sure about it! :) you can contact me at // midnight@GraphicsPapers.com. Before you do, however, check for a newer version at: // -// ftp://ftp.GraphicsPapers.com/pub/ProgrammingTools/MemoryManagers/ +// ftp://ftp.GraphicsPapers.com/pub/ProgrammingTools/MemoryManagers/ // // 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 +//#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 +//#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 100.0 +//#define RANDOM_FAILURE 100.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! +#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; +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 // --------------------------------------------------------------------------------------------------------------------------------- @@ -145,81 +145,99 @@ static const unsigned int paddingSize = 4; // simply declares a forced breakpoint. // --------------------------------------------------------------------------------------------------------------------------------- -#ifdef WIN32 - #ifdef _DEBUG - #define m_assert(x) if ((x) == false) __asm { int 3 } - #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 assert +#ifdef WIN32 + #ifdef _DEBUG + #define m_assert(x) if ((x) == false) __asm { int 3 } + #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 assert #endif // --------------------------------------------------------------------------------------------------------------------------------- // 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; +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 +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 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; // --------------------------------------------------------------------------------------------------------------------------------- // We use a static class to let us know when we're in the midst of static deinitialization // --------------------------------------------------------------------------------------------------------------------------------- -static void dumpLeakReport(); -static void doCleanupLogOnFirstRun(); +static void dumpLeakReport(); +static void doCleanupLogOnFirstRun(); +static void stressTest(); #ifdef OSG_USE_MEMORY_MANAGER -class MemStaticTimeTracker +class MemStaticTimeTracker { -public: - MemStaticTimeTracker() + public: + MemStaticTimeTracker() { doCleanupLogOnFirstRun(); + + char *ptr; + if( (ptr = getenv("OSG_MM_STRESS_TEST")) != 0) + { + } + + if( (ptr = getenv("OSG_MM_BREAK_ON_ALLOCATION")) != 0) + { + if (strcmp(ptr,"OFF")!=0) + { + int value = atoi(ptr); + m_breakOnAllocation(value); + } + } + + + } - ~MemStaticTimeTracker() + ~MemStaticTimeTracker() { staticDeinitTime = true; dumpLeakReport(); } }; -static MemStaticTimeTracker mstt; +static MemStaticTimeTracker mstt; #endif @@ -228,313 +246,323 @@ static MemStaticTimeTracker mstt; // Local functions only // --------------------------------------------------------------------------------------------------------------------------------- -static void doCleanupLogOnFirstRun() +static void stressTest() { - if (cleanupLogOnFirstRun) - { - unlink("memory.log"); - cleanupLogOnFirstRun = false; - } + randomWipe = true; + alwaysValidateAll = true; + alwaysLogAll = true; + alwaysWipeAll = true; + cleanupLogOnFirstRun = true; +} + + +static void doCleanupLogOnFirstRun() +{ + if (cleanupLogOnFirstRun) + { + unlink("memory.log"); + cleanupLogOnFirstRun = false; + } } // --------------------------------------------------------------------------------------------------------------------------------- -static const char *sourceFileStripper(const char *sourceFile) +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; + 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 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 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 const char *insertCommas(unsigned int value) { - static char str[30]; - memset(str, 0, sizeof(str)); + 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] = ','; - } + 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; + return str; } // --------------------------------------------------------------------------------------------------------------------------------- -static const char *memorySizeString(unsigned long size) +static const char *memorySizeString(unsigned long size) { - static char str[90]; - if (size > (1024*1024)) sprintf(str, "%10s (%7.2fM)", insertCommas(size), (float) size / (1024.0f * 1024.0f)); - else if (size > 1024) sprintf(str, "%10s (%7.2fK)", insertCommas(size), (float) size / 1024.0f); - else sprintf(str, "%10s bytes ", insertCommas(size)); - return str; + static char str[90]; + if (size > (1024*1024)) sprintf(str, "%10s (%7.2fM)", insertCommas(size), (float) size / (1024.0f * 1024.0f)); + else if (size > 1024) sprintf(str, "%10s (%7.2fK)", insertCommas(size), (float) size / 1024.0f); + else sprintf(str, "%10s bytes ", insertCommas(size)); + return str; } // --------------------------------------------------------------------------------------------------------------------------------- -static sAllocUnit *findAllocUnit(const void *reportedAddress) +static sAllocUnit *findAllocUnit(const void *reportedAddress) { - // Just in case... - m_assert(reportedAddress != NULL); + // 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. + // 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 = ((unsigned int) reportedAddress >> 4) & (hashSize - 1); - sAllocUnit *ptr = hashTable[hashIndex]; - while(ptr) - { - if (ptr->reportedAddress == reportedAddress) return ptr; - ptr = ptr->next; - } + unsigned int hashIndex = ((unsigned int) reportedAddress >> 4) & (hashSize - 1); + sAllocUnit *ptr = hashTable[hashIndex]; + while(ptr) + { + if (ptr->reportedAddress == reportedAddress) return ptr; + ptr = ptr->next; + } - return NULL; + return NULL; } // --------------------------------------------------------------------------------------------------------------------------------- -static size_t calculateActualSize(const size_t reportedSize) +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.) + // 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; + return reportedSize + paddingSize * sizeof(long) * 2; } // --------------------------------------------------------------------------------------------------------------------------------- -static size_t calculateReportedSize(const size_t actualSize) +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.) + // 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; + return actualSize - paddingSize * sizeof(long) * 2; } // --------------------------------------------------------------------------------------------------------------------------------- -static void *calculateReportedAddress(const void *actualAddress) +static void *calculateReportedAddress(const void *actualAddress) { - // We allow this... + // We allow this... - if (!actualAddress) return NULL; + if (!actualAddress) return NULL; - // JUst account for the padding + // JUst account for the padding - return (void *) ((char *) actualAddress + sizeof(long) * paddingSize); + return (void *) ((char *) actualAddress + sizeof(long) * paddingSize); } // --------------------------------------------------------------------------------------------------------------------------------- -static void wipeWithPattern(sAllocUnit *allocUnit, unsigned long pattern, const unsigned int originalReportedSize = 0) +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. + // 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); - } + 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; + // -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 + // This part of the operation is optional - if (alwaysWipeAll && allocUnit->reportedSize > originalReportedSize) - { - // Fill the bulk + if (alwaysWipeAll && allocUnit->reportedSize > originalReportedSize) + { + // Fill the bulk - long *lptr = (long *) ((char *)allocUnit->reportedAddress + originalReportedSize); - int length = allocUnit->reportedSize - originalReportedSize; - int i; - for (i = 0; i < (length >> 2); i++, lptr++) - { - *lptr = pattern; - } + long *lptr = (long *) ((char *)allocUnit->reportedAddress + originalReportedSize); + int length = allocUnit->reportedSize - originalReportedSize; + int i; + for (i = 0; i < (length >> 2); i++, lptr++) + { + *lptr = pattern; + } - // Fill the remainder + // Fill the remainder - unsigned int shiftCount = 0; - char *cptr = (char *) lptr; - for (i = 0; i < (length & 0x3); i++, cptr++, shiftCount += 8) - { - *cptr = (pattern & (0xff << shiftCount)) >> shiftCount; - } - } + unsigned int shiftCount = 0; + char *cptr = (char *) lptr; + for (i = 0; i < (length & 0x3); i++, cptr++, shiftCount += 8) + { + *cptr = (pattern & (0xff << shiftCount)) >> shiftCount; + } + } - // Write in the prefix/postfix bytes + // Write in the prefix/postfix bytes - long *pre = (long *) allocUnit->actualAddress; - long *post = (long *) ((char *)allocUnit->actualAddress + allocUnit->actualSize - paddingSize * sizeof(long)); - for (unsigned int i = 0; i < paddingSize; i++, pre++, post++) - { - *pre = prefixPattern; - *post = postfixPattern; - } + long *pre = (long *) allocUnit->actualAddress; + long *post = (long *) ((char *)allocUnit->actualAddress + allocUnit->actualSize - paddingSize * sizeof(long)); + for (unsigned int i = 0; i < paddingSize; i++, pre++, post++) + { + *pre = prefixPattern; + *post = postfixPattern; + } } // --------------------------------------------------------------------------------------------------------------------------------- -static void resetGlobals() +static void resetGlobals() { - sourceFile = "??"; - sourceLine = 0; - sourceFunc = "??"; + sourceFile = "??"; + sourceLine = 0; + sourceFunc = "??"; } // --------------------------------------------------------------------------------------------------------------------------------- -static void log(const char *format, ...) +static void log(const char *format, ...) { - // Build the buffer + // Build the buffer - static char buffer[2048]; - va_list ap; - va_start(ap, format); - vsprintf(buffer, format, ap); - va_end(ap); + static char buffer[2048]; + va_list ap; + va_start(ap, format); + vsprintf(buffer, format, ap); + va_end(ap); - // Cleanup the log? + // Cleanup the log? - if (cleanupLogOnFirstRun) doCleanupLogOnFirstRun(); + if (cleanupLogOnFirstRun) doCleanupLogOnFirstRun(); - // Open the log file + // Open the log file - FILE *fp = fopen("memory.log", "ab"); + FILE *fp = fopen("memory.log", "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 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; + if (!fp) return; - // Spit out the data to the log + // Spit out the data to the log - fprintf(fp, "%s\r\n", buffer); - fclose(fp); + fprintf(fp, "%s\r\n", buffer); + fclose(fp); } // --------------------------------------------------------------------------------------------------------------------------------- -static void dumpAllocations(FILE *fp) +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"); + 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, - (unsigned int) ptr->reportedAddress, ptr->reportedSize, - (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; - } - } + 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, + (unsigned int) ptr->reportedAddress, ptr->reportedSize, + (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() +static void dumpLeakReport() { - // Open the report file + // Open the report file - FILE *fp = fopen("memleaks.log", "w+b"); - //FILE *fp = stderr; + FILE *fp = fopen("memleaks.log", "w+b"); + //FILE *fp = stderr; - // 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; + // 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? + // Any leaks? - // Header + // 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"); + 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 + // 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 (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); - } + if (stats.totalAllocUnitCount) + { + dumpAllocations(fp); + } - fclose(fp); + fclose(fp); } @@ -542,34 +570,34 @@ static void dumpLeakReport() // -DOC- Flags & options -- Call these routines to enable/disable the following options // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_alwaysValidateAll() +bool &m_alwaysValidateAll() { - // Force a validation of all allocation units each time we enter this software - return alwaysValidateAll; + // Force a validation of all allocation units each time we enter this software + return alwaysValidateAll; } // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_alwaysLogAll() +bool &m_alwaysLogAll() { - // Force a log of every allocation & deallocation into memory.log - return alwaysLogAll; + // Force a log of every allocation & deallocation into memory.log + return alwaysLogAll; } // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_alwaysWipeAll() +bool &m_alwaysWipeAll() { - // Force this software to always wipe memory with a pattern when it is being allocated/dallocated - return alwaysWipeAll; + // Force this software to always wipe memory with a pattern when it is being allocated/dallocated + return alwaysWipeAll; } // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_randomeWipe() +bool &m_randomeWipe() { - // Force this software to use a random pattern when wiping memory -- good for stress testing - return randomWipe; + // Force this software to use a random pattern when wiping memory -- good for stress testing + return randomWipe; } // --------------------------------------------------------------------------------------------------------------------------------- @@ -577,23 +605,23 @@ bool &m_randomeWipe() // reallocated. // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_breakOnRealloc(void *reportedAddress) +bool &m_breakOnRealloc(void *reportedAddress) { - // Locate the existing allocation unit + // Locate the existing allocation unit - sAllocUnit *au = findAllocUnit(reportedAddress); + 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 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); + // 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; + return au->breakOnRealloc; } // --------------------------------------------------------------------------------------------------------------------------------- @@ -601,37 +629,37 @@ bool &m_breakOnRealloc(void *reportedAddress) // deallocated. // --------------------------------------------------------------------------------------------------------------------------------- -bool &m_breakOnDealloc(void *reportedAddress) +bool &m_breakOnDealloc(void *reportedAddress) { - // Locate the existing allocation unit + // Locate the existing allocation unit - sAllocUnit *au = findAllocUnit(reportedAddress); + 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); + // 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; + 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) +void m_breakOnAllocation(unsigned int count) { - breakOnAllocationCount = count; + breakOnAllocationCount = count; } // --------------------------------------------------------------------------------------------------------------------------------- // Used by the macros // --------------------------------------------------------------------------------------------------------------------------------- -void m_setOwner(const char *file, const unsigned int line, const char *func) +void m_setOwner(const char *file, const unsigned int line, const char *func) { - sourceFile = file; - sourceLine = line; - sourceFunc = func; + sourceFile = file; + sourceLine = line; + sourceFunc = func; } // --------------------------------------------------------------------------------------------------------------------------------- @@ -643,106 +671,106 @@ void m_setOwner(const char *file, const unsigned int line, const char *func) #ifdef OSG_USE_MEMORY_MANAGER -void *operator new(size_t reportedSize) throw (std::bad_alloc) +void *operator new(size_t reportedSize) throw (std::bad_alloc) { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: new"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: new"); + #endif - // ANSI says: allocation requests of 0 bytes will still return a valid value + // ANSI says: allocation requests of 0 bytes will still return a valid value - if (reportedSize == 0) reportedSize = 1; + if (reportedSize == 0) reportedSize = 1; - // ANSI says: loop continuously because the error handler could possibly free up some memory + // ANSI says: loop continuously because the error handler could possibly free up some memory - for(;;) - { - // Try the allocation + for(;;) + { + // Try the allocation - void *ptr = m_allocator(sourceFile, sourceLine, sourceFunc, m_alloc_new, reportedSize); - if (ptr) - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new"); - #endif - return ptr; - } + void *ptr = m_allocator(sourceFile, sourceLine, sourceFunc, m_alloc_new, reportedSize); + if (ptr) + { + #ifdef TEST_MEMORY_MANAGER + log("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. + // 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 = set_new_handler(0); - set_new_handler(nh); + new_handler nh = set_new_handler(0); + set_new_handler(nh); - // If there is an error handler, call it + // If there is an error handler, call it - if (nh) - { - (*nh)(); - } + if (nh) + { + (*nh)(); + } - // Otherwise, throw the exception + // Otherwise, throw the exception - else - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new"); - #endif - throw std::bad_alloc(); - } - } + else + { + #ifdef TEST_MEMORY_MANAGER + log("EXIT : new"); + #endif + throw std::bad_alloc(); + } + } } // --------------------------------------------------------------------------------------------------------------------------------- -void *operator new[](size_t reportedSize) throw (std::bad_alloc) +void *operator new[](size_t reportedSize) throw (std::bad_alloc) { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: new[]"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: new[]"); + #endif - // The ANSI standard says that allocation requests of 0 bytes will still return a valid value + // The ANSI standard says that allocation requests of 0 bytes will still return a valid value - if (reportedSize == 0) reportedSize = 1; + if (reportedSize == 0) reportedSize = 1; - // ANSI says: loop continuously because the error handler could possibly free up some memory + // ANSI says: loop continuously because the error handler could possibly free up some memory - for(;;) - { - // Try the allocation + for(;;) + { + // Try the allocation - void *ptr = m_allocator(sourceFile, sourceLine, sourceFunc, m_alloc_new_array, reportedSize); - if (ptr) - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new[]"); - #endif - return ptr; - } + void *ptr = m_allocator(sourceFile, sourceLine, sourceFunc, m_alloc_new_array, reportedSize); + if (ptr) + { + #ifdef TEST_MEMORY_MANAGER + log("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. + // 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 = set_new_handler(0); - set_new_handler(nh); + new_handler nh = set_new_handler(0); + set_new_handler(nh); - // If there is an error handler, call it + // If there is an error handler, call it - if (nh) - { - (*nh)(); - } + if (nh) + { + (*nh)(); + } - // Otherwise, throw the exception + // Otherwise, throw the exception - else - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new[]"); - #endif - throw std::bad_alloc(); - } - } + else + { + #ifdef TEST_MEMORY_MANAGER + log("EXIT : new[]"); + #endif + throw std::bad_alloc(); + } + } } // --------------------------------------------------------------------------------------------------------------------------------- @@ -753,106 +781,106 @@ void *operator new[](size_t reportedSize) throw (std::bad_alloc) // our memory tracking routines. // --------------------------------------------------------------------------------------------------------------------------------- -void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine) throw (std::bad_alloc) +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine) throw (std::bad_alloc) { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: new"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: new"); + #endif - // The ANSI standard says that allocation requests of 0 bytes will still return a valid value + // The ANSI standard says that allocation requests of 0 bytes will still return a valid value - if (reportedSize == 0) reportedSize = 1; + if (reportedSize == 0) reportedSize = 1; - // ANSI says: loop continuously because the error handler could possibly free up some memory + // ANSI says: loop continuously because the error handler could possibly free up some memory - for(;;) - { - // Try the allocation + for(;;) + { + // Try the allocation - void *ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new, reportedSize); - if (ptr) - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new"); - #endif - return ptr; - } + void *ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new, reportedSize); + if (ptr) + { + #ifdef TEST_MEMORY_MANAGER + log("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. + // 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 = set_new_handler(0); - set_new_handler(nh); + new_handler nh = set_new_handler(0); + set_new_handler(nh); - // If there is an error handler, call it + // If there is an error handler, call it - if (nh) - { - (*nh)(); - } + if (nh) + { + (*nh)(); + } - // Otherwise, throw the exception + // Otherwise, throw the exception - else - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new"); - #endif - throw std::bad_alloc(); - } - } + else + { + #ifdef TEST_MEMORY_MANAGER + log("EXIT : new"); + #endif + throw std::bad_alloc(); + } + } } // --------------------------------------------------------------------------------------------------------------------------------- -void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine) throw (std::bad_alloc) +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine) throw (std::bad_alloc) { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: new[]"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: new[]"); + #endif - // The ANSI standard says that allocation requests of 0 bytes will still return a valid value + // The ANSI standard says that allocation requests of 0 bytes will still return a valid value - if (reportedSize == 0) reportedSize = 1; + if (reportedSize == 0) reportedSize = 1; - // ANSI says: loop continuously because the error handler could possibly free up some memory + // ANSI says: loop continuously because the error handler could possibly free up some memory - for(;;) - { - // Try the allocation + for(;;) + { + // Try the allocation - void *ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new_array, reportedSize); - if (ptr) - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new[]"); - #endif - return ptr; - } + void *ptr = m_allocator(sourceFile, sourceLine, "??", m_alloc_new_array, reportedSize); + if (ptr) + { + #ifdef TEST_MEMORY_MANAGER + log("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. + // 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 = set_new_handler(0); - set_new_handler(nh); + new_handler nh = set_new_handler(0); + set_new_handler(nh); - // If there is an error handler, call it + // If there is an error handler, call it - if (nh) - { - (*nh)(); - } + if (nh) + { + (*nh)(); + } - // Otherwise, throw the exception + // Otherwise, throw the exception - else - { - #ifdef TEST_MEMORY_MANAGER - log("EXIT : new[]"); - #endif - throw std::bad_alloc(); - } - } + else + { + #ifdef TEST_MEMORY_MANAGER + log("EXIT : new[]"); + #endif + throw std::bad_alloc(); + } + } } // --------------------------------------------------------------------------------------------------------------------------------- @@ -862,40 +890,40 @@ void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine // but use our memory tracking routines. // --------------------------------------------------------------------------------------------------------------------------------- -void operator delete(void *reportedAddress) throw () +void operator delete(void *reportedAddress) throw () { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: delete"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: delete"); + #endif - // ANSI says: delete & delete[] allow NULL pointers (they do nothing) + // ANSI says: delete & delete[] allow NULL pointers (they do nothing) - if (!reportedAddress) return; + if (!reportedAddress) return; - m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete, reportedAddress); + m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete, reportedAddress); - #ifdef TEST_MEMORY_MANAGER - log("EXIT : delete"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : delete"); + #endif } // --------------------------------------------------------------------------------------------------------------------------------- -void operator delete[](void *reportedAddress) throw () +void operator delete[](void *reportedAddress) throw () { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: delete[]"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("ENTER: delete[]"); + #endif - // ANSI says: delete & delete[] allow NULL pointers (they do nothing) + // ANSI says: delete & delete[] allow NULL pointers (they do nothing) - if (!reportedAddress) return; + if (!reportedAddress) return; - m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete_array, reportedAddress); + m_deallocator(sourceFile, sourceLine, sourceFunc, m_alloc_delete_array, reportedAddress); - #ifdef TEST_MEMORY_MANAGER - log("EXIT : delete[]"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : delete[]"); + #endif } @@ -905,481 +933,481 @@ void operator delete[](void *reportedAddress) throw () // 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) +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("ENTER: m_allocator()"); - #endif + try + { + #ifdef TEST_MEMORY_MANAGER + log("ENTER: m_allocator()"); + #endif - // Increase our allocation count + // Increase our allocation count - currentAllocationCount++; + currentAllocationCount++; - // Log the request + // Log the request - if (alwaysLogAll) log("%05d %-40s %8s : %s", currentAllocationCount, ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[allocationType], memorySizeString(reportedSize)); + if (alwaysLogAll) log("%05d %-40s %8s : %s", currentAllocationCount, ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[allocationType], memorySizeString(reportedSize)); - // If you hit this assert, you requested a breakpoint on a specific allocation count - m_assert(currentAllocationCount != breakOnAllocationCount); + // 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 necessary, grow the reservoir of unused allocation units - if (!reservoir) - { - // Allocate 256 reservoir elements + if (!reservoir) + { + // Allocate 256 reservoir elements - reservoir = (sAllocUnit *) malloc(sizeof(sAllocUnit) * 256); + 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); + // 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! + // Danger Will Robinson! - if (reservoir == NULL) throw "Unable to allocate RAM for internal memory tracking data"; + if (reservoir == NULL) throw "Unable to allocate RAM for internal memory tracking data"; - // Build a linked-list of the elements in our reservoir + // 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]; - } + 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 + // 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; - } - } + 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); + // Logical flow says this should never happen... + m_assert(reservoir != NULL); - // Grab a new allocaton unit from the front of the reservoir + // Grab a new allocaton unit from the front of the reservoir - sAllocUnit *au = reservoir; - reservoir = au->next; + sAllocUnit *au = reservoir; + reservoir = au->next; - // Populate it with some real data + // 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("!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, "??"); + 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("!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. + // 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 + #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 (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); + // 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 + // Insert the new allocation into the hash table - unsigned int hashIndex = ((unsigned int) au->reportedAddress >> 4) & (hashSize - 1); - if (hashTable[hashIndex]) hashTable[hashIndex]->prev = au; - au->next = hashTable[hashIndex]; - au->prev = NULL; - hashTable[hashIndex] = au; + unsigned int hashIndex = ((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 + // Account for the new allocatin unit in our stats - stats.totalReportedMemory += au->reportedSize; - stats.totalActualMemory += 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 += au->reportedSize; - stats.accumulatedActualMemory += au->actualSize; - stats.accumulatedAllocUnitCount++; + stats.totalReportedMemory += au->reportedSize; + stats.totalActualMemory += 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 += au->reportedSize; + stats.accumulatedActualMemory += au->actualSize; + stats.accumulatedAllocUnitCount++; - // Prepare the allocation unit for use (wipe it with recognizable garbage) + // Prepare the allocation unit for use (wipe it with recognizable garbage) - wipeWithPattern(au, unusedPattern); + wipeWithPattern(au, unusedPattern); - // calloc() expects the reported memory address range to be filled with 0's + // calloc() expects the reported memory address range to be filled with 0's - if (allocationType == m_alloc_calloc) - { - memset(au->reportedAddress, 0, au->reportedSize); - } + if (allocationType == m_alloc_calloc) + { + memset(au->reportedAddress, 0, au->reportedSize); + } - // Validate every single allocated unit in memory + // Validate every single allocated unit in memory - if (alwaysValidateAll) m_validateAllAllocUnits(); + if (alwaysValidateAll) m_validateAllAllocUnits(); - // Log the result + // Log the result - if (alwaysLogAll) log(" OK: %010p (hash: %d)", au->reportedAddress, hashIndex); + if (alwaysLogAll) log(" OK: %010p (hash: %d)", au->reportedAddress, hashIndex); - // 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. + // 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(); + resetGlobals(); - // Return the (reported) address of the new allocation unit + // Return the (reported) address of the new allocation unit - #ifdef TEST_MEMORY_MANAGER - log("EXIT : m_allocator()"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : m_allocator()"); + #endif - return au->reportedAddress; - } - catch(const char *err) - { - // Deal with the errors + return au->reportedAddress; + } + catch(const char *err) + { + // Deal with the errors - log(err); - resetGlobals(); + log(err); + resetGlobals(); - #ifdef TEST_MEMORY_MANAGER - log("EXIT : m_allocator()"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : m_allocator()"); + #endif - return NULL; - } + 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) +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("ENTER: m_reallocator()"); - #endif + try + { + #ifdef TEST_MEMORY_MANAGER + log("ENTER: m_reallocator()"); + #endif - // Calling realloc with a NULL should force same operations as a malloc + // Calling realloc with a NULL should force same operations as a malloc - if (!reportedAddress) - { - return m_allocator(sourceFile, sourceLine, sourceFunc, reallocationType, reportedSize); - } + if (!reportedAddress) + { + return m_allocator(sourceFile, sourceLine, sourceFunc, reallocationType, reportedSize); + } - // Increase our allocation count + // Increase our allocation count - currentAllocationCount++; + currentAllocationCount++; - // If you hit this assert, you requested a breakpoint on a specific allocation count - m_assert(currentAllocationCount != breakOnAllocationCount); + // If you hit this assert, you requested a breakpoint on a specific allocation count + m_assert(currentAllocationCount != breakOnAllocationCount); - // Log the request + // Log the request - if (alwaysLogAll) log("%05d %-40s %8s(%010p): %s", currentAllocationCount, ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[reallocationType], reportedAddress, memorySizeString(reportedSize)); + if (alwaysLogAll) log("%05d %-40s %8s(%010p): %s", currentAllocationCount, ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[reallocationType], reportedAddress, memorySizeString(reportedSize)); - // Locate the existing allocation unit + // Locate the existing allocation unit - sAllocUnit *au = findAllocUnit(reportedAddress); + sAllocUnit *au = findAllocUnit(reportedAddress); - // If you hit this assert, you tried to reallocate RAM that wasn't allocated by this memory manager. - m_assert(au != NULL); - if (au == NULL) throw "Request to reallocate RAM that was never allocated"; + // If you hit this assert, you tried to reallocate RAM that wasn't allocated by this memory manager. + m_assert(au != NULL); + if (au == NULL) throw "Request to reallocate RAM that was never allocated"; - // If you hit this assert, then the allocation unit that is about to be reallocated is damaged. But you probably - // already know that from a previous assert you should have seen in validateAllocUnit() :) - m_assert(m_validateAllocUnit(au)); + // If you hit this assert, then the allocation unit that is about to be reallocated is damaged. But you probably + // already know that from a previous assert you should have seen in validateAllocUnit() :) + m_assert(m_validateAllocUnit(au)); - // If you hit this assert, then this reallocation 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(reallocationType != m_alloc_unknown); + // If you hit this assert, then this reallocation 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(reallocationType != m_alloc_unknown); - // If you hit this assert, you were trying to reallocate RAM that was not allocated in a way that is compatible with - // realloc. In other words, you have a allocation/reallocation mismatch. - m_assert(au->allocationType == m_alloc_malloc || - au->allocationType == m_alloc_calloc || - au->allocationType == m_alloc_realloc); + // If you hit this assert, you were trying to reallocate RAM that was not allocated in a way that is compatible with + // realloc. In other words, you have a allocation/reallocation mismatch. + m_assert(au->allocationType == m_alloc_malloc || + au->allocationType == m_alloc_calloc || + au->allocationType == m_alloc_realloc); - // If you hit this assert, then the "break on realloc" flag for this allocation unit is set (and will continue to be - // set until you specifically shut it off. Interrogate the 'au' variable to determine information about this - // allocation unit. - m_assert(au->breakOnRealloc == false); + // If you hit this assert, then the "break on realloc" flag for this allocation unit is set (and will continue to be + // set until you specifically shut it off. Interrogate the 'au' variable to determine information about this + // allocation unit. + m_assert(au->breakOnRealloc == false); - // Keep track of the original size + // Keep track of the original size - unsigned int originalReportedSize = au->reportedSize; + unsigned int originalReportedSize = au->reportedSize; - // Do the reallocation + // Do the reallocation - void *oldReportedAddress = reportedAddress; - size_t newActualSize = calculateActualSize(reportedSize); - void *newActualAddress = NULL; - #ifdef RANDOM_FAILURE - double a = rand(); - double b = RAND_MAX / 100.0 * RANDOM_FAILURE; - if (a > b) - { - newActualAddress = realloc(au->actualAddress, newActualSize); - } - else - { - log("!Random faiure!"); - } - #else - newActualAddress = realloc(au->actualAddress, newActualSize); - #endif + void *oldReportedAddress = reportedAddress; + size_t newActualSize = calculateActualSize(reportedSize); + void *newActualAddress = NULL; + #ifdef RANDOM_FAILURE + double a = rand(); + double b = RAND_MAX / 100.0 * RANDOM_FAILURE; + if (a > b) + { + newActualAddress = realloc(au->actualAddress, newActualSize); + } + else + { + log("!Random faiure!"); + } + #else + newActualAddress = realloc(au->actualAddress, newActualSize); + #endif - // We don't want to assert with random failures, because we want the application to deal with them. + // 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' to see the original allocation. You can also query 'newActualSize' to see the amount of memory - // trying to be allocated. Finally, you can query 'reportedSize' to see how much memory was requested by the caller. - m_assert(newActualAddress); - #endif + #ifndef RANDOM_FAILURE + // If you hit this assert, then the requested allocation simply failed (you're out of memory) Interrogate the + // variable 'au' to see the original allocation. You can also query 'newActualSize' to see the amount of memory + // trying to be allocated. Finally, you can query 'reportedSize' to see how much memory was requested by the caller. + m_assert(newActualAddress); + #endif - if (!newActualAddress) throw "Request for reallocation failed. Out of memory."; + if (!newActualAddress) throw "Request for reallocation failed. Out of memory."; - // Remove this allocation from our stats (we'll add the new reallocation again later) + // Remove this allocation from our stats (we'll add the new reallocation again later) - stats.totalReportedMemory -= au->reportedSize; - stats.totalActualMemory -= au->actualSize; + stats.totalReportedMemory -= au->reportedSize; + stats.totalActualMemory -= au->actualSize; - // Update the allocation with the new information + // Update the allocation with the new information - au->actualSize = newActualSize; - au->actualAddress = newActualAddress; - au->reportedSize = calculateReportedSize(newActualSize); - au->reportedAddress = calculateReportedAddress(newActualAddress); - au->allocationType = reallocationType; - 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, "??"); + au->actualSize = newActualSize; + au->actualAddress = newActualAddress; + au->reportedSize = calculateReportedSize(newActualSize); + au->reportedAddress = calculateReportedAddress(newActualAddress); + au->allocationType = reallocationType; + 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, "??"); - // The reallocation may cause the address to change, so we should relocate our allocation unit within the hash table + // The reallocation may cause the address to change, so we should relocate our allocation unit within the hash table - unsigned int hashIndex = (unsigned int) -1; - if (oldReportedAddress != au->reportedAddress) - { - // Remove this allocation unit from the hash table + unsigned int hashIndex = (unsigned int) -1; + if (oldReportedAddress != au->reportedAddress) + { + // Remove this allocation unit from the hash table - { - unsigned int hashIndex = ((unsigned int) oldReportedAddress >> 4) & (hashSize - 1); - if (hashTable[hashIndex] == au) - { - hashTable[hashIndex] = hashTable[hashIndex]->next; - } - else - { - if (au->prev) au->prev->next = au->next; - if (au->next) au->next->prev = au->prev; - } - } + { + unsigned int hashIndex = ((unsigned int) oldReportedAddress >> 4) & (hashSize - 1); + if (hashTable[hashIndex] == au) + { + hashTable[hashIndex] = hashTable[hashIndex]->next; + } + else + { + if (au->prev) au->prev->next = au->next; + if (au->next) au->next->prev = au->prev; + } + } - // Re-insert it back into the hash table + // Re-insert it back into the hash table - hashIndex = ((unsigned int) au->reportedAddress >> 4) & (hashSize - 1); - if (hashTable[hashIndex]) hashTable[hashIndex]->prev = au; - au->next = hashTable[hashIndex]; - au->prev = NULL; - hashTable[hashIndex] = au; - } + hashIndex = ((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 + // Account for the new allocatin unit in our stats - stats.totalReportedMemory += au->reportedSize; - stats.totalActualMemory += au->actualSize; - if (stats.totalReportedMemory > stats.peakReportedMemory) stats.peakReportedMemory = stats.totalReportedMemory; - if (stats.totalActualMemory > stats.peakActualMemory) stats.peakActualMemory = stats.totalActualMemory; - int deltaReportedSize = reportedSize - originalReportedSize; - if (deltaReportedSize > 0) - { - stats.accumulatedReportedMemory += deltaReportedSize; - stats.accumulatedActualMemory += deltaReportedSize; - } + stats.totalReportedMemory += au->reportedSize; + stats.totalActualMemory += au->actualSize; + if (stats.totalReportedMemory > stats.peakReportedMemory) stats.peakReportedMemory = stats.totalReportedMemory; + if (stats.totalActualMemory > stats.peakActualMemory) stats.peakActualMemory = stats.totalActualMemory; + int deltaReportedSize = reportedSize - originalReportedSize; + if (deltaReportedSize > 0) + { + stats.accumulatedReportedMemory += deltaReportedSize; + stats.accumulatedActualMemory += deltaReportedSize; + } - // Prepare the allocation unit for use (wipe it with recognizable garbage) + // Prepare the allocation unit for use (wipe it with recognizable garbage) - wipeWithPattern(au, unusedPattern, originalReportedSize); + wipeWithPattern(au, unusedPattern, originalReportedSize); - // If you hit this assert, then something went wrong, because the allocation unit was properly validated PRIOR to - // the reallocation. This should not happen. - m_assert(m_validateAllocUnit(au)); + // If you hit this assert, then something went wrong, because the allocation unit was properly validated PRIOR to + // the reallocation. This should not happen. + m_assert(m_validateAllocUnit(au)); - // Validate every single allocated unit in memory + // Validate every single allocated unit in memory - if (alwaysValidateAll) m_validateAllAllocUnits(); + if (alwaysValidateAll) m_validateAllAllocUnits(); - // Log the result + // Log the result - if (alwaysLogAll) log(" OK: %010p (hash: %d)", au->reportedAddress, hashIndex); + if (alwaysLogAll) log(" OK: %010p (hash: %d)", au->reportedAddress, hashIndex); - // 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. + // 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(); + resetGlobals(); - // Return the (reported) address of the new allocation unit + // Return the (reported) address of the new allocation unit - #ifdef TEST_MEMORY_MANAGER - log("EXIT : m_reallocator()"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : m_reallocator()"); + #endif - return au->reportedAddress; - } - catch(const char *err) - { - // Deal with the errors + return au->reportedAddress; + } + catch(const char *err) + { + // Deal with the errors - log(err); - resetGlobals(); + log(err); + resetGlobals(); - #ifdef TEST_MEMORY_MANAGER - log("EXIT : m_reallocator()"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : m_reallocator()"); + #endif - return NULL; - } + return NULL; + } } // --------------------------------------------------------------------------------------------------------------------------------- // Deallocate memory and track it // --------------------------------------------------------------------------------------------------------------------------------- -void m_deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, const unsigned int deallocationType, const void *reportedAddress) +void m_deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, const unsigned int deallocationType, const void *reportedAddress) { - try - { - #ifdef TEST_MEMORY_MANAGER - log("ENTER: m_deallocator()"); - #endif + try + { + #ifdef TEST_MEMORY_MANAGER + log("ENTER: m_deallocator()"); + #endif - // Log the request + // Log the request - if (alwaysLogAll) log(" %-40s %8s(%010p)", ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[deallocationType], reportedAddress); + if (alwaysLogAll) log(" %-40s %8s(%010p)", ownerString(sourceFile, sourceLine, sourceFunc), allocationTypes[deallocationType], reportedAddress); - // Go get the allocation unit + // Go get the allocation unit - sAllocUnit *au = findAllocUnit(reportedAddress); + sAllocUnit *au = findAllocUnit(reportedAddress); - // If you hit this assert, you tried to deallocate RAM that wasn't allocated by this memory manager. - m_assert(au != NULL); - if (au == NULL) throw "Request to deallocate RAM that was never allocated"; + // If you hit this assert, you tried to deallocate RAM that wasn't allocated by this memory manager. + m_assert(au != NULL); + if (au == NULL) throw "Request to deallocate RAM that was never allocated"; - // If you hit this assert, then the allocation unit that is about to be deallocated is damaged. But you probably - // already know that from a previous assert you should have seen in validateAllocUnit() :) - m_assert(m_validateAllocUnit(au)); + // If you hit this assert, then the allocation unit that is about to be deallocated is damaged. But you probably + // already know that from a previous assert you should have seen in validateAllocUnit() :) + m_assert(m_validateAllocUnit(au)); - // If you hit this assert, then this deallocation 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(deallocationType != m_alloc_unknown); + // If you hit this assert, then this deallocation 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(deallocationType != m_alloc_unknown); - // If you hit this assert, you were trying to deallocate RAM that was not allocated in a way that is compatible with - // the deallocation method requested. In other words, you have a allocation/deallocation mismatch. - m_assert((deallocationType == m_alloc_delete && au->allocationType == m_alloc_new ) || - (deallocationType == m_alloc_delete_array && au->allocationType == m_alloc_new_array) || - (deallocationType == m_alloc_free && au->allocationType == m_alloc_malloc ) || - (deallocationType == m_alloc_free && au->allocationType == m_alloc_calloc ) || - (deallocationType == m_alloc_free && au->allocationType == m_alloc_realloc ) || - (deallocationType == m_alloc_unknown ) ); + // If you hit this assert, you were trying to deallocate RAM that was not allocated in a way that is compatible with + // the deallocation method requested. In other words, you have a allocation/deallocation mismatch. + m_assert((deallocationType == m_alloc_delete && au->allocationType == m_alloc_new ) || + (deallocationType == m_alloc_delete_array && au->allocationType == m_alloc_new_array) || + (deallocationType == m_alloc_free && au->allocationType == m_alloc_malloc ) || + (deallocationType == m_alloc_free && au->allocationType == m_alloc_calloc ) || + (deallocationType == m_alloc_free && au->allocationType == m_alloc_realloc ) || + (deallocationType == m_alloc_unknown ) ); - // If you hit this assert, then the "break on dealloc" flag for this allocation unit is set. Interrogate the 'au' - // variable to determine information about this allocation unit. - m_assert(au->breakOnDealloc == false); + // If you hit this assert, then the "break on dealloc" flag for this allocation unit is set. Interrogate the 'au' + // variable to determine information about this allocation unit. + m_assert(au->breakOnDealloc == false); - // Wipe the deallocated RAM with a new pattern. This doen't actually do us much good in debug mode under WIN32, - // because Microsoft's memory debugging & tracking utilities will wipe it right after we do. Oh well. + // Wipe the deallocated RAM with a new pattern. This doen't actually do us much good in debug mode under WIN32, + // because Microsoft's memory debugging & tracking utilities will wipe it right after we do. Oh well. - wipeWithPattern(au, releasedPattern); + wipeWithPattern(au, releasedPattern); - // Do the deallocation + // Do the deallocation - free(au->actualAddress); + free(au->actualAddress); - // Remove this allocation unit from the hash table + // Remove this allocation unit from the hash table - unsigned int hashIndex = ((unsigned int) au->reportedAddress >> 4) & (hashSize - 1); - if (hashTable[hashIndex] == au) - { - hashTable[hashIndex] = au->next; - } - else - { - if (au->prev) au->prev->next = au->next; - if (au->next) au->next->prev = au->prev; - } + unsigned int hashIndex = ((unsigned int) au->reportedAddress >> 4) & (hashSize - 1); + if (hashTable[hashIndex] == au) + { + hashTable[hashIndex] = au->next; + } + else + { + if (au->prev) au->prev->next = au->next; + if (au->next) au->next->prev = au->prev; + } - // Remove this allocation from our stats + // Remove this allocation from our stats - stats.totalReportedMemory -= au->reportedSize; - stats.totalActualMemory -= au->actualSize; - stats.totalAllocUnitCount--; + stats.totalReportedMemory -= au->reportedSize; + stats.totalActualMemory -= au->actualSize; + stats.totalAllocUnitCount--; - // Add this allocation unit to the front of our reservoir of unused allocation units + // Add this allocation unit to the front of our reservoir of unused allocation units - memset(au, 0, sizeof(sAllocUnit)); - au->next = reservoir; - reservoir = au; + memset(au, 0, sizeof(sAllocUnit)); + au->next = reservoir; + reservoir = au; - // 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. + // 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(); + resetGlobals(); - // Validate every single allocated unit in memory + // Validate every single allocated unit in memory - if (alwaysValidateAll) m_validateAllAllocUnits(); + if (alwaysValidateAll) m_validateAllAllocUnits(); - // If we're in the midst of static deinitialization time, track any pending memory leaks + // If we're in the midst of static deinitialization time, track any pending memory leaks - if (staticDeinitTime) dumpLeakReport(); - } - catch(const char *err) - { - // Deal with errors + if (staticDeinitTime) dumpLeakReport(); + } + catch(const char *err) + { + // Deal with errors - log(err); - resetGlobals(); - } + log(err); + resetGlobals(); + } - #ifdef TEST_MEMORY_MANAGER - log("EXIT : m_deallocator()"); - #endif + #ifdef TEST_MEMORY_MANAGER + log("EXIT : m_deallocator()"); + #endif } // --------------------------------------------------------------------------------------------------------------------------------- @@ -1387,168 +1415,168 @@ void m_deallocator(const char *sourceFile, const unsigned int sourceLine, const // bugs. // --------------------------------------------------------------------------------------------------------------------------------- -bool m_validateAddress(const void *reportedAddress) +bool m_validateAddress(const void *reportedAddress) { - // Just see if the address exists in our allocation routines + // Just see if the address exists in our allocation routines - return findAllocUnit(reportedAddress) != NULL; + return findAllocUnit(reportedAddress) != NULL; } // --------------------------------------------------------------------------------------------------------------------------------- -bool m_validateAllocUnit(const sAllocUnit *allocUnit) +bool m_validateAllocUnit(const sAllocUnit *allocUnit) { - // Make sure the padding is untouched + // Make sure the padding is untouched - long *pre = (long *) allocUnit->actualAddress; - long *post = (long *) ((char *)allocUnit->actualAddress + allocUnit->actualSize - paddingSize * sizeof(long)); - bool errorFlag = false; - for (unsigned int i = 0; i < paddingSize; i++, pre++, post++) - { - if (*pre != (long) prefixPattern) - { - log("A memory allocation unit was corrupt because of an underrun:"); - m_dumpAllocUnit(allocUnit, " "); - errorFlag = true; - } + long *pre = (long *) allocUnit->actualAddress; + long *post = (long *) ((char *)allocUnit->actualAddress + allocUnit->actualSize - paddingSize * sizeof(long)); + bool errorFlag = false; + for (unsigned int i = 0; i < paddingSize; i++, pre++, post++) + { + if (*pre != (long) prefixPattern) + { + log("A memory allocation unit was corrupt because of an underrun:"); + m_dumpAllocUnit(allocUnit, " "); + errorFlag = true; + } - // If you hit this assert, then you should know that this allocation unit has been damaged. Something (possibly the - // owner?) has underrun the allocation unit (modified a few bytes prior to the start). You can interrogate the - // variable 'allocUnit' to see statistics and information about this damaged allocation unit. - m_assert(*pre == (long) prefixPattern); + // If you hit this assert, then you should know that this allocation unit has been damaged. Something (possibly the + // owner?) has underrun the allocation unit (modified a few bytes prior to the start). You can interrogate the + // variable 'allocUnit' to see statistics and information about this damaged allocation unit. + m_assert(*pre == (long) prefixPattern); - if (*post != (long) postfixPattern) - { - log("A memory allocation unit was corrupt because of an overrun:"); - m_dumpAllocUnit(allocUnit, " "); - errorFlag = true; - } + if (*post != (long) postfixPattern) + { + log("A memory allocation unit was corrupt because of an overrun:"); + m_dumpAllocUnit(allocUnit, " "); + errorFlag = true; + } - // If you hit this assert, then you should know that this allocation unit has been damaged. Something (possibly the - // owner?) has overrun the allocation unit (modified a few bytes after the end). You can interrogate the variable - // 'allocUnit' to see statistics and information about this damaged allocation unit. - m_assert(*post == (long) postfixPattern); - } + // If you hit this assert, then you should know that this allocation unit has been damaged. Something (possibly the + // owner?) has overrun the allocation unit (modified a few bytes after the end). You can interrogate the variable + // 'allocUnit' to see statistics and information about this damaged allocation unit. + m_assert(*post == (long) postfixPattern); + } - // Return the error status (we invert it, because a return of 'false' means error) + // Return the error status (we invert it, because a return of 'false' means error) - return !errorFlag; + return !errorFlag; } // --------------------------------------------------------------------------------------------------------------------------------- -bool m_validateAllAllocUnits() +bool m_validateAllAllocUnits() { - // Just go through each allocation unit in the hash table and count the ones that have errors + // Just go through each allocation unit in the hash table and count the ones that have errors - unsigned int errors = 0; - unsigned int allocCount = 0; - for (unsigned int i = 0; i < hashSize; i++) - { - sAllocUnit *ptr = hashTable[i]; - while(ptr) - { - allocCount++; - if (!m_validateAllocUnit(ptr)) errors++; - ptr = ptr->next; - } - } + unsigned int errors = 0; + unsigned int allocCount = 0; + for (unsigned int i = 0; i < hashSize; i++) + { + sAllocUnit *ptr = hashTable[i]; + while(ptr) + { + allocCount++; + if (!m_validateAllocUnit(ptr)) errors++; + ptr = ptr->next; + } + } - // Test for hash-table correctness + // Test for hash-table correctness - if (allocCount != stats.totalAllocUnitCount) - { - log("Memory tracking hash table corrupt!"); - errors++; - } + if (allocCount != stats.totalAllocUnitCount) + { + log("Memory tracking hash table corrupt!"); + errors++; + } - // If you hit this assert, then the internal memory (hash table) used by this memory tracking software is damaged! The - // best way to track this down is to use the alwaysLogAll flag in conjunction with STRESS_TEST macro to narrow in on the - // offending code. After running the application with these settings (and hitting this assert again), interrogate the - // memory.log file to find the previous successful operation. The corruption will have occurred between that point and this - // assertion. - m_assert(allocCount == stats.totalAllocUnitCount); + // If you hit this assert, then the internal memory (hash table) used by this memory tracking software is damaged! The + // best way to track this down is to use the alwaysLogAll flag in conjunction with STRESS_TEST macro to narrow in on the + // offending code. After running the application with these settings (and hitting this assert again), interrogate the + // memory.log file to find the previous successful operation. The corruption will have occurred between that point and this + // assertion. + m_assert(allocCount == stats.totalAllocUnitCount); - // If you hit this assert, then you've probably already been notified that there was a problem with a allocation unit in a - // prior call to validateAllocUnit(), but this assert is here just to make sure you know about it. :) - m_assert(errors == 0); + // If you hit this assert, then you've probably already been notified that there was a problem with a allocation unit in a + // prior call to validateAllocUnit(), but this assert is here just to make sure you know about it. :) + m_assert(errors == 0); - // Log any errors + // Log any errors - if (errors) log("While validting all allocation units, %d allocation unit(s) were found to have problems", errors); + if (errors) log("While validting all allocation units, %d allocation unit(s) were found to have problems", errors); - // Return the error status + // Return the error status - return errors != 0; + return errors != 0; } // --------------------------------------------------------------------------------------------------------------------------------- // -DOC- Unused RAM calculation routines. Use these to determine how much of your RAM is unused (in bytes) // --------------------------------------------------------------------------------------------------------------------------------- -unsigned int m_calcUnused(const sAllocUnit *allocUnit) +unsigned int m_calcUnused(const sAllocUnit *allocUnit) { - const unsigned long *ptr = (const unsigned long *) allocUnit->reportedAddress; - unsigned int count = 0; + const unsigned long *ptr = (const unsigned long *) allocUnit->reportedAddress; + unsigned int count = 0; - for (unsigned int i = 0; i < allocUnit->reportedSize; i += sizeof(long), ptr++) - { - if (*ptr == unusedPattern) count += sizeof(long); - } + for (unsigned int i = 0; i < allocUnit->reportedSize; i += sizeof(long), ptr++) + { + if (*ptr == unusedPattern) count += sizeof(long); + } - return count; + return count; } // --------------------------------------------------------------------------------------------------------------------------------- -unsigned int m_calcAllUnused() +unsigned int m_calcAllUnused() { - // Just go through each allocation unit in the hash table and count the unused RAM + // Just go through each allocation unit in the hash table and count the unused RAM - unsigned int total = 0; - for (unsigned int i = 0; i < hashSize; i++) - { - sAllocUnit *ptr = hashTable[i]; - while(ptr) - { - total += m_calcUnused(ptr); - ptr = ptr->next; - } - } + unsigned int total = 0; + for (unsigned int i = 0; i < hashSize; i++) + { + sAllocUnit *ptr = hashTable[i]; + while(ptr) + { + total += m_calcUnused(ptr); + ptr = ptr->next; + } + } - return total; + return total; } // --------------------------------------------------------------------------------------------------------------------------------- // -DOC- The following functions are for logging and statistics reporting. // --------------------------------------------------------------------------------------------------------------------------------- -void m_dumpAllocUnit(const sAllocUnit *allocUnit, const char *prefix) +void m_dumpAllocUnit(const sAllocUnit *allocUnit, const char *prefix) { - log("%sAddress (reported): %010p", prefix, allocUnit->reportedAddress); - log("%sAddress (actual) : %010p", prefix, allocUnit->actualAddress); - log("%sSize (reported) : 0x%08X (%s)", prefix, allocUnit->reportedSize, memorySizeString(allocUnit->reportedSize)); - log("%sSize (actual) : 0x%08X (%s)", prefix, allocUnit->actualSize, memorySizeString(allocUnit->actualSize)); - log("%sOwner : %s(%d)::%s", prefix, allocUnit->sourceFile, allocUnit->sourceLine, allocUnit->sourceFunc); - log("%sAllocation type : %s", prefix, allocationTypes[allocUnit->allocationType]); - log("%sAllocation number : %d", prefix, allocUnit->allocationNumber); + log("%sAddress (reported): %010p", prefix, allocUnit->reportedAddress); + log("%sAddress (actual) : %010p", prefix, allocUnit->actualAddress); + log("%sSize (reported) : 0x%08X (%s)", prefix, allocUnit->reportedSize, memorySizeString(allocUnit->reportedSize)); + log("%sSize (actual) : 0x%08X (%s)", prefix, allocUnit->actualSize, memorySizeString(allocUnit->actualSize)); + log("%sOwner : %s(%d)::%s", prefix, allocUnit->sourceFile, allocUnit->sourceLine, allocUnit->sourceFunc); + log("%sAllocation type : %s", prefix, allocationTypes[allocUnit->allocationType]); + log("%sAllocation number : %d", prefix, allocUnit->allocationNumber); } // --------------------------------------------------------------------------------------------------------------------------------- -void m_dumpMemoryReport(const char *filename, const bool overwrite) +void m_dumpMemoryReport(const char *filename, const bool overwrite) { - // Open the report file + // Open the report file - FILE *fp = NULL; - - if (overwrite) fp = fopen(filename, "w+b"); - else fp = fopen(filename, "ab"); + FILE *fp = NULL; + + if (overwrite) fp = fopen(filename, "w+b"); + else fp = fopen(filename, "ab"); - // 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; + // 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; // Header @@ -1556,56 +1584,56 @@ void m_dumpMemoryReport(const char *filename, const bool overwrite) memset(timeString, 0, sizeof(timeString)); time_t t = time(NULL); struct tm *tme = localtime(&t); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); fprintf(fp, "| Memory 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"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, "\r\n"); + fprintf(fp, "\r\n"); - // Report summary + // Report summary - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, "| T O T A L S |\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, " Allocation unit count: %10s\r\n", insertCommas(stats.totalAllocUnitCount)); - fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.totalReportedMemory)); - fprintf(fp, " Actual total memory in use: %s\r\n", memorySizeString(stats.totalActualMemory)); - fprintf(fp, " Memory tracking overhead: %s\r\n", memorySizeString(stats.totalActualMemory - stats.totalReportedMemory)); - fprintf(fp, "\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, "| T O T A L S |\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, " Allocation unit count: %10s\r\n", insertCommas(stats.totalAllocUnitCount)); + fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.totalReportedMemory)); + fprintf(fp, " Actual total memory in use: %s\r\n", memorySizeString(stats.totalActualMemory)); + fprintf(fp, " Memory tracking overhead: %s\r\n", memorySizeString(stats.totalActualMemory - stats.totalReportedMemory)); + fprintf(fp, "\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, "| P E A K S |\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, " Allocation unit count: %10s\r\n", insertCommas(stats.peakAllocUnitCount)); - fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.peakReportedMemory)); - fprintf(fp, " Actual: %s\r\n", memorySizeString(stats.peakActualMemory)); - fprintf(fp, " Memory tracking overhead: %s\r\n", memorySizeString(stats.peakActualMemory - stats.peakReportedMemory)); - fprintf(fp, "\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, "| P E A K S |\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, " Allocation unit count: %10s\r\n", insertCommas(stats.peakAllocUnitCount)); + fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.peakReportedMemory)); + fprintf(fp, " Actual: %s\r\n", memorySizeString(stats.peakActualMemory)); + fprintf(fp, " Memory tracking overhead: %s\r\n", memorySizeString(stats.peakActualMemory - stats.peakReportedMemory)); + fprintf(fp, "\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, "| A C C U M U L A T E D |\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, " Allocation unit count: %s\r\n", memorySizeString(stats.accumulatedAllocUnitCount)); - fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.accumulatedReportedMemory)); - fprintf(fp, " Actual: %s\r\n", memorySizeString(stats.accumulatedActualMemory)); - fprintf(fp, "\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, "| A C C U M U L A T E D |\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, " Allocation unit count: %s\r\n", memorySizeString(stats.accumulatedAllocUnitCount)); + fprintf(fp, " Reported to application: %s\r\n", memorySizeString(stats.accumulatedReportedMemory)); + fprintf(fp, " Actual: %s\r\n", memorySizeString(stats.accumulatedActualMemory)); + fprintf(fp, "\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, "| U N U S E D |\r\n"); - fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); - fprintf(fp, " Memory allocated but not in use: %s\r\n", memorySizeString(m_calcAllUnused())); - fprintf(fp, "\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, "| U N U S E D |\r\n"); + fprintf(fp, " ---------------------------------------------------------------------------------------------------------------------------------- \r\n"); + fprintf(fp, " Memory allocated but not in use: %s\r\n", memorySizeString(m_calcAllUnused())); + fprintf(fp, "\r\n"); - dumpAllocations(fp); + dumpAllocations(fp); - fclose(fp); + fclose(fp); } // --------------------------------------------------------------------------------------------------------------------------------- -sMStats m_getMemoryStatistics() +sMStats m_getMemoryStatistics() { - return stats; + return stats; } // --------------------------------------------------------------------------------------------------------------------------------- diff --git a/src/osgDB/Registry.cpp b/src/osgDB/Registry.cpp index 2552f886b..855a277e8 100644 --- a/src/osgDB/Registry.cpp +++ b/src/osgDB/Registry.cpp @@ -477,7 +477,12 @@ Image* Registry::readImage(Input& fr) } - return dynamic_cast(readObject(_imageWrapperMap,fr)); + osg::Object* obj = readObject(_imageWrapperMap,fr); + osg::Image* image = dynamic_cast(obj); + if (image) return image; + else if (obj) obj->unref(); + + return NULL; } @@ -498,7 +503,12 @@ Drawable* Registry::readDrawable(Input& fr) } - return dynamic_cast(readObject(_drawableWrapperMap,fr)); + osg::Object* obj = readObject(_drawableWrapperMap,fr); + osg::Drawable* drawable = dynamic_cast(obj); + if (drawable) return drawable; + else if (obj) obj->unref(); + + return NULL; } // @@ -539,7 +549,12 @@ Node* Registry::readNode(Input& fr) } - return dynamic_cast(readObject(_nodeWrapperMap,fr)); + osg::Object* obj = readObject(_nodeWrapperMap,fr); + osg::Node* node = dynamic_cast(obj); + if (node) return node; + else if (obj) obj->unref(); + + return NULL; } //