%s

\n" + " " + " \n" + " \n", id, + table_class ? table_class : "", + caption); + + for (i=0; i< header_length; i++) + PR_fprintf(inRequest->mFD, + " \n", headers[i]); + + PR_fprintf(inRequest->mFD, " \n"); +} + +/* +** callsiteArrayFromCallsite +** +** Simply return an array of the callsites divulged from the site passed in, +** including the site passed in. +** Do not worry about dups, or the order of the items. +** +** Returns the number of items in the array. +** If the same as aExistingCount, then nothing happened. +*/ +uint32_t +callsiteArrayFromCallsite(tmcallsite *** aArray, uint32_t aExistingCount, + tmcallsite * aSite, int aFollow) +{ + uint32_t retval = 0; + + if (NULL != aArray && NULL != aSite) { + tmcallsite **expand = NULL; + + /* + ** If we have an existing count, we just keep expanding this. + */ + retval = aExistingCount; + + /* + ** Go through every allocation. + */ + do { + /* + ** expand the array. + */ + expand = + (tmcallsite **) realloc(*aArray, + sizeof(tmcallsite *) * (retval + 1)); + if (NULL != expand) { + /* + ** Set the callsite in case of pointer move. + */ + *aArray = expand; + + /* + ** Assign the value. + */ + (*aArray)[retval] = aSite; + retval++; + } + else { + REPORT_ERROR(__LINE__, realloc); + break; + } + + + /* + ** What do we follow? + */ + switch (aFollow) { + case ST_FOLLOW_SIBLINGS: + aSite = aSite->siblings; + break; + case ST_FOLLOW_PARENTS: + aSite = aSite->parent; + break; + default: + aSite = NULL; + REPORT_ERROR(__LINE__, callsiteArrayFromCallsite); + break; + } + } + while (NULL != aSite && NULL != aSite->method); + } + + return retval; +} + +/* +** callsiteArrayFromRun +** +** Simply return an array of the callsites from the run allocations. +** We only pay attention to callsites that were not free callsites. +** Do not worry about dups, or the order of the items. +** +** Returns the number of items in the array. +** If the same as aExistingCount, then nothing happened. +*/ +uint32_t +callsiteArrayFromRun(tmcallsite *** aArray, uint32_t aExistingCount, + STRun * aRun) +{ + uint32_t retval = 0; + + if (NULL != aArray && NULL != aRun && 0 < aRun->mAllocationCount) { + uint32_t allocLoop = 0; + uint32_t eventLoop = 0; + int stopLoops = 0; + + /* + ** If we have an existing count, we just keep expanding this. + */ + retval = aExistingCount; + + /* + ** Go through every allocation. + */ + for (allocLoop = 0; + 0 == stopLoops && allocLoop < aRun->mAllocationCount; + allocLoop++) { + /* + ** Go through every event. + */ + for (eventLoop = 0; + 0 == stopLoops + && eventLoop < aRun->mAllocations[allocLoop]->mEventCount; + eventLoop++) { + /* + ** Skip the free events. + */ + if (TM_EVENT_FREE != + aRun->mAllocations[allocLoop]->mEvents[eventLoop]. + mEventType) { + tmcallsite **expand = NULL; + + /* + ** expand the array. + */ + expand = + (tmcallsite **) realloc(*aArray, + sizeof(tmcallsite *) * + (retval + 1)); + if (NULL != expand) { + /* + ** Set the callsite in case of pointer move. + */ + *aArray = expand; + + /* + ** Assign the value. + */ + (*aArray)[retval] = + aRun->mAllocations[allocLoop]->mEvents[eventLoop]. + mCallsite; + retval++; + } + else { + REPORT_ERROR(__LINE__, realloc); + stopLoops = __LINE__; + } + } + } + } + } + + return retval; +} + +/* +** getDataPRUint* +** +** Helper to avoid cut and paste code. +** Failure to find aCheckFor does not mean failure. +** In case of dups, specify an index on non "1" to get others. +** Do not touch storage space unless a find is made. +** Returns !0 on failure. +*/ +int +getDataPRUint32Base(const FormData * aGetData, const char *aCheckFor, + int inIndex, void *aStoreResult, uint32_t aBits) +{ + int retval = 0; + + if (NULL != aGetData && NULL != aCheckFor && 0 != inIndex + && NULL != aStoreResult) { + unsigned finder = 0; + + /* + ** Loop over the names, looking for an exact string match. + ** Skip over initial finds, decrementing inIndex, until "1". + */ + for (finder = 0; finder < aGetData->mNVCount; finder++) { + if (0 == strcmp(aCheckFor, aGetData->mNArray[finder])) { + inIndex--; + + if (0 == inIndex) { + int32_t scanRes = 0; + + if (64 == aBits) { + scanRes = + PR_sscanf(aGetData->mVArray[finder], "%llu", + aStoreResult); + } + else { + scanRes = + PR_sscanf(aGetData->mVArray[finder], "%u", + aStoreResult); + } + if (1 != scanRes) { + retval = __LINE__; + REPORT_ERROR(__LINE__, PR_sscanf); + } + break; + } + } + } + } + else { + retval = __LINE__; + REPORT_ERROR(__LINE__, getDataPRUint32Base); + } + + return retval; +} + +int +getDataPRUint32(const FormData * aGetData, const char *aCheckFor, int inIndex, + uint32_t * aStoreResult, uint32_t aConversion) +{ + int retval = 0; + + retval = + getDataPRUint32Base(aGetData, aCheckFor, inIndex, aStoreResult, 32); + *aStoreResult *= aConversion; + + return retval; +} + +int +getDataPRUint64(const FormData * aGetData, const char *aCheckFor, int inIndex, + uint64_t * aStoreResult64, uint64_t aConversion64) +{ + int retval = 0; + uint64_t value64 = 0; + + retval = getDataPRUint32Base(aGetData, aCheckFor, inIndex, &value64, 64); + *aStoreResult64 = value64 * aConversion64; + + return retval; +} + +/* +** getDataString +** +** Pull out the string data, if specified. +** In case of dups, specify an index on non "1" to get others. +** Do not touch storage space unless a find is made. +** Return !0 on failure. +*/ +int +getDataString(const FormData * aGetData, const char *aCheckFor, int inIndex, + char *aStoreResult, int inStoreResultLength) +{ + int retval = 0; + + if (NULL != aGetData && NULL != aCheckFor && 0 != inIndex + && NULL != aStoreResult && 0 != inStoreResultLength) { + unsigned finder = 0; + + /* + ** Loop over the names, looking for an exact string match. + ** Skip over initial finds, decrementing inIndex, until "1". + */ + for (finder = 0; finder < aGetData->mNVCount; finder++) { + if (0 == strcmp(aCheckFor, aGetData->mNArray[finder])) { + inIndex--; + + if (0 == inIndex) { + PR_snprintf(aStoreResult, inStoreResultLength, "%s", + aGetData->mVArray[finder]); + break; + } + } + } + } + else { + retval = __LINE__; + REPORT_ERROR(__LINE__, getDataPRUint32); + } + + return retval; +} + +/* +** displayTopAllocations +** +** Present the top allocations. +** The run must be passed in, and it must be pre-sorted. +** +** Returns !0 on failure. +*/ +int +displayTopAllocations(STRequest * inRequest, STRun * aRun, + const char* id, + const char* caption, + int aWantCallsite) +{ + int retval = 0; + + if (NULL != aRun) { + if (0 < aRun->mAllocationCount) { + uint32_t loop = 0; + STAllocation *current = NULL; + + static const char* const headers[] = { + "Rank", "Index", "Byte Size", "Lifespan (sec)", + "Weight", "Heap Op (sec)" + }; + + static const char* const headers_callsite[] = { + "Rank", "Index", "Byte Size", "Lifespan (sec)", + "Weight", "Heap Op (sec)", "Origin Callsite" + }; + + if (aWantCallsite) + htmlStartTable(inRequest, NULL, id, + caption, + headers_callsite, + sizeof(headers_callsite) / sizeof(headers_callsite[0])); + else + htmlStartTable(inRequest, NULL, id, caption, + headers, + sizeof(headers) / sizeof(headers[0])); + /* + ** Loop over the items, up to some limit or until the end. + */ + for (loop = 0; + loop < inRequest->mOptions.mListItemMax + && loop < aRun->mAllocationCount; loop++) { + current = aRun->mAllocations[loop]; + if (NULL != current) { + uint32_t lifespan = + current->mMaxTimeval - current->mMinTimeval; + uint32_t size = byteSize(&inRequest->mOptions, current); + uint32_t heapCost = current->mHeapRuntimeCost; + uint64_t weight64 = 0; + char buffer[32]; + + weight64 =(uint64_t)(size * lifespan); + + PR_fprintf(inRequest->mFD, "\n"); + + /* + ** Rank. + */ + PR_fprintf(inRequest->mFD, "\n", + loop + 1); + + /* + ** Index. + */ + PR_snprintf(buffer, sizeof(buffer), "%u", + current->mRunIndex); + PR_fprintf(inRequest->mFD, "\n"); + + /* + ** Byte Size. + */ + PR_fprintf(inRequest->mFD, "\n", + size); + + /* + ** Lifespan. + */ + PR_fprintf(inRequest->mFD, + "\n", + ST_TIMEVAL_PRINTABLE(lifespan)); + + /* + ** Weight. + */ + PR_fprintf(inRequest->mFD, "\n", + weight64); + + /* + ** Heap operation cost. + */ + PR_fprintf(inRequest->mFD, + "\n", ST_MICROVAL_PRINTABLE(heapCost)); + + if (0 != aWantCallsite) { + /* + ** Callsite. + */ + PR_fprintf(inRequest->mFD, "\n"); + } + + PR_fprintf(inRequest->mFD, "\n"); + } + } + + PR_fprintf(inRequest->mFD, "\n

%s
%s
%u	\n"); + htmlAllocationAnchor(inRequest, current, buffer); + PR_fprintf(inRequest->mFD, "	%u	" ST_TIMEVAL_FORMAT "	%llu	" ST_MICROVAL_FORMAT + "	"); + htmlCallsiteAnchor(inRequest, + current->mEvents[0].mCallsite, + NULL, 0); + PR_fprintf(inRequest->mFD, "

Final Size:	%u
Lifespan Seconds:	" + ST_TIMEVAL_FORMAT "
Weight:	%llu
Heap Operation Seconds:	" + ST_MICROVAL_FORMAT "

Composite Byte Size:	%u
Composite Seconds:	" + ST_TIMEVAL_FORMAT "
Composite Weight:	%llu
Heap Object Count:	%u
Heap Operation Seconds:	" + ST_MICROVAL_FORMAT "

\n"); +#endif +#define ST_WEB_OPTION_BOOL(option_name, option_genre, option_help) \ + displayOptionBool(option_name, option_genre, option_help) +#define ST_WEB_OPTION_STRING(option_name, option_genre, default_value, option_help) \ + displayOptionString(inRequest, #option_name, #option_genre, default_value, option_help, inRequest->mOptions.m##option_name); +#define ST_WEB_OPTION_STRING_ARRAY(option_name, option_genre, array_size, option_help) \ + displayOptionStringArray(inRequest, #option_name, #option_genre, array_size, option_help, inRequest->mOptions.m##option_name); +#define ST_WEB_OPTION_STRING_PTR_ARRAY(option_name, option_genre, option_help) /* no implementation */ +#define ST_WEB_OPTION_UINT32(option_name, option_genre, default_value, multiplier, option_help) \ + displayOptionInt(inRequest, #option_name, #option_genre, default_value, multiplier, option_help, inRequest->mOptions.m##option_name); +#define ST_WEB_OPTION_UINT64(option_name, option_genre, default_value, multiplier, option_help) \ + displayOptionInt64(inRequest, #option_name, #option_genre, default_value, multiplier, option_help, inRequest->mOptions.m##option_name##64); +#include "stoptions.h" + /* + ** Give a submit/reset button, obligatory. + ** Done respecting newlines in help text. + */ + PR_fprintf(inRequest->mFD, + " \n"); +#if 0 + PR_fprintf(inRequest->mFD, "