dalvik/vm/hprof/HprofStackFrame.c

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "Hprof.h"
  18 #include "HprofStack.h"
  19
  20 #include "alloc/HeapInternal.h"
  21
  22 static HashTable *gStackFrameHashTable;
  23
  24 static u4 computeStackFrameHash(const StackFrameEntry *stackFrameEntry);
  25
  26 int
  27 hprofStartup_StackFrame()
  28 {
  29     HashIter iter;
  30
  31     /* Cache the string "<unknown>" for use when the source file is
  32      * unknown.
  33      */
  34     hprofLookupStringId("<unknown>");
  35
  36     /* This will be called when a GC begins. */
  37     for (dvmHashIterBegin(gStackFrameHashTable, &iter);
  38          !dvmHashIterDone(&iter);
  39          dvmHashIterNext(&iter)) {
  40         StackFrameEntry *stackFrameEntry;
  41         const Method *method;
  42
  43         /* Clear the 'live' bit at the start of the GC pass. */
  44         stackFrameEntry = (StackFrameEntry *) dvmHashIterData(&iter);
  45         stackFrameEntry->live = 0;
  46
  47         method = stackFrameEntry->frame.method;
  48         if (method == NULL) {
  49             continue;
  50         }
  51
  52         /* Make sure the method name, descriptor, and source file are in
  53          * the string table, and that the method class is in the class
  54          * table. This is needed because strings and classes will be dumped
  55          * before stack frames.
  56          */
  57
  58         if (method->name) {
  59             hprofLookupStringId(method->name);
  60         }
  61
  62         DexStringCache cache;
  63         const char* descriptor;
  64
  65         dexStringCacheInit(&cache);
  66         descriptor = dexProtoGetMethodDescriptor(&method->prototype, &cache);
  67         hprofLookupStringId(descriptor);
  68         dexStringCacheRelease(&cache);
  69
  70         const char* sourceFile = dvmGetMethodSourceFile(method);
  71         if (sourceFile) {
  72             hprofLookupStringId(sourceFile);
  73         }
  74
  75         if (method->clazz) {
  76             hprofLookupClassId(method->clazz);
  77         }
  78     }
  79
  80     return 0;
  81 }
  82
  83 int
  84 hprofShutdown_StackFrame()
  85 {
  86     HashIter iter;
  87
  88     /* This will be called when a GC has completed. */
  89     for (dvmHashIterBegin(gStackFrameHashTable, &iter);
  90          !dvmHashIterDone(&iter);
  91          dvmHashIterNext(&iter)) {
  92         const StackFrameEntry *stackFrameEntry;
  93
  94         /*
  95          * If the 'live' bit is 0, the frame is not in use by any current
  96          * heap object and may be destroyed.
  97          */
  98         stackFrameEntry = (const StackFrameEntry *) dvmHashIterData(&iter);
  99         if (!stackFrameEntry->live) {
 100             dvmHashTableRemove(gStackFrameHashTable,
 101                     computeStackFrameHash(stackFrameEntry),
 102                     (void*) stackFrameEntry);
 103             free((void*) stackFrameEntry);
 104         }
 105     }
 106
 107     return 0;
 108 }
 109
 110 /* Only hash the 'frame' portion of the StackFrameEntry. */
 111 static u4
 112 computeStackFrameHash(const StackFrameEntry *stackFrameEntry)
 113 {
 114     u4 hash = 0;
 115     const char *cp = (char *) &stackFrameEntry->frame;
 116     int i;
 117
 118     for (i = 0; i < (int) sizeof(StackFrame); i++) {
 119         hash = 31 * hash + cp[i];
 120     }
 121     return hash;
 122 }
 123
 124 /* Only compare the 'frame' portion of the StackFrameEntry. */
 125 static int
 126 stackFrameCmp(const void *tableItem, const void *looseItem)
 127 {
 128     return memcmp(&((StackFrameEntry *)tableItem)->frame,
 129             &((StackFrameEntry *) looseItem)->frame, sizeof(StackFrame));
 130 }
 131
 132 static StackFrameEntry *
 133 stackFrameDup(const StackFrameEntry *stackFrameEntry)
 134 {
 135     StackFrameEntry *newStackFrameEntry = malloc(sizeof(StackFrameEntry));
 136     memcpy(newStackFrameEntry, stackFrameEntry, sizeof(StackFrameEntry));
 137     return newStackFrameEntry;
 138 }
 139
 140 hprof_stack_frame_id
 141 hprofLookupStackFrameId(const StackFrameEntry *stackFrameEntry)
 142 {
 143     StackFrameEntry *val;
 144     u4 hashValue;
 145
 146     /*
 147      * Create the hash table on first contact.  We can't do this in
 148      * hprofStartupStackFrame, because we have to compute stack trace
 149      * serial numbers and place them into object headers before the
 150      * rest of hprof is triggered by a GC event.
 151      */
 152     if (gStackFrameHashTable == NULL) {
 153         gStackFrameHashTable = dvmHashTableCreate(512, free);
 154     }
 155     dvmHashTableLock(gStackFrameHashTable);
 156
 157     hashValue = computeStackFrameHash(stackFrameEntry);
 158     val = dvmHashTableLookup(gStackFrameHashTable, hashValue,
 159         (void *)stackFrameEntry, (HashCompareFunc)stackFrameCmp, false);
 160     if (val == NULL) {
 161         const StackFrameEntry *newStackFrameEntry;
 162
 163         newStackFrameEntry = stackFrameDup(stackFrameEntry);
 164         val = dvmHashTableLookup(gStackFrameHashTable, hashValue,
 165             (void *)newStackFrameEntry, (HashCompareFunc)stackFrameCmp, true);
 166         assert(val != NULL);
 167     }
 168
 169     /* Mark the frame as live (in use by an object in the current heap). */
 170     val->live = 1;
 171
 172     dvmHashTableUnlock(gStackFrameHashTable);
 173
 174     return (hprof_stack_frame_id) val;
 175 }
 176
 177 int
 178 hprofDumpStackFrames(hprof_context_t *ctx)
 179 {
 180     HashIter iter;
 181     hprof_record_t *rec = &ctx->curRec;
 182
 183     dvmHashTableLock(gStackFrameHashTable);
 184
 185     for (dvmHashIterBegin(gStackFrameHashTable, &iter);
 186          !dvmHashIterDone(&iter);
 187          dvmHashIterNext(&iter))
 188     {
 189         const StackFrameEntry *stackFrameEntry;
 190         const Method *method;
 191         int pc;
 192         const char *sourceFile;
 193         ClassObject *clazz;
 194         int lineNum;
 195
 196         hprofStartNewRecord(ctx, HPROF_TAG_STACK_FRAME, HPROF_TIME);
 197
 198         stackFrameEntry = (const StackFrameEntry *) dvmHashIterData(&iter);
 199         assert(stackFrameEntry != NULL);
 200
 201         method = stackFrameEntry->frame.method;
 202         pc = stackFrameEntry->frame.pc;
 203         sourceFile = dvmGetMethodSourceFile(method);
 204         if (sourceFile == NULL) {
 205             sourceFile = "<unknown>";
 206             lineNum = 0;
 207         } else {
 208             lineNum = dvmLineNumFromPC(method, pc);
 209         }
 210         clazz = (ClassObject *) hprofLookupClassId(method->clazz);
 211
 212         /* STACK FRAME format:
 213          *
 214          * ID:     ID for this stack frame
 215          * ID:     ID for the method name
 216          * ID:     ID for the method descriptor
 217          * ID:     ID for the source file name
 218          * u4:     class serial number
 219          * u4:     line number, 0 = no line information
 220          *
 221          * We use the address of the stack frame as its ID.
 222          */
 223
 224         DexStringCache cache;
 225         const char* descriptor;
 226
 227         dexStringCacheInit(&cache);
 228         descriptor = dexProtoGetMethodDescriptor(&method->prototype, &cache);
 229
 230         hprofAddIdToRecord(rec, (u4) stackFrameEntry);
 231         hprofAddIdToRecord(rec, hprofLookupStringId(method->name));
 232         hprofAddIdToRecord(rec, hprofLookupStringId(descriptor));
 233         hprofAddIdToRecord(rec, hprofLookupStringId(sourceFile));
 234         hprofAddU4ToRecord(rec, (u4) clazz->serialNumber);
 235         hprofAddU4ToRecord(rec, (u4) lineNum);
 236
 237         dexStringCacheRelease(&cache);
 238     }
 239
 240     dvmHashTableUnlock(gStackFrameHashTable);
 241     return 0;
 242 }