From 6f6593ac946a13171213718590401986d52cb301 Mon Sep 17 00:00:00 2001 From: "blythe%netscape.com" Date: Fri, 1 Nov 2002 00:34:13 +0000 Subject: [PATCH] Not part of any build. Work in progress on heap fragmentation report tool. --- tools/trace-malloc/tmfrags.c | 219 +++++++++++++++++++++++++++++++---- 1 file changed, 198 insertions(+), 21 deletions(-) diff --git a/tools/trace-malloc/tmfrags.c b/tools/trace-malloc/tmfrags.c index 98f1039f5ad..3d138447b38 100644 --- a/tools/trace-malloc/tmfrags.c +++ b/tools/trace-malloc/tmfrags.c @@ -116,28 +116,25 @@ static Switch* gSwitches[] = { }; -typedef struct __struct_TMState +typedef struct __struct_AnyArray /* -** State of our current operation. -** Stats we are trying to calculate. +** Variable sized item array. ** -** mOptions Obilgatory options pointer. -** mTMR The tmreader, used in tmreader API calls. -** mLoopExitTMR Set to non zero in order to quickly exit from tmreader -** input loop. This will also result in an error. -** uMinTicks Start of run, milliseconds. -** uMaxTicks End of run, milliseconds. +** mItems The void pointer items. +** mItemSize Size of each different item. +** mCount The number of items in the array. +** mCapacity How many more items we can hold before reallocing. +** mGrowBy How many items we allocate when we grow. */ { - Options* mOptions; - tmreader* mTMR; - - int mLoopExitTMR; - - unsigned uMinTicks; - unsigned uMaxTicks; + void* mItems; + unsigned mItemSize; + unsigned mCount; + unsigned mCapacity; + unsigned mGrowBy; } -TMState; +AnyArray; +typedef AnyArray HeapObjectArray; typedef enum __enum_HeapEventType @@ -163,8 +160,6 @@ HeapObjectType; typedef struct __struct_HeapObject HeapObject; - - typedef struct __struct_HeapHistory /* ** A marker as to what has happened. @@ -210,6 +205,30 @@ struct __struct_HeapObject }; +typedef struct __struct_TMState +/* +** State of our current operation. +** Stats we are trying to calculate. +** +** mOptions Obilgatory options pointer. +** mTMR The tmreader, used in tmreader API calls. +** mLoopExitTMR Set to non zero in order to quickly exit from tmreader +** input loop. This will also result in an error. +** uMinTicks Start of run, milliseconds. +** uMaxTicks End of run, milliseconds. +*/ +{ + Options* mOptions; + tmreader* mTMR; + + int mLoopExitTMR; + + unsigned uMinTicks; + unsigned uMaxTicks; +} +TMState; + + int initOptions(Options* outOptions, int inArgc, char** inArgv) /* ** returns int 0 if successful. @@ -471,10 +490,168 @@ void showHelp(Options* inOptions) } +AnyArray* arrayCreate(unsigned inItemSize, unsigned inGrowBy) +/* +** Create an array container object. +*/ +{ + AnyArray* retval = NULL; + + if(0 != inGrowBy && 0 != inItemSize) + { + retval = (AnyArray*)calloc(1, sizeof(AnyArray)); + retval->mItemSize = inItemSize; + retval->mGrowBy = inGrowBy; + } + + return retval; +} + + +void arrayDestroy(AnyArray* inArray) +/* +** Release the memory the array contains. +** This will release the items as well. +*/ +{ + if(NULL != inArray) + { + if(NULL != inArray->mItems) + { + free(inArray->mItems); + } + free(inArray); + } +} + + +unsigned arrayAlloc(AnyArray* inArray, unsigned inItems) +/* +** Resize the item array capcity to a specific number of items. +** This could possibly truncate the array, so handle that as well. +** +** returns unsigned <= inArray->mCapactiy on success. +*/ +{ + unsigned retval = (unsigned)-1; + + if(NULL != inArray) + { + void* moved = NULL; + + moved = realloc(inArray->mItems, inItems * inArray->mItemSize); + if(NULL != moved) + { + inArray->mItems = moved; + inArray->mCapacity = inItems; + if(inArray->mCount > inItems) + { + inArray->mCount = inItems; + } + + retval = inItems; + } + } + + return retval; +} + + +void* arrayItem(AnyArray* inArray, unsigned inIndex) +/* +** Return the array item at said index. +** Zero based index. +** +** returns void* NULL on failure. +*/ +{ + void* retval = NULL; + + if(NULL != inArray && inIndex < inArray->mCount) + { + retval = (void*)((char*)inArray->mItems + (inArray->mItemSize * inIndex)); + } + + return retval; +} + + +unsigned arrayIndex(AnyArray* inArray, void* inItem, unsigned inStartIndex) +/* +** Go through the array from the index specified looking for an item +** match. +** We allow specifying the start index in order to handle arrays with +** duplicate items. +** +** returns unsigned >= inArray->mCount on failure. +*/ +{ + unsigned retval = (unsigned)-1; + + if(NULL != inArray && NULL != inItem && inStartIndex < inArray->mCount) + { + void* curItem = NULL; + + for(retval = inStartIndex; retval < inArray->mCount; retval++) + { + curItem = arrayItem(inArray, retval); + if(0 == memcmp(inItem, curItem, inArray->mItemSize)) + { + break; + } + } + } + + + return retval; +} + + +unsigned arrayAddItem(AnyArray* inArray, void* inItem) +/* +** Add a new item to the array. +** This is done by copying the item. +** +** returns unsigned < inArray->mCount on success. +*/ +{ + unsigned retval = (unsigned)-1; + + if(NULL != inArray && NULL != inItem) + { + int noCopy = 0; + + /* + ** See if the array should grow. + */ + if(inArray->mCount == inArray->mCapacity) + { + unsigned allocRes = 0; + + allocRes = arrayAlloc(inArray, inArray->mCapacity + inArray->mGrowBy); + if(allocRes > inArray->mCapacity) + { + noCopy = __LINE__; + } + } + + if(0 == noCopy) + { + retval = inArray->mCount; + + inArray->mCount++; + memcpy(arrayItem(inArray, retval), inItem, inArray->mItemSize); + } + } + + return retval; +} + + int simpleHeapEvent(TMState* inStats, HeapEventType inType, unsigned mTimestamp, unsigned inSerial, unsigned inHeapID, unsigned inSize) /* -** Generally, this event intends to chain one old heap object to a newer heap object. -** Otherwise, the functionality should recognizable ala simpleHeapEvent. +** A new heap event will cause the creation of a new heap object. +** The new heap object will displace, or replace, a heap object of a different type. */ { int retval = 0;