int
hprofShutdown_Stack()
{
HashIter iter;
/* This will be called when a GC has completed. */
for (dvmHashIterBegin(gStackTraceHashTable, &iter);
!dvmHashIterDone(&iter);
dvmHashIterNext(&iter)) {
StackTraceEntry *stackTraceEntry;
/*
* If the 'live' bit is 0, the trace is not in use by any current
* heap object and may be destroyed.
*/
stackTraceEntry = (StackTraceEntry *) dvmHashIterData(&iter);
if (!stackTraceEntry->live) {
dvmHashTableRemove(gStackTraceHashTable,
computeStackTraceHash(stackTraceEntry), stackTraceEntry);
free(stackTraceEntry);
}
}
return 0;
}
/*
* Evaluate the amount of probing required for the specified hash table.
*
* We do this by running through all entries in the hash table, computing
* the hash value and then doing a lookup.
*
* The caller should lock the table before calling here.
*/
void dvmHashTableProbeCount(HashTable* pHashTable, HashCalcFunc calcFunc,
HashCompareFunc cmpFunc)
{
int numEntries, minProbe, maxProbe, totalProbe;
HashIter iter;
numEntries = maxProbe = totalProbe = 0;
minProbe = 65536*32767;
for (dvmHashIterBegin(pHashTable, &iter); !dvmHashIterDone(&iter);
dvmHashIterNext(&iter))
{
const void* data = (const void*)dvmHashIterData(&iter);
int count;
count = countProbes(pHashTable, (*calcFunc)(data), data, cmpFunc);
numEntries++;
if (count < minProbe)
minProbe = count;
if (count > maxProbe)
maxProbe = count;
totalProbe += count;
}
LOGI("Probe: min=%d max=%d, total=%d in %d (%d), avg=%.3f\n",
minProbe, maxProbe, totalProbe, numEntries, pHashTable->tableSize,
(float) totalProbe / (float) numEntries);
}
int
hprofStartup_StackFrame()
{
HashIter iter;
/* Cache the string "<unknown>" for use when the source file is
* unknown.
*/
hprofLookupStringId("<unknown>");
/* This will be called when a GC begins. */
for (dvmHashIterBegin(gStackFrameHashTable, &iter);
!dvmHashIterDone(&iter);
dvmHashIterNext(&iter)) {
StackFrameEntry *stackFrameEntry;
const Method *method;
/* Clear the 'live' bit at the start of the GC pass. */
stackFrameEntry = (StackFrameEntry *) dvmHashIterData(&iter);
stackFrameEntry->live = 0;
method = stackFrameEntry->frame.method;
if (method == NULL) {
continue;
}
/* Make sure the method name, descriptor, and source file are in
* the string table, and that the method class is in the class
* table. This is needed because strings and classes will be dumped
* before stack frames.
*/
if (method->name) {
hprofLookupStringId(method->name);
}
DexStringCache cache;
const char* descriptor;
dexStringCacheInit(&cache);
descriptor = dexProtoGetMethodDescriptor(&method->prototype, &cache);
hprofLookupStringId(descriptor);
dexStringCacheRelease(&cache);
const char* sourceFile = dvmGetMethodSourceFile(method);
if (sourceFile) {
hprofLookupStringId(sourceFile);
}
if (method->clazz) {
hprofLookupClassId(method->clazz);
}
}
return 0;
}
int
hprofDumpStacks(hprof_context_t *ctx)
{
HashIter iter;
hprof_record_t *rec = &ctx->curRec;
dvmHashTableLock(gStackTraceHashTable);
for (dvmHashIterBegin(gStackTraceHashTable, &iter);
!dvmHashIterDone(&iter);
dvmHashIterNext(&iter))
{
const StackTraceEntry *stackTraceEntry;
int count;
int i;
hprofStartNewRecord(ctx, HPROF_TAG_STACK_TRACE, HPROF_TIME);
stackTraceEntry = (const StackTraceEntry *) dvmHashIterData(&iter);
assert(stackTraceEntry != NULL);
/* STACK TRACE format:
*
* u4: serial number for this stack
* u4: serial number for the running thread
* u4: number of frames
* [ID]*: ID for the stack frame
*/
hprofAddU4ToRecord(rec, stackTraceEntry->trace.serialNumber);
hprofAddU4ToRecord(rec, stackTraceEntry->trace.threadSerialNumber);
count = 0;
while ((count < STACK_DEPTH) &&
(stackTraceEntry->trace.frameIds[count] != 0)) {
count++;
}
hprofAddU4ToRecord(rec, count);
for (i = 0; i < count; i++) {
hprofAddU4ToRecord(rec, stackTraceEntry->trace.frameIds[i]);
}
}
dvmHashTableUnlock(gStackTraceHashTable);
return 0;
}
int
hprofStartup_Stack()
{
HashIter iter;
/* This will be called when a GC begins. */
for (dvmHashIterBegin(gStackTraceHashTable, &iter);
!dvmHashIterDone(&iter);
dvmHashIterNext(&iter)) {
StackTraceEntry *stackTraceEntry;
/* Clear the 'live' bit at the start of the GC pass. */
stackTraceEntry = (StackTraceEntry *) dvmHashIterData(&iter);
stackTraceEntry->live = 0;
}
return 0;
}
int
hprofDumpClasses(hprof_context_t *ctx)
{
HashIter iter;
hprof_record_t *rec = &ctx->curRec;
int err;
dvmHashTableLock(gClassHashTable);
for (err = 0, dvmHashIterBegin(gClassHashTable, &iter);
err == 0 && !dvmHashIterDone(&iter);
dvmHashIterNext(&iter))
{
err = hprofStartNewRecord(ctx, HPROF_TAG_LOAD_CLASS, HPROF_TIME);
if (err == 0) {
const ClassObject *clazz;
clazz = (const ClassObject *)dvmHashIterData(&iter);
assert(clazz != NULL);
/* LOAD CLASS format:
*
* u4: class serial number (always > 0)
* ID: class object ID
* u4: stack trace serial number
* ID: class name string ID
*
* We use the address of the class object structure as its ID.
*/
hprofAddU4ToRecord(rec, clazz->serialNumber);
hprofAddIdToRecord(rec, (hprof_class_object_id)clazz);
hprofAddU4ToRecord(rec, HPROF_NULL_STACK_TRACE);
hprofAddIdToRecord(rec, getPrettyClassNameId(clazz->descriptor));
}
}
dvmHashTableUnlock(gClassHashTable);
return err;
}
int
hprofDumpStackFrames(hprof_context_t *ctx)
{
HashIter iter;
hprof_record_t *rec = &ctx->curRec;
dvmHashTableLock(gStackFrameHashTable);
for (dvmHashIterBegin(gStackFrameHashTable, &iter);
!dvmHashIterDone(&iter);
dvmHashIterNext(&iter))
{
const StackFrameEntry *stackFrameEntry;
const Method *method;
int pc;
const char *sourceFile;
ClassObject *clazz;
int lineNum;
hprofStartNewRecord(ctx, HPROF_TAG_STACK_FRAME, HPROF_TIME);
stackFrameEntry = (const StackFrameEntry *) dvmHashIterData(&iter);
assert(stackFrameEntry != NULL);
method = stackFrameEntry->frame.method;
pc = stackFrameEntry->frame.pc;
sourceFile = dvmGetMethodSourceFile(method);
if (sourceFile == NULL) {
sourceFile = "<unknown>";
lineNum = 0;
} else {
lineNum = dvmLineNumFromPC(method, pc);
}
clazz = (ClassObject *) hprofLookupClassId(method->clazz);
/* STACK FRAME format:
*
* ID: ID for this stack frame
* ID: ID for the method name
* ID: ID for the method descriptor
* ID: ID for the source file name
* u4: class serial number
* u4: line number, 0 = no line information
*
* We use the address of the stack frame as its ID.
*/
DexStringCache cache;
const char* descriptor;
dexStringCacheInit(&cache);
descriptor = dexProtoGetMethodDescriptor(&method->prototype, &cache);
hprofAddIdToRecord(rec, (u4) stackFrameEntry);
hprofAddIdToRecord(rec, hprofLookupStringId(method->name));
hprofAddIdToRecord(rec, hprofLookupStringId(descriptor));
hprofAddIdToRecord(rec, hprofLookupStringId(sourceFile));
hprofAddU4ToRecord(rec, (u4) clazz->serialNumber);
hprofAddU4ToRecord(rec, (u4) lineNum);
dexStringCacheRelease(&cache);
}
dvmHashTableUnlock(gStackFrameHashTable);
return 0;
}
