Google Git
Sign in
android / platform / art / 3c19d3e / . / tools / dmtracedump / tracedump.cc
blob: f70e2c22079f106a66d7747c3281fe4b685995bb [file] [log] [blame]
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Process dmtrace output.
*
* This is the wrong way to go about it -- C is a clumsy language for
* shuffling data around. It'll do for a first pass.
*/
#include "profile.h" // from VM header
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
/* Version number in the key file.
* Version 1 uses one byte for the thread id.
* Version 2 uses two bytes for the thread ids.
* Version 3 encodes the record size and adds an optional extra timestamp field.
*/
int32_t versionNumber;
/* arbitrarily limit indentation */
#define MAX_STACK_DEPTH 10000
/* thread list in key file is not reliable, so just max out */
#define MAX_THREADS 32768
/* Size of temporary buffers for escaping html strings */
#define HTML_BUFSIZE 10240
const char* htmlHeader =
"<html>\n<head>\n<script type=\"text/javascript\" "
"src=\"%ssortable.js\"></script>\n"
"<script langugage=\"javascript\">\n"
"function toggle(item) {\n"
" obj=document.getElementById(item);\n"
" visible=(obj.style.display!=\"none\" && obj.style.display!=\"\");\n"
" key=document.getElementById(\"x\" + item);\n"
" if (visible) {\n"
" obj.style.display=\"none\";\n"
" key.innerHTML=\"+\";\n"
" } else {\n"
" obj.style.display=\"block\";\n"
" key.innerHTML=\"-\";\n"
" }\n"
"}\n"
"function onMouseOver(obj) {\n"
" obj.style.background=\"lightblue\";\n"
"}\n"
"function onMouseOut(obj) {\n"
" obj.style.background=\"white\";\n"
"}\n"
"</script>\n"
"<style type=\"text/css\">\n"
"div { font-family: courier; font-size: 13 }\n"
"div.parent { margin-left: 15; display: none }\n"
"div.leaf { margin-left: 10 }\n"
"div.header { margin-left: 10 }\n"
"div.link { margin-left: 10; cursor: move }\n"
"span.parent { padding-right: 10; }\n"
"span.leaf { padding-right: 10; }\n"
"a img { border: 0;}\n"
"table.sortable th { border-width: 0px 1px 1px 1px; background-color: "
"#ccc;}\n"
"a { text-decoration: none; }\n"
"a:hover { text-decoration: underline; }\n"
"table.sortable th, table.sortable td { text-align: left;}"
"table.sortable tr.odd td { background-color: #ddd; }\n"
"table.sortable tr.even td { background-color: #fff; }\n"
"</style>\n"
"</head><body>\n\n";
const char* htmlFooter = "\n</body>\n</html>\n";
const char* profileSeparator =
"======================================================================";
const char* tableHeader =
"<table class='sortable' id='%s'><tr>\n"
"<th>Method</th>\n"
"<th>Run 1 (us)</th>\n"
"<th>Run 2 (us)</th>\n"
"<th>Diff (us)</th>\n"
"<th>Diff (%%)</th>\n"
"<th>1: # calls</th>\n"
"<th>2: # calls</th>\n"
"</tr>\n";
const char* tableHeaderMissing =
"<table class='sortable' id='%s'>\n"
"<th>Method</th>\n"
"<th>Exclusive</th>\n"
"<th>Inclusive</th>\n"
"<th># calls</th>\n";
#define GRAPH_LABEL_VISITED 0x0001
#define GRAPH_NODE_VISITED 0x0002
/*
* Values from the header of the data file.
*/
typedef struct DataHeader {
uint32_t magic;
int16_t version;
int16_t offsetToData;
int64_t startWhen;
int16_t recordSize;
} DataHeader;
/*
* Entry from the thread list.
*/
typedef struct ThreadEntry {
int32_t threadId;
const char* threadName;
} ThreadEntry;
struct MethodEntry;
typedef struct TimedMethod {
struct TimedMethod* next;
uint64_t elapsedInclusive;
int32_t numCalls;
struct MethodEntry* method;
} TimedMethod;
typedef struct ClassEntry {
const char* className;
uint64_t elapsedExclusive;
int32_t numMethods;
struct MethodEntry** methods; /* list of methods in this class */
int32_t numCalls[2]; /* 0=normal, 1=recursive */
} ClassEntry;
typedef struct UniqueMethodEntry {
uint64_t elapsedExclusive;
int32_t numMethods;
struct MethodEntry** methods; /* list of methods with same name */
int32_t numCalls[2]; /* 0=normal, 1=recursive */
} UniqueMethodEntry;
/*
* Entry from the method list.
*/
typedef struct MethodEntry {
int64_t methodId;
const char* className;
const char* methodName;
const char* signature;
const char* fileName;
int32_t lineNum;
uint64_t elapsedExclusive;
uint64_t elapsedInclusive;
uint64_t topExclusive; /* non-recursive exclusive time */
uint64_t recursiveInclusive;
struct TimedMethod* parents[2]; /* 0=normal, 1=recursive */
struct TimedMethod* children[2]; /* 0=normal, 1=recursive */
int32_t numCalls[2]; /* 0=normal, 1=recursive */
int32_t index; /* used after sorting to number methods */
int32_t recursiveEntries; /* number of entries on the stack */
int32_t graphState; /* used when graphing to see if this method has been visited before */
} MethodEntry;
/*
* The parsed contents of the key file.
*/
typedef struct DataKeys {
char* fileData; /* contents of the entire file */
int64_t fileLen;
int32_t numThreads;
ThreadEntry* threads;
int32_t numMethods;
MethodEntry* methods; /* 2 extra methods: "toplevel" and "unknown" */
} DataKeys;
#define TOPLEVEL_INDEX 0
#define UNKNOWN_INDEX 1
typedef struct StackEntry {
MethodEntry* method;
uint64_t entryTime;
} StackEntry;
typedef struct CallStack {
int32_t top;
StackEntry calls[MAX_STACK_DEPTH];
uint64_t lastEventTime;
uint64_t threadStartTime;
} CallStack;
typedef struct DiffEntry {
MethodEntry* method1;
MethodEntry* method2;
int64_t differenceExclusive;
int64_t differenceInclusive;
double differenceExclusivePercentage;
double differenceInclusivePercentage;
} DiffEntry;
// Global options
typedef struct Options {
const char* traceFileName;
const char* diffFileName;
const char* graphFileName;
int32_t keepDotFile;
int32_t dump;
int32_t outputHtml;
const char* sortableUrl;
int32_t threshold;
} Options;
typedef struct TraceData {
int32_t numClasses;
ClassEntry* classes;
CallStack* stacks[MAX_THREADS];
int32_t depth[MAX_THREADS];
int32_t numUniqueMethods;
UniqueMethodEntry* uniqueMethods;
} TraceData;
static Options gOptions;
/* Escapes characters in the source string that are html special entities.
* The escaped string is written to "dest" which must be large enough to
* hold the result. A pointer to "dest" is returned. The characters and
* their corresponding escape sequences are:
* '<' &lt;
* '>' &gt;
* '&' &amp;
*/
char* htmlEscape(const char* src, char* dest, int32_t len) {
char* destStart = dest;
if (src == nullptr) return nullptr;
int32_t nbytes = 0;
while (*src) {
if (*src == '<') {
nbytes += 4;
if (nbytes >= len) break;
*dest++ = '&';
*dest++ = 'l';
*dest++ = 't';
*dest++ = ';';
} else if (*src == '>') {
nbytes += 4;
if (nbytes >= len) break;
*dest++ = '&';
*dest++ = 'g';
*dest++ = 't';
*dest++ = ';';
} else if (*src == '&') {
nbytes += 5;
if (nbytes >= len) break;
*dest++ = '&';
*dest++ = 'a';
*dest++ = 'm';
*dest++ = 'p';
*dest++ = ';';
} else {
nbytes += 1;
if (nbytes >= len) break;
*dest++ = *src;
}
src += 1;
}
if (nbytes >= len) {
fprintf(stderr, "htmlEscape(): buffer overflow\n");
exit(1);
}
*dest = 0;
return destStart;
}
/* Initializes a MethodEntry
*/
void initMethodEntry(MethodEntry* method, int64_t methodId, const char* className,
const char* methodName, const char* signature, const char* fileName,
const char* lineNumStr) {
method->methodId = methodId;
method->className = className;
method->methodName = methodName;
method->signature = signature;
method->fileName = fileName;
method->lineNum = (lineNumStr != nullptr) ? atoi(lineNumStr) : -1;
method->elapsedExclusive = 0;
method->elapsedInclusive = 0;
method->topExclusive = 0;
method->recursiveInclusive = 0;
method->parents[0] = nullptr;
method->parents[1] = nullptr;
method->children[0] = nullptr;
method->children[1] = nullptr;
method->numCalls[0] = 0;
method->numCalls[1] = 0;
method->index = 0;
method->recursiveEntries = 0;
}
/*
* This comparison function is called from qsort() to sort
* methods into decreasing order of exclusive elapsed time.
*/
int32_t compareElapsedExclusive(const void* a, const void* b) {
const MethodEntry* methodA = *(const MethodEntry**) a;
const MethodEntry* methodB = *(const MethodEntry**) b;
uint64_t elapsed1 = methodA->elapsedExclusive;
uint64_t elapsed2 = methodB->elapsedExclusive;
if (elapsed1 < elapsed2) return 1;
if (elapsed1 > elapsed2) return -1;
/* If the elapsed times of two methods are equal, then sort them
* into alphabetical order.
*/
int32_t result = strcmp(methodA->className, methodB->className);
if (result == 0) {
if (methodA->methodName == nullptr || methodB->methodName == nullptr) {
int64_t idA = methodA->methodId;
int64_t idB = methodB->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
result = strcmp(methodA->methodName, methodB->methodName);
if (result == 0) result = strcmp(methodA->signature, methodB->signature);
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* methods into decreasing order of inclusive elapsed time.
*/
int32_t compareElapsedInclusive(const void* a, const void* b) {
const MethodEntry* methodA = *(MethodEntry const**) a;
const MethodEntry* methodB = *(MethodEntry const**) b;
uint64_t elapsed1 = methodA->elapsedInclusive;
uint64_t elapsed2 = methodB->elapsedInclusive;
if (elapsed1 < elapsed2) return 1;
if (elapsed1 > elapsed2) return -1;
/* If the elapsed times of two methods are equal, then sort them
* into alphabetical order.
*/
int32_t result = strcmp(methodA->className, methodB->className);
if (result == 0) {
if (methodA->methodName == nullptr || methodB->methodName == nullptr) {
int64_t idA = methodA->methodId;
int64_t idB = methodB->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
result = strcmp(methodA->methodName, methodB->methodName);
if (result == 0) result = strcmp(methodA->signature, methodB->signature);
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* TimedMethods into decreasing order of inclusive elapsed time.
*/
int32_t compareTimedMethod(const void* a, const void* b) {
const TimedMethod* timedA = (TimedMethod const*) a;
const TimedMethod* timedB = (TimedMethod const*) b;
uint64_t elapsed1 = timedA->elapsedInclusive;
uint64_t elapsed2 = timedB->elapsedInclusive;
if (elapsed1 < elapsed2) return 1;
if (elapsed1 > elapsed2) return -1;
/* If the elapsed times of two methods are equal, then sort them
* into alphabetical order.
*/
MethodEntry* methodA = timedA->method;
MethodEntry* methodB = timedB->method;
int32_t result = strcmp(methodA->className, methodB->className);
if (result == 0) {
if (methodA->methodName == nullptr || methodB->methodName == nullptr) {
int64_t idA = methodA->methodId;
int64_t idB = methodB->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
result = strcmp(methodA->methodName, methodB->methodName);
if (result == 0) result = strcmp(methodA->signature, methodB->signature);
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* MethodEntry pointers into alphabetical order of class names.
*/
int32_t compareClassNames(const void* a, const void* b) {
const MethodEntry* methodA = *(const MethodEntry**) a;
const MethodEntry* methodB = *(const MethodEntry**) b;
int32_t result = strcmp(methodA->className, methodB->className);
if (result == 0) {
int64_t idA = methodA->methodId;
int64_t idB = methodB->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* classes into decreasing order of exclusive elapsed time.
*/
int32_t compareClassExclusive(const void* a, const void* b) {
const ClassEntry* classA = *(const ClassEntry**) a;
const ClassEntry* classB = *(const ClassEntry**) b;
uint64_t elapsed1 = classA->elapsedExclusive;
uint64_t elapsed2 = classB->elapsedExclusive;
if (elapsed1 < elapsed2) return 1;
if (elapsed1 > elapsed2) return -1;
/* If the elapsed times of two classs are equal, then sort them
* into alphabetical order.
*/
int32_t result = strcmp(classA->className, classB->className);
if (result == 0) {
/* Break ties with the first method id. This is probably not
* needed.
*/
int64_t idA = classA->methods[0]->methodId;
int64_t idB = classB->methods[0]->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* MethodEntry pointers into alphabetical order by method name,
* then by class name.
*/
int32_t compareMethodNames(const void* a, const void* b) {
const MethodEntry* methodA = *(const MethodEntry**) a;
const MethodEntry* methodB = *(const MethodEntry**) b;
if (methodA->methodName == nullptr || methodB->methodName == nullptr) {
return compareClassNames(a, b);
}
int32_t result = strcmp(methodA->methodName, methodB->methodName);
if (result == 0) {
result = strcmp(methodA->className, methodB->className);
if (result == 0) {
int64_t idA = methodA->methodId;
int64_t idB = methodB->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
}
return result;
}
/*
* This comparison function is called from qsort() to sort
* unique methods into decreasing order of exclusive elapsed time.
*/
int32_t compareUniqueExclusive(const void* a, const void* b) {
const UniqueMethodEntry* uniqueA = *(const UniqueMethodEntry**) a;
const UniqueMethodEntry* uniqueB = *(const UniqueMethodEntry**) b;
uint64_t elapsed1 = uniqueA->elapsedExclusive;
uint64_t elapsed2 = uniqueB->elapsedExclusive;
if (elapsed1 < elapsed2) return 1;
if (elapsed1 > elapsed2) return -1;
/* If the elapsed times of two methods are equal, then sort them
* into alphabetical order.
*/
int32_t result = strcmp(uniqueA->methods[0]->className, uniqueB->methods[0]->className);
if (result == 0) {
int64_t idA = uniqueA->methods[0]->methodId;
int64_t idB = uniqueB->methods[0]->methodId;
if (idA < idB) return -1;
if (idA > idB) return 1;
return 0;
}
return result;
}
/*
* Free a DataKeys struct.
*/
void freeDataKeys(DataKeys* pKeys) {
if (pKeys == nullptr) return;
free(pKeys->fileData);
free(pKeys->threads);
free(pKeys->methods);
free(pKeys);
}
/*
* Find the offset to the next occurrence of the specified character.
*
* "data" should point somewhere within the current line. "len" is the
* number of bytes left in the buffer.
*
* Returns -1 if we hit the end of the buffer.
*/
int32_t findNextChar(const char* data, int32_t len, char lookFor) {
const char* start = data;
while (len > 0) {
if (*data == lookFor) return data - start;
data++;
len--;
}
return -1;
}
/*
* Count the number of lines until the next token.
*
* Returns -1 if none found before EOF.
*/
int32_t countLinesToToken(const char* data, int32_t len) {
int32_t count = 0;
int32_t next;
while (*data != TOKEN_CHAR) {
next = findNextChar(data, len, '\n');
if (next < 0) return -1;
count++;
data += next + 1;
len -= next + 1;
}
return count;
}
/*
* Make sure we're at the start of the right section.
*
* Returns the length of the token line, or -1 if something is wrong.
*/
int32_t checkToken(const char* data, int32_t len, const char* cmpStr) {
int32_t cmpLen = strlen(cmpStr);
int32_t next;
if (*data != TOKEN_CHAR) {
fprintf(stderr, "ERROR: not at start of %s (found '%.10s')\n", cmpStr, data);
return -1;
}
next = findNextChar(data, len, '\n');
if (next < cmpLen + 1) return -1;
if (strncmp(data + 1, cmpStr, cmpLen) != 0) {
fprintf(stderr, "ERROR: '%s' not found (got '%.7s')\n", cmpStr, data + 1);
return -1;
}
return next + 1;
}
/*
* Parse the "*version" section.
*/
int64_t parseVersion(DataKeys* pKeys, int64_t offset, int32_t verbose) {
if (offset < 0) return -1;
char* data = pKeys->fileData + offset;
char* dataEnd = pKeys->fileData + pKeys->fileLen;
int32_t next = checkToken(data, dataEnd - data, "version");
if (next <= 0) return -1;
data += next;
/*
* Count the number of items in the "version" section.
*/
int32_t count = countLinesToToken(data, dataEnd - data);
if (count <= 0) {
fprintf(stderr, "ERROR: failed while reading version (found %d)\n", count);
return -1;
}
/* find the end of the line */
next = findNextChar(data, dataEnd - data, '\n');
if (next < 0) return -1;
data[next] = '\0';
versionNumber = strtoul(data, nullptr, 0);
if (verbose) printf("VERSION: %d\n", versionNumber);
data += next + 1;
/* skip over the rest of the stuff, which is "name=value" lines */
for (int32_t i = 1; i < count; i++) {
next = findNextChar(data, dataEnd - data, '\n');
if (next < 0) return -1;
// data[next] = '\0';
// printf("IGNORING: '%s'\n", data);
data += next + 1;
}
return data - pKeys->fileData;
}
/*
* Parse the "*threads" section.
*/
int64_t parseThreads(DataKeys* pKeys, int64_t offset) {
if (offset < 0) return -1;
char* data = pKeys->fileData + offset;
char* dataEnd = pKeys->fileData + pKeys->fileLen;
int32_t next = checkToken(data, dataEnd - data, "threads");
data += next;
/*
* Count the number of thread entries (one per line).
*/
int32_t count = countLinesToToken(data, dataEnd - data);
if (count <= 0) {
fprintf(stderr, "ERROR: failed while reading threads (found %d)\n", count);
return -1;
}
// printf("+++ found %d threads\n", count);
pKeys->threads = new ThreadEntry[count];
if (pKeys->threads == nullptr) return -1;
/*
* Extract all entries.
*/
for (int32_t i = 0; i < count; i++) {
next = findNextChar(data, dataEnd - data, '\n');
assert(next > 0);
data[next] = '\0';
int32_t tab = findNextChar(data, next, '\t');
data[tab] = '\0';
pKeys->threads[i].threadId = atoi(data);
pKeys->threads[i].threadName = data + tab + 1;
data += next + 1;
}
pKeys->numThreads = count;
return data - pKeys->fileData;
}
/*
* Parse the "*methods" section.
*/
int64_t parseMethods(DataKeys* pKeys, int64_t offset) {
if (offset < 0) return -1;
char* data = pKeys->fileData + offset;
char* dataEnd = pKeys->fileData + pKeys->fileLen;
int32_t next = checkToken(data, dataEnd - data, "methods");
if (next < 0) return -1;
data += next;
/*
* Count the number of method entries (one per line).
*/
int32_t count = countLinesToToken(data, dataEnd - data);
if (count <= 0) {
fprintf(stderr, "ERROR: failed while reading methods (found %d)\n", count);
return -1;
}
/* Reserve an extra method at location 0 for the "toplevel" method,
* and another extra method for all other "unknown" methods.
*/
count += 2;
pKeys->methods = new MethodEntry[count];
if (pKeys->methods == nullptr) return -1;
initMethodEntry(&pKeys->methods[TOPLEVEL_INDEX], -2, "(toplevel)", nullptr, nullptr,
nullptr, nullptr);
initMethodEntry(&pKeys->methods[UNKNOWN_INDEX], -1, "(unknown)", nullptr, nullptr,
nullptr, nullptr);
/*
* Extract all entries, starting with index 2.
*/
for (int32_t i = UNKNOWN_INDEX + 1; i < count; i++) {
next = findNextChar(data, dataEnd - data, '\n');
assert(next > 0);
data[next] = '\0';
int32_t tab1 = findNextChar(data, next, '\t');
int32_t tab2 = findNextChar(data + (tab1 + 1), next - (tab1 + 1), '\t');
int32_t tab3 = findNextChar(data + (tab1 + tab2 + 2), next - (tab1 + tab2 + 2), '\t');
int32_t tab4 = findNextChar(data + (tab1 + tab2 + tab3 + 3),
next - (tab1 + tab2 + tab3 + 3), '\t');
int32_t tab5 = findNextChar(data + (tab1 + tab2 + tab3 + tab4 + 4),
next - (tab1 + tab2 + tab3 + tab4 + 4), '\t');
if (tab1 < 0) {
fprintf(stderr, "ERROR: missing field on method line: '%s'\n", data);
return -1;
}
assert(data[tab1] == '\t');
data[tab1] = '\0';
char* endptr;
int64_t id = strtoul(data, &endptr, 0);
if (*endptr != '\0') {
fprintf(stderr, "ERROR: bad method ID '%s'\n", data);
return -1;
}
// Allow files that specify just a function name, instead of requiring
// "class \t method \t signature"
if (tab2 > 0 && tab3 > 0) {
tab2 += tab1 + 1;
tab3 += tab2 + 1;
assert(data[tab2] == '\t');
assert(data[tab3] == '\t');
data[tab2] = data[tab3] = '\0';
// This is starting to get awkward. Allow filename and line #.
if (tab4 > 0 && tab5 > 0) {
tab4 += tab3 + 1;
tab5 += tab4 + 1;
assert(data[tab4] == '\t');
assert(data[tab5] == '\t');
data[tab4] = data[tab5] = '\0';
initMethodEntry(&pKeys->methods[i], id, data + tab1 + 1,
data + tab2 + 1, data + tab3 + 1, data + tab4 + 1,
data + tab5 + 1);
} else {
initMethodEntry(&pKeys->methods[i], id, data + tab1 + 1,
data + tab2 + 1, data + tab3 + 1, nullptr, nullptr);
}
} else {
initMethodEntry(&pKeys->methods[i], id, data + tab1 + 1, nullptr, nullptr, nullptr,
nullptr);
}
data += next + 1;
}
pKeys->numMethods = count;
return data - pKeys->fileData;
}
/*
* Parse the "*end" section.
*/
int64_t parseEnd(DataKeys* pKeys, int64_t offset) {
if (offset < 0) return -1;
char* data = pKeys->fileData + offset;
char* dataEnd = pKeys->fileData + pKeys->fileLen;
int32_t next = checkToken(data, dataEnd - data, "end");
if (next < 0) return -1;
data += next;
return data - pKeys->fileData;
}
/*
* Sort the thread list entries.
*/
static int32_t compareThreads(const void* thread1, const void* thread2) {
return ((const ThreadEntry*) thread1)->threadId -
((const ThreadEntry*) thread2)->threadId;
}
void sortThreadList(DataKeys* pKeys) {
qsort(pKeys->threads, pKeys->numThreads, sizeof(pKeys->threads[0]), compareThreads);
}
/*
* Sort the method list entries.
*/
static int32_t compareMethods(const void* meth1, const void* meth2) {
int64_t id1 = ((const MethodEntry*) meth1)->methodId;
int64_t id2 = ((const MethodEntry*) meth2)->methodId;
if (id1 < id2) return -1;
if (id1 > id2) return 1;
return 0;
}
void sortMethodList(DataKeys* pKeys) {
qsort(pKeys->methods, pKeys->numMethods, sizeof(MethodEntry), compareMethods);
}
/*
* Parse the key section, and return a copy of the parsed contents.
*/
DataKeys* parseKeys(FILE* fp, int32_t verbose) {
int64_t offset;
DataKeys* pKeys = new DataKeys();
memset(pKeys, 0, sizeof(DataKeys));
if (pKeys == nullptr) return nullptr;
/*
* We load the entire file into memory. We do this, rather than memory-
* mapping it, because we want to change some whitespace to NULs.
*/
if (fseek(fp, 0L, SEEK_END) != 0) {
perror("fseek");
freeDataKeys(pKeys);
return nullptr;
}
pKeys->fileLen = ftell(fp);
if (pKeys->fileLen == 0) {
fprintf(stderr, "Key file is empty.\n");
freeDataKeys(pKeys);
return nullptr;
}
rewind(fp);
pKeys->fileData = new char[pKeys->fileLen];
if (pKeys->fileData == nullptr) {
fprintf(stderr, "ERROR: unable to alloc %" PRIu64 " bytes\n", pKeys->fileLen);
freeDataKeys(pKeys);
return nullptr;
}
if (fread(pKeys->fileData, 1, pKeys->fileLen, fp) != (size_t)pKeys->fileLen) {
fprintf(stderr, "ERROR: unable to read %" PRIu64 " bytes from trace file\n", pKeys->fileLen);
freeDataKeys(pKeys);
return nullptr;
}
offset = 0;
offset = parseVersion(pKeys, offset, verbose);
offset = parseThreads(pKeys, offset);
offset = parseMethods(pKeys, offset);
offset = parseEnd(pKeys, offset);
if (offset < 0) {
freeDataKeys(pKeys);
return nullptr;
}
/* Reduce our allocation now that we know where the end of the key section is. */
pKeys->fileData = reinterpret_cast<char*>(realloc(pKeys->fileData, offset));
pKeys->fileLen = offset;
/* Leave fp pointing to the beginning of the data section. */
fseek(fp, offset, SEEK_SET);
sortThreadList(pKeys);
sortMethodList(pKeys);
/*
* Dump list of threads.
*/
if (verbose) {
printf("Threads (%d):\n", pKeys->numThreads);
for (int32_t i = 0; i < pKeys->numThreads; i++) {
printf("%2d %s\n", pKeys->threads[i].threadId, pKeys->threads[i].threadName);
}
}
#if 0
/*
* Dump list of methods.
*/
if (verbose) {
printf("Methods (%d):\n", pKeys->numMethods);
for (int32_t i = 0; i < pKeys->numMethods; i++) {
printf("0x%08x %s : %s : %s\n",
pKeys->methods[i].methodId, pKeys->methods[i].className,
pKeys->methods[i].methodName, pKeys->methods[i].signature);
}
}
#endif
return pKeys;
}
/*
* Read values from the binary data file.
*/
/*
* Make the return value "uint32_t" instead of "uint16_t" so that we can detect EOF.
*/
uint32_t read2LE(FILE* fp) {
uint32_t val = getc(fp);
val |= getc(fp) << 8;
return val;
}
uint32_t read4LE(FILE* fp) {
uint32_t val = getc(fp);
val |= getc(fp) << 8;
val |= getc(fp) << 16;
val |= getc(fp) << 24;
return val;
}
uint64_t read8LE(FILE* fp) {
uint64_t val = getc(fp);
val |= (uint64_t) getc(fp) << 8;
val |= (uint64_t) getc(fp) << 16;
val |= (uint64_t) getc(fp) << 24;
val |= (uint64_t) getc(fp) << 32;
val |= (uint64_t) getc(fp) << 40;
val |= (uint64_t) getc(fp) << 48;
val |= (uint64_t) getc(fp) << 56;
return val;
}
/*
* Parse the header of the data section.
*
* Returns with the file positioned at the start of the record data.
*/
int32_t parseDataHeader(FILE* fp, DataHeader* pHeader) {
pHeader->magic = read4LE(fp);
pHeader->version = read2LE(fp);
pHeader->offsetToData = read2LE(fp);
pHeader->startWhen = read8LE(fp);
int32_t bytesToRead = pHeader->offsetToData - 16;
if (pHeader->version == 1) {
pHeader->recordSize = 9;
} else if (pHeader->version == 2) {
pHeader->recordSize = 10;
} else if (pHeader->version == 3) {
pHeader->recordSize = read2LE(fp);
bytesToRead -= 2;
} else {
fprintf(stderr, "Unsupported trace file version: %d\n", pHeader->version);
return -1;
}
if (fseek(fp, bytesToRead, SEEK_CUR) != 0) {
return -1;
}
return 0;
}
/*
* Look up a method by it's method ID.
*
* Returns nullptr if no matching method was found.
*/
MethodEntry* lookupMethod(DataKeys* pKeys, int64_t methodId) {
int32_t lo = 0;
int32_t hi = pKeys->numMethods - 1;
while (hi >= lo) {
int32_t mid = (hi + lo) / 2;
int64_t id = pKeys->methods[mid].methodId;
if (id == methodId) /* match */
return &pKeys->methods[mid];
else if (id < methodId) /* too low */
lo = mid + 1;
else /* too high */
hi = mid - 1;
}
return nullptr;
}
/*
* Reads the next data record, and assigns the data values to threadId,
* methodVal and elapsedTime. On end-of-file, the threadId, methodVal,
* and elapsedTime are unchanged. Returns 1 on end-of-file, otherwise
* returns 0.
*/
int32_t readDataRecord(FILE* dataFp, DataHeader* dataHeader, int32_t* threadId,
uint32_t* methodVal, uint64_t* elapsedTime) {
int32_t id;
int32_t bytesToRead = dataHeader->recordSize;
if (dataHeader->version == 1) {
id = getc(dataFp);
bytesToRead -= 1;
} else {
id = read2LE(dataFp);
bytesToRead -= 2;
}
if (id == EOF) return 1;
*threadId = id;
*methodVal = read4LE(dataFp);
*elapsedTime = read4LE(dataFp);
bytesToRead -= 8;
while (bytesToRead-- > 0) {
getc(dataFp);
}
if (feof(dataFp)) {
fprintf(stderr, "WARNING: hit EOF mid-record\n");
return 1;
}
return 0;
}
/*
* Read the key file and use it to produce formatted output from the
* data file.
*/
void dumpTrace() {
static const char* actionStr[] = {"ent", "xit", "unr", "???"};
MethodEntry bogusMethod = {
0, "???", "???", "???", "???", -1, 0, 0,
0, 0, {nullptr, nullptr}, {nullptr, nullptr}, {0, 0}, 0, 0, -1};
char bogusBuf[80];
TraceData traceData;
// printf("Dumping '%s' '%s'\n", dataFileName, keyFileName);
char spaces[MAX_STACK_DEPTH + 1];
memset(spaces, '.', MAX_STACK_DEPTH);
spaces[MAX_STACK_DEPTH] = '\0';
for (int32_t i = 0; i < MAX_THREADS; i++)
traceData.depth[i] = 2; // adjust for return from start function
FILE* dataFp = fopen(gOptions.traceFileName, "rb");
if (dataFp == nullptr) return;
DataKeys* pKeys = parseKeys(dataFp, 1);
if (pKeys == nullptr) {
fclose(dataFp);
return;
}
DataHeader dataHeader;
if (parseDataHeader(dataFp, &dataHeader) < 0) {
fclose(dataFp);
freeDataKeys(pKeys);
return;
}
printf("Trace (threadID action usecs class.method signature):\n");
while (1) {
/*
* Extract values from file.
*/
int32_t threadId;
uint32_t methodVal;
uint64_t elapsedTime;
if (readDataRecord(dataFp, &dataHeader, &threadId, &methodVal, &elapsedTime))
break;
int32_t action = METHOD_ACTION(methodVal);
int64_t methodId = METHOD_ID(methodVal);
/*
* Generate a line of output.
*/
int64_t lastEnter = 0;
int32_t mismatch = 0;
if (action == METHOD_TRACE_ENTER) {
traceData.depth[threadId]++;
lastEnter = methodId;
} else {
/* quick test for mismatched adjacent enter/exit */
if (lastEnter != 0 && lastEnter != methodId) mismatch = 1;
}
int32_t printDepth = traceData.depth[threadId];
char depthNote = ' ';
if (printDepth < 0) {
printDepth = 0;
depthNote = '-';
} else if (printDepth > MAX_STACK_DEPTH) {
printDepth = MAX_STACK_DEPTH;
depthNote = '+';
}
MethodEntry* method = lookupMethod(pKeys, methodId);
if (method == nullptr) {
method = &bogusMethod;
sprintf(bogusBuf, "methodId: %#" PRIx64 "", methodId);
method->signature = bogusBuf;
}
if (method->methodName) {
printf("%2d %s%c %8" PRIu64 "%c%s%s.%s %s\n", threadId, actionStr[action],
mismatch ? '!' : ' ', elapsedTime, depthNote,
spaces + (MAX_STACK_DEPTH - printDepth), method->className,
method->methodName, method->signature);
} else {
printf("%2d %s%c %8" PRIu64 "%c%s%s\n", threadId, actionStr[action],
mismatch ? '!' : ' ', elapsedTime, depthNote,
spaces + (MAX_STACK_DEPTH - printDepth), method->className);
}
if (action != METHOD_TRACE_ENTER) {
traceData.depth[threadId]--; /* METHOD_TRACE_EXIT or METHOD_TRACE_UNROLL */
lastEnter = 0;
}
mismatch = 0;
}
fclose(dataFp);
freeDataKeys(pKeys);
}
/* This routine adds the given time to the parent and child methods.
* This is called when the child routine exits, after the child has
* been popped from the stack. The elapsedTime parameter is the
* duration of the child routine, including time spent in called routines.
*/
void addInclusiveTime(MethodEntry* parent, MethodEntry* child, uint64_t elapsedTime) {
#if 0
bool verbose = false;
if (strcmp(child->className, debugClassName) == 0)
verbose = true;
#endif
int32_t childIsRecursive = (child->recursiveEntries > 0);
int32_t parentIsRecursive = (parent->recursiveEntries > 1);
if (child->recursiveEntries == 0) {
child->elapsedInclusive += elapsedTime;
} else if (child->recursiveEntries == 1) {
child->recursiveInclusive += elapsedTime;
}
child->numCalls[childIsRecursive] += 1;
#if 0
if (verbose) {
fprintf(stderr,
"%s %d elapsedTime: %lld eI: %lld, rI: %lld\n",
child->className, child->recursiveEntries,
elapsedTime, child->elapsedInclusive,
child->recursiveInclusive);
}
#endif
/* Find the child method in the parent */
TimedMethod* pTimed;
TimedMethod* children = parent->children[parentIsRecursive];
for (pTimed = children; pTimed; pTimed = pTimed->next) {
if (pTimed->method == child) {
pTimed->elapsedInclusive += elapsedTime;
pTimed->numCalls += 1;
break;
}
}
if (pTimed == nullptr) {
/* Allocate a new TimedMethod */
pTimed = new TimedMethod();
pTimed->elapsedInclusive = elapsedTime;
pTimed->numCalls = 1;
pTimed->method = child;
/* Add it to the front of the list */
pTimed->next = children;
parent->children[parentIsRecursive] = pTimed;
}
/* Find the parent method in the child */
TimedMethod* parents = child->parents[childIsRecursive];
for (pTimed = parents; pTimed; pTimed = pTimed->next) {
if (pTimed->method == parent) {
pTimed->elapsedInclusive += elapsedTime;
pTimed->numCalls += 1;
break;
}
}
if (pTimed == nullptr) {
/* Allocate a new TimedMethod */
pTimed = new TimedMethod();
pTimed->elapsedInclusive = elapsedTime;
pTimed->numCalls = 1;
pTimed->method = parent;
/* Add it to the front of the list */
pTimed->next = parents;
child->parents[childIsRecursive] = pTimed;
}
#if 0
if (verbose) {
fprintf(stderr,
" %s %d eI: %lld\n",
parent->className, parent->recursiveEntries,
pTimed->elapsedInclusive);
}
#endif
}
/* Sorts a linked list and returns a newly allocated array containing
* the sorted entries.
*/
TimedMethod* sortTimedMethodList(TimedMethod* list, int32_t* num) {
/* Count the elements */
TimedMethod* pTimed;
int32_t num_entries = 0;
for (pTimed = list; pTimed; pTimed = pTimed->next) num_entries += 1;
*num = num_entries;
if (num_entries == 0) return nullptr;
/* Copy all the list elements to a new array and sort them */
int32_t ii;
TimedMethod* sorted = new TimedMethod[num_entries];
for (ii = 0, pTimed = list; pTimed; pTimed = pTimed->next, ++ii)
memcpy(&sorted[ii], pTimed, sizeof(TimedMethod));
qsort(sorted, num_entries, sizeof(TimedMethod), compareTimedMethod);
/* Fix up the "next" pointers so that they work. */
for (ii = 0; ii < num_entries - 1; ++ii) sorted[ii].next = &sorted[ii + 1];
sorted[num_entries - 1].next = nullptr;
return sorted;
}
/* Define flag values for printInclusiveMethod() */
static const int32_t kIsRecursive = 1;
/* This prints the inclusive stats for all the parents or children of a
* method, depending on the list that is passed in.
*/
void printInclusiveMethod(MethodEntry* method, TimedMethod* list, int32_t numCalls, int32_t flags) {
char buf[80];
const char* anchor_close = "";
const char* spaces = " "; /* 6 spaces */
int32_t num_spaces = strlen(spaces);
const char* space_ptr = &spaces[num_spaces];
char classBuf[HTML_BUFSIZE], methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
if (gOptions.outputHtml) anchor_close = "</a>";
int32_t num;
TimedMethod* sorted = sortTimedMethodList(list, &num);
double methodTotal = method->elapsedInclusive;
for (TimedMethod* pTimed = sorted; pTimed; pTimed = pTimed->next) {
MethodEntry* relative = pTimed->method;
const char* className = relative->className;
const char* methodName = relative->methodName;
const char* signature = relative->signature;
double per = 100.0 * pTimed->elapsedInclusive / methodTotal;
sprintf(buf, "[%d]", relative->index);
if (gOptions.outputHtml) {
int32_t len = strlen(buf);
if (len > num_spaces) len = num_spaces;
sprintf(buf, "<a href=\"#m%d\">[%d]", relative->index, relative->index);
space_ptr = &spaces[len];
className = htmlEscape(className, classBuf, HTML_BUFSIZE);
methodName = htmlEscape(methodName, methodBuf, HTML_BUFSIZE);
signature = htmlEscape(signature, signatureBuf, HTML_BUFSIZE);
}
int32_t nCalls = numCalls;
if (nCalls == 0) nCalls = relative->numCalls[0] + relative->numCalls[1];
if (relative->methodName) {
if (flags & kIsRecursive) {
// Don't display percentages for recursive functions
printf("%6s %5s %6s %s%6s%s %6d/%-6d %9" PRIu64 " %s.%s %s\n", "", "",
"", space_ptr, buf, anchor_close, pTimed->numCalls, nCalls,
pTimed->elapsedInclusive, className, methodName, signature);
} else {
printf("%6s %5s %5.1f%% %s%6s%s %6d/%-6d %9" PRIu64 " %s.%s %s\n", "",
"", per, space_ptr, buf, anchor_close, pTimed->numCalls, nCalls,
pTimed->elapsedInclusive, className, methodName, signature);
}
} else {
if (flags & kIsRecursive) {
// Don't display percentages for recursive functions
printf("%6s %5s %6s %s%6s%s %6d/%-6d %9" PRIu64 " %s\n", "", "", "",
space_ptr, buf, anchor_close, pTimed->numCalls, nCalls,
pTimed->elapsedInclusive, className);
} else {
printf("%6s %5s %5.1f%% %s%6s%s %6d/%-6d %9" PRIu64 " %s\n", "", "",
per, space_ptr, buf, anchor_close, pTimed->numCalls, nCalls,
pTimed->elapsedInclusive, className);
}
}
}
}
void countRecursiveEntries(CallStack* pStack, int32_t top, MethodEntry* method) {
method->recursiveEntries = 0;
for (int32_t ii = 0; ii < top; ++ii) {
if (pStack->calls[ii].method == method) method->recursiveEntries += 1;
}
}
void stackDump(CallStack* pStack, int32_t top) {
for (int32_t ii = 0; ii < top; ++ii) {
MethodEntry* method = pStack->calls[ii].method;
uint64_t entryTime = pStack->calls[ii].entryTime;
if (method->methodName) {
fprintf(stderr, " %2d: %8" PRIu64 " %s.%s %s\n", ii, entryTime,
method->className, method->methodName, method->signature);
} else {
fprintf(stderr, " %2d: %8" PRIu64 " %s\n", ii, entryTime, method->className);
}
}
}
void outputTableOfContents() {
printf("<a name=\"contents\"></a>\n");
printf("<h2>Table of Contents</h2>\n");
printf("<ul>\n");
printf(" <li><a href=\"#exclusive\">Exclusive profile</a></li>\n");
printf(" <li><a href=\"#inclusive\">Inclusive profile</a></li>\n");
printf(" <li><a href=\"#class\">Class/method profile</a></li>\n");
printf(" <li><a href=\"#method\">Method/class profile</a></li>\n");
printf("</ul>\n\n");
}
void outputNavigationBar() {
printf("<a href=\"#contents\">[Top]</a>\n");
printf("<a href=\"#exclusive\">[Exclusive]</a>\n");
printf("<a href=\"#inclusive\">[Inclusive]</a>\n");
printf("<a href=\"#class\">[Class]</a>\n");
printf("<a href=\"#method\">[Method]</a>\n");
printf("<br><br>\n");
}
void printExclusiveProfile(MethodEntry** pMethods, int32_t numMethods, uint64_t sumThreadTime) {
char classBuf[HTML_BUFSIZE], methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
const char* anchor_close = "";
char anchor_buf[80];
anchor_buf[0] = 0;
if (gOptions.outputHtml) {
anchor_close = "</a>";
printf("<a name=\"exclusive\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
} else {
printf("\n%s\n", profileSeparator);
}
/* First, sort the methods into decreasing order of inclusive
* elapsed time so that we can assign the method indices.
*/
qsort(pMethods, numMethods, sizeof(MethodEntry*), compareElapsedInclusive);
for (int32_t ii = 0; ii < numMethods; ++ii) pMethods[ii]->index = ii;
/* Sort the methods into decreasing order of exclusive elapsed time. */
qsort(pMethods, numMethods, sizeof(MethodEntry*), compareElapsedExclusive);
printf("Total cycles: %" PRIu64 "\n\n", sumThreadTime);
if (gOptions.outputHtml) {
printf("<br><br>\n");
}
printf("Exclusive elapsed times for each method, not including time spent in\n");
printf("children, sorted by exclusive time.\n\n");
if (gOptions.outputHtml) {
printf("<br><br>\n<pre>\n");
}
printf(" Usecs self %% sum %% Method\n");
double sum = 0;
double total = sumThreadTime;
for (int32_t ii = 0; ii < numMethods; ++ii) {
MethodEntry* method = pMethods[ii];
/* Don't show methods with zero cycles */
if (method->elapsedExclusive == 0) break;
const char* className = method->className;
const char* methodName = method->methodName;
const char* signature = method->signature;
sum += method->elapsedExclusive;
double per = 100.0 * method->elapsedExclusive / total;
double sum_per = 100.0 * sum / total;
if (gOptions.outputHtml) {
sprintf(anchor_buf, "<a href=\"#m%d\">", method->index);
className = htmlEscape(className, classBuf, HTML_BUFSIZE);
methodName = htmlEscape(methodName, methodBuf, HTML_BUFSIZE);
signature = htmlEscape(signature, signatureBuf, HTML_BUFSIZE);
}
if (method->methodName) {
printf("%9" PRIu64 " %6.2f %6.2f %s[%d]%s %s.%s %s\n",
method->elapsedExclusive, per, sum_per, anchor_buf, method->index,
anchor_close, className, methodName, signature);
} else {
printf("%9" PRIu64 " %6.2f %6.2f %s[%d]%s %s\n",
method->elapsedExclusive, per, sum_per, anchor_buf, method->index,
anchor_close, className);
}
}
if (gOptions.outputHtml) {
printf("</pre>\n");
}
}
/* check to make sure that the child method meets the threshold of the parent */
int32_t checkThreshold(MethodEntry* parent, MethodEntry* child) {
double parentTime = parent->elapsedInclusive;
double childTime = child->elapsedInclusive;
int64_t percentage = (childTime / parentTime) * 100.0;
return (percentage < gOptions.threshold) ? 0 : 1;
}
void createLabels(FILE* file, MethodEntry* method) {
fprintf(file,
"node%d[label = \"[%d] %s.%s (%" PRIu64 ", %" PRIu64 ", %d)\"]\n",
method->index, method->index, method->className, method->methodName,
method->elapsedInclusive / 1000, method->elapsedExclusive / 1000,
method->numCalls[0]);
method->graphState = GRAPH_LABEL_VISITED;
for (TimedMethod* child = method->children[0]; child; child = child->next) {
MethodEntry* childMethod = child->method;
if ((childMethod->graphState & GRAPH_LABEL_VISITED) == 0 &&
checkThreshold(method, childMethod)) {
createLabels(file, child->method);
}
}
}
void createLinks(FILE* file, MethodEntry* method) {
method->graphState |= GRAPH_NODE_VISITED;
for (TimedMethod* child = method->children[0]; child; child = child->next) {
MethodEntry* childMethod = child->method;
if (checkThreshold(method, child->method)) {
fprintf(file, "node%d -> node%d\n", method->index, child->method->index);
// only visit children that haven't been visited before
if ((childMethod->graphState & GRAPH_NODE_VISITED) == 0) {
createLinks(file, child->method);
}
}
}
}
void createInclusiveProfileGraphNew(DataKeys* dataKeys) {
// create a temporary file in /tmp
char path[FILENAME_MAX];
if (gOptions.keepDotFile) {
snprintf(path, FILENAME_MAX, "%s.dot", gOptions.graphFileName);
} else {
snprintf(path, FILENAME_MAX, "dot-%d-%d.dot", (int32_t)time(nullptr), rand());
}
FILE* file = fopen(path, "w+");
fprintf(file, "digraph g {\nnode [shape = record,height=.1];\n");
createLabels(file, dataKeys->methods);
createLinks(file, dataKeys->methods);
fprintf(file, "}");
fclose(file);
// now that we have the dot file generate the image
char command[1024];
snprintf(command, 1024, "dot -Tpng -o \"%s\" \"%s\"", gOptions.graphFileName, path);
system(command);
if (!gOptions.keepDotFile) {
remove(path);
}
}
void printInclusiveProfile(MethodEntry** pMethods, int32_t numMethods, uint64_t sumThreadTime) {
char classBuf[HTML_BUFSIZE], methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
char anchor_buf[80];
const char* anchor_close = "";
anchor_buf[0] = 0;
if (gOptions.outputHtml) {
anchor_close = "</a>";
printf("<a name=\"inclusive\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
} else {
printf("\n%s\n", profileSeparator);
}
/* Sort the methods into decreasing order of inclusive elapsed time. */
qsort(pMethods, numMethods, sizeof(MethodEntry*), compareElapsedInclusive);
printf("\nInclusive elapsed times for each method and its parents and children,\n");
printf("sorted by inclusive time.\n\n");
if (gOptions.outputHtml) {
printf("<br><br>\n<pre>\n");
}
printf("index %%/total %%/self index calls usecs name\n");
double total = sumThreadTime;
for (int32_t ii = 0; ii < numMethods; ++ii) {
char buf[40];
MethodEntry* method = pMethods[ii];
/* Don't show methods with zero cycles */
if (method->elapsedInclusive == 0) break;
const char* className = method->className;
const char* methodName = method->methodName;
const char* signature = method->signature;
if (gOptions.outputHtml) {
printf("<a name=\"m%d\"></a>", method->index);
className = htmlEscape(className, classBuf, HTML_BUFSIZE);
methodName = htmlEscape(methodName, methodBuf, HTML_BUFSIZE);
signature = htmlEscape(signature, signatureBuf, HTML_BUFSIZE);
}
printf("----------------------------------------------------\n");
/* Sort and print the parents */
int32_t numCalls = method->numCalls[0] + method->numCalls[1];
printInclusiveMethod(method, method->parents[0], numCalls, 0);
if (method->parents[1]) {
printf(" +++++++++++++++++++++++++\n");
printInclusiveMethod(method, method->parents[1], numCalls, kIsRecursive);
}
double per = 100.0 * method->elapsedInclusive / total;
sprintf(buf, "[%d]", ii);
if (method->methodName) {
printf("%-6s %5.1f%% %5s %6s %6d+%-6d %9" PRIu64 " %s.%s %s\n", buf,
per, "", "", method->numCalls[0], method->numCalls[1],
method->elapsedInclusive, className, methodName, signature);
} else {
printf("%-6s %5.1f%% %5s %6s %6d+%-6d %9" PRIu64 " %s\n", buf, per, "",
"", method->numCalls[0], method->numCalls[1],
method->elapsedInclusive, className);
}
double excl_per = 100.0 * method->topExclusive / method->elapsedInclusive;
printf("%6s %5s %5.1f%% %6s %6s %6s %9" PRIu64 "\n", "", "", excl_per,
"excl", "", "", method->topExclusive);
/* Sort and print the children */
printInclusiveMethod(method, method->children[0], 0, 0);
if (method->children[1]) {
printf(" +++++++++++++++++++++++++\n");
printInclusiveMethod(method, method->children[1], 0, kIsRecursive);
}
}
if (gOptions.outputHtml) {
printf("</pre>\n");
}
}
void createClassList(TraceData* traceData, MethodEntry** pMethods, int32_t numMethods) {
/* Sort the methods into alphabetical order to find the unique class
* names.
*/
qsort(pMethods, numMethods, sizeof(MethodEntry*), compareClassNames);
/* Count the number of unique class names. */
const char* currentClassName = "";
const char* firstClassName = nullptr;
traceData->numClasses = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) {
continue;
}
if (strcmp(pMethods[ii]->className, currentClassName) != 0) {
// Remember the first one
if (firstClassName == nullptr) {
firstClassName = pMethods[ii]->className;
}
traceData->numClasses += 1;
currentClassName = pMethods[ii]->className;
}
}
if (traceData->numClasses == 0) {
traceData->classes = nullptr;
return;
}
/* Allocate space for all of the unique class names */
traceData->classes = new ClassEntry[traceData->numClasses];
/* Initialize the classes array */
memset(traceData->classes, 0, sizeof(ClassEntry) * traceData->numClasses);
ClassEntry* pClass = traceData->classes;
pClass->className = currentClassName = firstClassName;
int32_t prevNumMethods = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) {
continue;
}
if (strcmp(pMethods[ii]->className, currentClassName) != 0) {
pClass->numMethods = prevNumMethods;
(++pClass)->className = currentClassName = pMethods[ii]->className;
prevNumMethods = 0;
}
prevNumMethods += 1;
}
pClass->numMethods = prevNumMethods;
/* Create the array of MethodEntry pointers for each class */
pClass = nullptr;
currentClassName = "";
int32_t nextMethod = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) {
continue;
}
if (strcmp(pMethods[ii]->className, currentClassName) != 0) {
currentClassName = pMethods[ii]->className;
if (pClass == nullptr)
pClass = traceData->classes;
else
pClass++;
/* Allocate space for the methods array */
pClass->methods = new MethodEntry*[pClass->numMethods];
nextMethod = 0;
}
pClass->methods[nextMethod++] = pMethods[ii];
}
}
/* Prints a number of html non-breaking spaces according so that the length
* of the string "buf" is at least "width" characters wide. If width is
* negative, then trailing spaces are added instead of leading spaces.
*/
void printHtmlField(char* buf, int32_t width) {
int32_t leadingSpaces = 1;
if (width < 0) {
width = -width;
leadingSpaces = 0;
}
int32_t len = strlen(buf);
int32_t numSpaces = width - len;
if (numSpaces <= 0) {
printf("%s", buf);
return;
}
if (leadingSpaces == 0) printf("%s", buf);
for (int32_t ii = 0; ii < numSpaces; ++ii) printf("&nbsp;");
if (leadingSpaces == 1) printf("%s", buf);
}
void printClassProfiles(TraceData* traceData, uint64_t sumThreadTime) {
char classBuf[HTML_BUFSIZE];
char methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
if (gOptions.outputHtml) {
printf("<a name=\"class\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
} else {
printf("\n%s\n", profileSeparator);
}
if (traceData->numClasses == 0) {
printf("\nNo classes.\n");
if (gOptions.outputHtml) {
printf("<br><br>\n");
}
return;
}
printf("\nExclusive elapsed time for each class, summed over all the methods\n");
printf("in the class.\n\n");
if (gOptions.outputHtml) {
printf("<br><br>\n");
}
/* For each class, sum the exclusive times in all of the methods
* in that class. Also sum the number of method calls. Also
* sort the methods so the most expensive appear at the top.
*/
ClassEntry* pClass = traceData->classes;
for (int32_t ii = 0; ii < traceData->numClasses; ++ii, ++pClass) {
// printf("%s %d methods\n", pClass->className, pClass->numMethods);
int32_t numMethods = pClass->numMethods;
for (int32_t jj = 0; jj < numMethods; ++jj) {
MethodEntry* method = pClass->methods[jj];
pClass->elapsedExclusive += method->elapsedExclusive;
pClass->numCalls[0] += method->numCalls[0];
pClass->numCalls[1] += method->numCalls[1];
}
/* Sort the methods into decreasing order of exclusive time */
qsort(pClass->methods, numMethods, sizeof(MethodEntry*), compareElapsedExclusive);
}
/* Allocate an array of pointers to the classes for more efficient sorting. */
ClassEntry** pClasses = new ClassEntry*[traceData->numClasses];
for (int32_t ii = 0; ii < traceData->numClasses; ++ii)
pClasses[ii] = &traceData->classes[ii];
/* Sort the classes into decreasing order of exclusive time */
qsort(pClasses, traceData->numClasses, sizeof(ClassEntry*), compareClassExclusive);
if (gOptions.outputHtml) {
printf(
"<div class=\"header\"><span "
"class=\"parent\">&nbsp;</span>&nbsp;&nbsp;&nbsp;");
printf("Cycles %%/total Cumul.%% &nbsp;Calls+Recur&nbsp; Class</div>\n");
} else {
printf(" Cycles %%/total Cumul.%% Calls+Recur Class\n");
}
double sum = 0;
double total = sumThreadTime;
for (int32_t ii = 0; ii < traceData->numClasses; ++ii) {
/* Skip classes with zero cycles */
pClass = pClasses[ii];
if (pClass->elapsedExclusive == 0) break;
sum += pClass->elapsedExclusive;
double per = 100.0 * pClass->elapsedExclusive / total;
double sum_per = 100.0 * sum / total;
const char* className = pClass->className;
if (gOptions.outputHtml) {
char buf[80];
className = htmlEscape(className, classBuf, HTML_BUFSIZE);
printf(
"<div class=\"link\" onClick=\"javascript:toggle('d%d')\" "
"onMouseOver=\"javascript:onMouseOver(this)\" "
"onMouseOut=\"javascript:onMouseOut(this)\"><span class=\"parent\" "
"id=\"xd%d\">+</span>",
ii, ii);
sprintf(buf, "%" PRIu64, pClass->elapsedExclusive);
printHtmlField(buf, 9);
printf(" ");
sprintf(buf, "%.1f", per);
printHtmlField(buf, 7);
printf(" ");
sprintf(buf, "%.1f", sum_per);
printHtmlField(buf, 7);
printf(" ");
sprintf(buf, "%d", pClass->numCalls[0]);
printHtmlField(buf, 6);
printf("+");
sprintf(buf, "%d", pClass->numCalls[1]);
printHtmlField(buf, -6);
printf(" ");
printf("%s", className);
printf("</div>\n");
printf("<div class=\"parent\" id=\"d%d\">\n", ii);
} else {
printf("---------------------------------------------\n");
printf("%9" PRIu64 " %7.1f %7.1f %6d+%-6d %s\n", pClass->elapsedExclusive,
per, sum_per, pClass->numCalls[0], pClass->numCalls[1], className);
}
int32_t numMethods = pClass->numMethods;
double classExclusive = pClass->elapsedExclusive;
double sumMethods = 0;
for (int32_t jj = 0; jj < numMethods; ++jj) {
MethodEntry* method = pClass->methods[jj];
const char* methodName = method->methodName;
const char* signature = method->signature;
per = 100.0 * method->elapsedExclusive / classExclusive;
sumMethods += method->elapsedExclusive;
sum_per = 100.0 * sumMethods / classExclusive;
if (gOptions.outputHtml) {
char buf[80];
methodName = htmlEscape(methodName, methodBuf, HTML_BUFSIZE);
signature = htmlEscape(signature, signatureBuf, HTML_BUFSIZE);
printf("<div class=\"leaf\"><span class=\"leaf\">&nbsp;</span>");
sprintf(buf, "%" PRIu64, method->elapsedExclusive);
printHtmlField(buf, 9);
printf("&nbsp;");
sprintf(buf, "%" PRIu64, method->elapsedInclusive);
printHtmlField(buf, 9);
printf("&nbsp;");
sprintf(buf, "%.1f", per);
printHtmlField(buf, 7);
printf("&nbsp;");
sprintf(buf, "%.1f", sum_per);
printHtmlField(buf, 7);
printf("&nbsp;");
sprintf(buf, "%d", method->numCalls[0]);
printHtmlField(buf, 6);
printf("+");
sprintf(buf, "%d", method->numCalls[1]);
printHtmlField(buf, -6);
printf("&nbsp;");
printf("<a href=\"#m%d\">[%d]</a>&nbsp;%s&nbsp;%s", method->index,
method->index, methodName, signature);
printf("</div>\n");
} else {
printf("%9" PRIu64 " %9" PRIu64 " %7.1f %7.1f %6d+%-6d [%d] %s %s\n",
method->elapsedExclusive, method->elapsedInclusive, per, sum_per,
method->numCalls[0], method->numCalls[1], method->index,
methodName, signature);
}
}
if (gOptions.outputHtml) {
printf("</div>\n");
}
}
}
void createUniqueMethodList(TraceData* traceData, MethodEntry** pMethods, int32_t numMethods) {
/* Sort the methods into alphabetical order of method names
* to find the unique method names.
*/
qsort(pMethods, numMethods, sizeof(MethodEntry*), compareMethodNames);
/* Count the number of unique method names, ignoring class and signature. */
const char* currentMethodName = "";
traceData->numUniqueMethods = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) continue;
if (strcmp(pMethods[ii]->methodName, currentMethodName) != 0) {
traceData->numUniqueMethods += 1;
currentMethodName = pMethods[ii]->methodName;
}
}
if (traceData->numUniqueMethods == 0) return;
/* Allocate space for pointers to all of the unique methods */
traceData->uniqueMethods = new UniqueMethodEntry[traceData->numUniqueMethods];
/* Initialize the uniqueMethods array */
memset(traceData->uniqueMethods, 0, sizeof(UniqueMethodEntry) * traceData->numUniqueMethods);
UniqueMethodEntry* pUnique = traceData->uniqueMethods;
currentMethodName = nullptr;
int32_t prevNumMethods = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) continue;
if (currentMethodName == nullptr) currentMethodName = pMethods[ii]->methodName;
if (strcmp(pMethods[ii]->methodName, currentMethodName) != 0) {
currentMethodName = pMethods[ii]->methodName;
pUnique->numMethods = prevNumMethods;
pUnique++;
prevNumMethods = 0;
}
prevNumMethods += 1;
}
pUnique->numMethods = prevNumMethods;
/* Create the array of MethodEntry pointers for each unique method */
pUnique = nullptr;
currentMethodName = "";
int32_t nextMethod = 0;
for (int32_t ii = 0; ii < numMethods; ++ii) {
if (pMethods[ii]->methodName == nullptr) continue;
if (strcmp(pMethods[ii]->methodName, currentMethodName) != 0) {
currentMethodName = pMethods[ii]->methodName;
if (pUnique == nullptr)
pUnique = traceData->uniqueMethods;
else
pUnique++;
/* Allocate space for the methods array */
pUnique->methods = new MethodEntry*[pUnique->numMethods];
nextMethod = 0;
}
pUnique->methods[nextMethod++] = pMethods[ii];
}
}
void printMethodProfiles(TraceData* traceData, uint64_t sumThreadTime) {
char classBuf[HTML_BUFSIZE], methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
if (traceData->numUniqueMethods == 0) return;
if (gOptions.outputHtml) {
printf("<a name=\"method\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
} else {
printf("\n%s\n", profileSeparator);
}
printf("\nExclusive elapsed time for each method, summed over all the classes\n");
printf("that contain a method with the same name.\n\n");
if (gOptions.outputHtml) {
printf("<br><br>\n");
}
/* For each unique method, sum the exclusive times in all of the methods
* with the same name. Also sum the number of method calls. Also
* sort the methods so the most expensive appear at the top.
*/
UniqueMethodEntry* pUnique = traceData->uniqueMethods;
for (int32_t ii = 0; ii < traceData->numUniqueMethods; ++ii, ++pUnique) {
int32_t numMethods = pUnique->numMethods;
for (int32_t jj = 0; jj < numMethods; ++jj) {
MethodEntry* method = pUnique->methods[jj];
pUnique->elapsedExclusive += method->elapsedExclusive;
pUnique->numCalls[0] += method->numCalls[0];
pUnique->numCalls[1] += method->numCalls[1];
}
/* Sort the methods into decreasing order of exclusive time */
qsort(pUnique->methods, numMethods, sizeof(MethodEntry*), compareElapsedExclusive);
}
/* Allocate an array of pointers to the methods for more efficient sorting. */
UniqueMethodEntry** pUniqueMethods = new UniqueMethodEntry*[traceData->numUniqueMethods];
for (int32_t ii = 0; ii < traceData->numUniqueMethods; ++ii)
pUniqueMethods[ii] = &traceData->uniqueMethods[ii];
/* Sort the methods into decreasing order of exclusive time */
qsort(pUniqueMethods, traceData->numUniqueMethods, sizeof(UniqueMethodEntry*),
compareUniqueExclusive);
if (gOptions.outputHtml) {
printf(
"<div class=\"header\"><span "
"class=\"parent\">&nbsp;</span>&nbsp;&nbsp;&nbsp;");
printf("Cycles %%/total Cumul.%% &nbsp;Calls+Recur&nbsp; Method</div>\n");
} else {
printf(" Cycles %%/total Cumul.%% Calls+Recur Method\n");
}
double sum = 0;
double total = sumThreadTime;
for (int32_t ii = 0; ii < traceData->numUniqueMethods; ++ii) {
/* Skip methods with zero cycles */
pUnique = pUniqueMethods[ii];
if (pUnique->elapsedExclusive == 0) break;
sum += pUnique->elapsedExclusive;
double per = 100.0 * pUnique->elapsedExclusive / total;
double sum_per = 100.0 * sum / total;
const char* methodName = pUnique->methods[0]->methodName;
if (gOptions.outputHtml) {
char buf[80];
methodName = htmlEscape(methodName, methodBuf, HTML_BUFSIZE);
printf(
"<div class=\"link\" onClick=\"javascript:toggle('e%d')\" "
"onMouseOver=\"javascript:onMouseOver(this)\" "
"onMouseOut=\"javascript:onMouseOut(this)\"><span class=\"parent\" "
"id=\"xe%d\">+</span>",
ii, ii);
sprintf(buf, "%" PRIu64, pUnique->elapsedExclusive);
printHtmlField(buf, 9);
printf(" ");
sprintf(buf, "%.1f", per);
printHtmlField(buf, 7);
printf(" ");
sprintf(buf, "%.1f", sum_per);
printHtmlField(buf, 7);
printf(" ");
sprintf(buf, "%d", pUnique->numCalls[0]);
printHtmlField(buf, 6);
printf("+");
sprintf(buf, "%d", pUnique->numCalls[1]);
printHtmlField(buf, -6);
printf(" ");
printf("%s", methodName);
printf("</div>\n");
printf("<div class=\"parent\" id=\"e%d\">\n", ii);
} else {
printf("---------------------------------------------\n");
printf("%9" PRIu64 " %7.1f %7.1f %6d+%-6d %s\n",
pUnique->elapsedExclusive, per, sum_per, pUnique->numCalls[0],
pUnique->numCalls[1], methodName);
}
int32_t numMethods = pUnique->numMethods;
double methodExclusive = pUnique->elapsedExclusive;
double sumMethods = 0;
for (int32_t jj = 0; jj < numMethods; ++jj) {
MethodEntry* method = pUnique->methods[jj];
const char* className = method->className;
const char* signature = method->signature;
per = 100.0 * method->elapsedExclusive / methodExclusive;
sumMethods += method->elapsedExclusive;
sum_per = 100.0 * sumMethods / methodExclusive;
if (gOptions.outputHtml) {
char buf[80];
className = htmlEscape(className, classBuf, HTML_BUFSIZE);
signature = htmlEscape(signature, signatureBuf, HTML_BUFSIZE);
printf("<div class=\"leaf\"><span class=\"leaf\">&nbsp;</span>");
sprintf(buf, "%" PRIu64, method->elapsedExclusive);
printHtmlField(buf, 9);
printf("&nbsp;");
sprintf(buf, "%" PRIu64, method->elapsedInclusive);
printHtmlField(buf, 9);
printf("&nbsp;");
sprintf(buf, "%.1f", per);
printHtmlField(buf, 7);
printf("&nbsp;");
sprintf(buf, "%.1f", sum_per);
printHtmlField(buf, 7);
printf("&nbsp;");
sprintf(buf, "%d", method->numCalls[0]);
printHtmlField(buf, 6);
printf("+");
sprintf(buf, "%d", method->numCalls[1]);
printHtmlField(buf, -6);
printf("&nbsp;");
printf("<a href=\"#m%d\">[%d]</a>&nbsp;%s.%s&nbsp;%s", method->index,
method->index, className, methodName, signature);
printf("</div>\n");
} else {
printf("%9" PRIu64 " %9" PRIu64 " %7.1f %7.1f %6d+%-6d [%d] %s.%s %s\n",
method->elapsedExclusive, method->elapsedInclusive, per, sum_per,
method->numCalls[0], method->numCalls[1], method->index,
className, methodName, signature);
}
}
if (gOptions.outputHtml) {
printf("</div>\n");
}
}
}
/*
* Read the key and data files and return the MethodEntries for those files
*/
DataKeys* parseDataKeys(TraceData* traceData, const char* traceFileName, uint64_t* threadTime) {
MethodEntry* caller;
FILE* dataFp = fopen(traceFileName, "rb");
if (dataFp == nullptr) return nullptr;
DataKeys* dataKeys = parseKeys(dataFp, 0);
if (dataKeys == nullptr) {
fclose(dataFp);
return nullptr;
}
DataHeader dataHeader;
if (parseDataHeader(dataFp, &dataHeader) < 0) {
fclose(dataFp);
return dataKeys;
}
#if 0
FILE* dumpStream = fopen("debug", "w");
#endif
while (1) {
/*
* Extract values from file.
*/
int32_t threadId;
uint32_t methodVal;
uint64_t currentTime;
if (readDataRecord(dataFp, &dataHeader, &threadId, &methodVal, &currentTime))
break;
int32_t action = METHOD_ACTION(methodVal);
int64_t methodId = METHOD_ID(methodVal);
/* Get the call stack for this thread */
CallStack* pStack = traceData->stacks[threadId];
/* If there is no call stack yet for this thread, then allocate one */
if (pStack == nullptr) {
pStack = new CallStack();
pStack->top = 0;
pStack->lastEventTime = currentTime;
pStack->threadStartTime = currentTime;
traceData->stacks[threadId] = pStack;
}
/* Lookup the current method */
MethodEntry* method = lookupMethod(dataKeys, methodId);
if (method == nullptr) method = &dataKeys->methods[UNKNOWN_INDEX];
#if 0
if (method->methodName) {
fprintf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s.%s %s\n",
threadId, currentTime, action, pStack->threadStartTime,
method->recursiveEntries,
pStack->top, method->className, method->methodName,
method->signature);
} else {
fprintf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s\n",
threadId, currentTime, action, pStack->threadStartTime,
method->recursiveEntries,
pStack->top, method->className);
}
#endif
if (action == METHOD_TRACE_ENTER) {
/* This is a method entry */
if (pStack->top >= MAX_STACK_DEPTH) {
fprintf(stderr, "Stack overflow (exceeded %d frames)\n",
MAX_STACK_DEPTH);
exit(1);
}
/* Get the caller method */
if (pStack->top >= 1)
caller = pStack->calls[pStack->top - 1].method;
else
caller = &dataKeys->methods[TOPLEVEL_INDEX];
countRecursiveEntries(pStack, pStack->top, caller);
caller->elapsedExclusive += currentTime - pStack->lastEventTime;
#if 0
if (caller->elapsedExclusive > 10000000)
fprintf(dumpStream, "%llu current %llu last %llu diff %llu\n",
caller->elapsedExclusive, currentTime,
pStack->lastEventTime,
currentTime - pStack->lastEventTime);
#endif
if (caller->recursiveEntries <= 1) {
caller->topExclusive += currentTime - pStack->lastEventTime;
}
/* Push the method on the stack for this thread */
pStack->calls[pStack->top].method = method;
pStack->calls[pStack->top++].entryTime = currentTime;
} else {
/* This is a method exit */
uint64_t entryTime = 0;
/* Pop the method off the stack for this thread */
if (pStack->top > 0) {
pStack->top -= 1;
entryTime = pStack->calls[pStack->top].entryTime;
if (method != pStack->calls[pStack->top].method) {
if (method->methodName) {
fprintf(stderr, "Exit from method %s.%s %s does not match stack:\n",
method->className, method->methodName, method->signature);
} else {
fprintf(stderr, "Exit from method %s does not match stack:\n",
method->className);
}
stackDump(pStack, pStack->top + 1);
exit(1);
}
}
/* Get the caller method */
if (pStack->top >= 1)
caller = pStack->calls[pStack->top - 1].method;
else
caller = &dataKeys->methods[TOPLEVEL_INDEX];
countRecursiveEntries(pStack, pStack->top, caller);
countRecursiveEntries(pStack, pStack->top, method);
uint64_t elapsed = currentTime - entryTime;
addInclusiveTime(caller, method, elapsed);
method->elapsedExclusive += currentTime - pStack->lastEventTime;
if (method->recursiveEntries == 0) {
method->topExclusive += currentTime - pStack->lastEventTime;
}
}
/* Remember the time of the last entry or exit event */
pStack->lastEventTime = currentTime;
}
/* If we have calls on the stack when the trace ends, then clean
* up the stack and add time to the callers by pretending that we
* are exiting from their methods now.
*/
uint64_t sumThreadTime = 0;
for (int32_t threadId = 0; threadId < MAX_THREADS; ++threadId) {
CallStack* pStack = traceData->stacks[threadId];
/* If this thread never existed, then continue with next thread */
if (pStack == nullptr) continue;
/* Also, add up the time taken by all of the threads */
sumThreadTime += pStack->lastEventTime - pStack->threadStartTime;
for (int32_t ii = 0; ii < pStack->top; ++ii) {
if (ii == 0)
caller = &dataKeys->methods[TOPLEVEL_INDEX];
else
caller = pStack->calls[ii - 1].method;
MethodEntry* method = pStack->calls[ii].method;
countRecursiveEntries(pStack, ii, caller);
countRecursiveEntries(pStack, ii, method);
uint64_t entryTime = pStack->calls[ii].entryTime;
uint64_t elapsed = pStack->lastEventTime - entryTime;
addInclusiveTime(caller, method, elapsed);
}
}
caller = &dataKeys->methods[TOPLEVEL_INDEX];
caller->elapsedInclusive = sumThreadTime;
#if 0
fclose(dumpStream);
#endif
if (threadTime != nullptr) {
*threadTime = sumThreadTime;
}
fclose(dataFp);
return dataKeys;
}
MethodEntry** parseMethodEntries(DataKeys* dataKeys) {
/* Create a new array of pointers to the methods and sort the pointers
* instead of the actual MethodEntry structs. We need to do this
* because there are other lists that contain pointers to the
* MethodEntry structs.
*/
MethodEntry** pMethods = new MethodEntry*[dataKeys->numMethods];
for (int32_t ii = 0; ii < dataKeys->numMethods; ++ii) {
MethodEntry* entry = &dataKeys->methods[ii];
pMethods[ii] = entry;
}
return pMethods;
}
/*
* Produce a function profile from the following methods
*/
void profileTrace(TraceData* traceData, MethodEntry** pMethods, int32_t numMethods,
uint64_t sumThreadTime) {
/* Print the html header, if necessary */
if (gOptions.outputHtml) {
printf(htmlHeader, gOptions.sortableUrl);
outputTableOfContents();
}
printExclusiveProfile(pMethods, numMethods, sumThreadTime);
printInclusiveProfile(pMethods, numMethods, sumThreadTime);
createClassList(traceData, pMethods, numMethods);
printClassProfiles(traceData, sumThreadTime);
createUniqueMethodList(traceData, pMethods, numMethods);
printMethodProfiles(traceData, sumThreadTime);
if (gOptions.outputHtml) {
printf("%s", htmlFooter);
}
}
int32_t compareMethodNamesForDiff(const void* a, const void* b) {
const MethodEntry* methodA = *(const MethodEntry**) a;
const MethodEntry* methodB = *(const MethodEntry**) b;
if (methodA->methodName == nullptr || methodB->methodName == nullptr) {
return compareClassNames(a, b);
}
int32_t result = strcmp(methodA->methodName, methodB->methodName);
if (result == 0) {
result = strcmp(methodA->signature, methodB->signature);
if (result == 0) {
return strcmp(methodA->className, methodB->className);
}
}
return result;
}
int32_t findMatch(MethodEntry** methods, int32_t size, MethodEntry* matchThis) {
for (int32_t i = 0; i < size; i++) {
MethodEntry* method = methods[i];
if (method != nullptr && !compareMethodNamesForDiff(&method, &matchThis)) {
// printf("%s.%s == %s.%s<br>\n", matchThis->className, matchThis->methodName,
// method->className, method->methodName);
return i;
// if (!compareMethodNames(&method, &matchThis)) return i;
}
}
return -1;
}
int32_t compareDiffEntriesExculsive(const void* a, const void* b) {
const DiffEntry* entryA = (const DiffEntry*) a;
const DiffEntry* entryB = (const DiffEntry*) b;
if (entryA->differenceExclusive < entryB->differenceExclusive) {
return 1;
} else if (entryA->differenceExclusive > entryB->differenceExclusive) {
return -1;
}
return 0;
}
int32_t compareDiffEntriesInculsive(const void* a, const void* b) {
const DiffEntry* entryA = (const DiffEntry*) a;
const DiffEntry* entryB = (const DiffEntry*) b;
if (entryA->differenceInclusive < entryB->differenceInclusive) {
return 1;
} else if (entryA->differenceInclusive > entryB->differenceInclusive) {
return -1;
}
return 0;
}
void printMissingMethod(MethodEntry* method) {
char classBuf[HTML_BUFSIZE];
char methodBuf[HTML_BUFSIZE];
char* className = htmlEscape(method->className, classBuf, HTML_BUFSIZE);
char* methodName = htmlEscape(method->methodName, methodBuf, HTML_BUFSIZE);
if (gOptions.outputHtml) printf("<tr><td>\n");
printf("%s.%s ", className, methodName);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", method->elapsedExclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", method->elapsedInclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%d\n", method->numCalls[0]);
if (gOptions.outputHtml) printf("</td><td>\n");
}
void createDiff(DataKeys* d1, DataKeys* d2) {
MethodEntry** methods1 = parseMethodEntries(d1);
MethodEntry** methods2 = parseMethodEntries(d2);
// sort and assign the indicies
qsort(methods1, d1->numMethods, sizeof(MethodEntry*), compareElapsedInclusive);
for (int32_t i = 0; i < d1->numMethods; ++i) {
methods1[i]->index = i;
}
qsort(methods2, d2->numMethods, sizeof(MethodEntry*), compareElapsedInclusive);
for (int32_t i = 0; i < d2->numMethods; ++i) {
methods2[i]->index = i;
}
int32_t max = (d1->numMethods < d2->numMethods) ? d2->numMethods : d1->numMethods;
max++;
DiffEntry* diffs = new DiffEntry[max];
memset(diffs, 0, max * sizeof(DiffEntry));
DiffEntry* ptr = diffs;
// printf("<br>d1->numMethods: %d d1->numMethods: %d<br>\n",
// d1->numMethods, d2->numMethods);
int32_t matches = 0;
for (int32_t i = 0; i < d1->numMethods; i++) {
int32_t match = findMatch(methods2, d2->numMethods, methods1[i]);
if (match >= 0) {
ptr->method1 = methods1[i];
ptr->method2 = methods2[match];
uint64_t e1 = ptr->method1->elapsedExclusive;
uint64_t e2 = ptr->method2->elapsedExclusive;
if (e1 > 0) {
ptr->differenceExclusive = e2 - e1;
ptr->differenceExclusivePercentage = (static_cast<double>(e2) /
static_cast<double>(e1)) * 100.0;
}
uint64_t i1 = ptr->method1->elapsedInclusive;
uint64_t i2 = ptr->method2->elapsedInclusive;
if (i1 > 0) {
ptr->differenceInclusive = i2 - i1;
ptr->differenceInclusivePercentage = (static_cast<double>(i2) /
static_cast<double>(i1)) * 100.0;
}
// clear these out so we don't find them again and we know which ones
// we have left over
methods1[i] = nullptr;
methods2[match] = nullptr;
ptr++;
matches++;
}
}
ptr->method1 = nullptr;
ptr->method2 = nullptr;
qsort(diffs, matches, sizeof(DiffEntry), compareDiffEntriesExculsive);
ptr = diffs;
if (gOptions.outputHtml) {
printf(htmlHeader, gOptions.sortableUrl);
printf("<h3>Table of Contents</h3>\n");
printf("<ul>\n");
printf("<li><a href='#exclusive'>Exclusive</a>\n");
printf("<li><a href='#inclusive'>Inclusive</a>\n");
printf("</ul>\n");
printf("Run 1: %s<br>\n", gOptions.diffFileName);
printf("Run 2: %s<br>\n", gOptions.traceFileName);
printf("<a name=\"exclusive\"></a><h3 id=\"exclusive\">Exclusive</h3>\n");
printf(tableHeader, "exclusive_table");
}
char classBuf[HTML_BUFSIZE];
char methodBuf[HTML_BUFSIZE];
while (ptr->method1 != nullptr && ptr->method2 != nullptr) {
if (gOptions.outputHtml) printf("<tr><td>\n");
char* className = htmlEscape(ptr->method1->className, classBuf, HTML_BUFSIZE);
char* methodName = htmlEscape(ptr->method1->methodName, methodBuf, HTML_BUFSIZE);
printf("%s.%s ", className, methodName);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->method1->elapsedExclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->method2->elapsedExclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->differenceExclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%.2f\n", ptr->differenceExclusivePercentage);
if (gOptions.outputHtml) printf("</td><td>\n");
printf("%d\n", ptr->method1->numCalls[0]);
if (gOptions.outputHtml) printf("</td><td>\n");
printf("%d\n", ptr->method2->numCalls[0]);
if (gOptions.outputHtml) printf("</td></tr>\n");
ptr++;
}
if (gOptions.outputHtml) printf("</table>\n");
if (gOptions.outputHtml) {
printf(htmlHeader, gOptions.sortableUrl);
printf("Run 1: %s<br>\n", gOptions.diffFileName);
printf("Run 2: %s<br>\n", gOptions.traceFileName);
printf("<a name=\"inclusive\"></a><h3 id=\"inculisve\">Inclusive</h3>\n");
printf(tableHeader, "inclusive_table");
}
qsort(diffs, matches, sizeof(DiffEntry), compareDiffEntriesInculsive);
ptr = diffs;
while (ptr->method1 != nullptr && ptr->method2 != nullptr) {
if (gOptions.outputHtml) printf("<tr><td>\n");
char* className = htmlEscape(ptr->method1->className, classBuf, HTML_BUFSIZE);
char* methodName = htmlEscape(ptr->method1->methodName, methodBuf, HTML_BUFSIZE);
printf("%s.%s ", className, methodName);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->method1->elapsedInclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->method2->elapsedInclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%" PRIu64 " ", ptr->differenceInclusive);
if (gOptions.outputHtml) printf("</td><td>");
printf("%.2f\n", ptr->differenceInclusivePercentage);
if (gOptions.outputHtml) printf("</td><td>\n");
printf("%d\n", ptr->method1->numCalls[0]);
if (gOptions.outputHtml) printf("</td><td>\n");
printf("%d\n", ptr->method2->numCalls[0]);
if (gOptions.outputHtml) printf("</td></tr>\n");
ptr++;
}
if (gOptions.outputHtml) {
printf("</table>\n");
printf("<h3>Run 1 methods not found in Run 2</h3>");
printf(tableHeaderMissing, "?");
}
for (int32_t i = 0; i < d1->numMethods; ++i) {
if (methods1[i] != nullptr) {
printMissingMethod(methods1[i]);
}
}
if (gOptions.outputHtml) {
printf("</table>\n");
printf("<h3>Run 2 methods not found in Run 1</h3>");
printf(tableHeaderMissing, "?");
}
for (int32_t i = 0; i < d2->numMethods; ++i) {
if (methods2[i] != nullptr) {
printMissingMethod(methods2[i]);
}
}
if (gOptions.outputHtml) printf("</body></html\n");
}
int32_t usage(const char* program) {
fprintf(stderr, "Copyright (C) 2006 The Android Open Source Project\n\n");
fprintf(stderr,
"usage: %s [-ho] [-s sortable] [-d trace-file-name] [-g outfile] "
"trace-file-name\n",
program);
fprintf(stderr, " -d trace-file-name - Diff with this trace\n");
fprintf(stderr, " -g outfile - Write graph to 'outfile'\n");
fprintf(stderr,
" -k - When writing a graph, keep the intermediate "
"DOT file\n");
fprintf(stderr, " -h - Turn on HTML output\n");
fprintf(
stderr,
" -o - Dump the dmtrace file instead of profiling\n");
fprintf(stderr,
" -s - URL base to where the sortable javascript "
"file\n");
fprintf(stderr,
" -t threshold - Threshold percentage for including nodes in "
"the graph\n");
return 2;
}
// Returns true if there was an error
int32_t parseOptions(int32_t argc, char** argv) {
while (1) {
int32_t opt = getopt(argc, argv, "d:hg:kos:t:");
if (opt == -1) break;
switch (opt) {
case 'd':
gOptions.diffFileName = optarg;
break;
case 'g':
gOptions.graphFileName = optarg;
break;
case 'k':
gOptions.keepDotFile = 1;
break;
case 'h':
gOptions.outputHtml = 1;
break;
case 'o':
gOptions.dump = 1;
break;
case 's':
gOptions.sortableUrl = optarg;
break;
case 't':
gOptions.threshold = atoi(optarg);
break;
default:
return 1;
}
}
return 0;
}
/*
* Parse args.
*/
int32_t main(int32_t argc, char** argv) {
gOptions.threshold = -1;
// Parse the options
if (parseOptions(argc, argv) || argc - optind != 1) return usage(argv[0]);
gOptions.traceFileName = argv[optind];
if (gOptions.threshold < 0 || 100 <= gOptions.threshold) {
gOptions.threshold = 20;
}
if (gOptions.dump) {
dumpTrace();
return 0;
}
uint64_t sumThreadTime = 0;
TraceData data1;
DataKeys* dataKeys = parseDataKeys(&data1, gOptions.traceFileName, &sumThreadTime);
if (dataKeys == nullptr) {
fprintf(stderr, "Cannot read \"%s\".\n", gOptions.traceFileName);
exit(1);
}
if (gOptions.diffFileName != nullptr) {
uint64_t sum2;
TraceData data2;
DataKeys* d2 = parseDataKeys(&data2, gOptions.diffFileName, &sum2);
if (d2 == nullptr) {
fprintf(stderr, "Cannot read \"%s\".\n", gOptions.diffFileName);
exit(1);
}
createDiff(d2, dataKeys);
freeDataKeys(d2);
} else {
MethodEntry** methods = parseMethodEntries(dataKeys);
profileTrace(&data1, methods, dataKeys->numMethods, sumThreadTime);
if (gOptions.graphFileName != nullptr) {
createInclusiveProfileGraphNew(dataKeys);
}
free(methods);
}
freeDataKeys(dataKeys);
return 0;
}