vm/hprof/HprofHeap.cpp

   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  * Heap object dump
  18  */
  19 #include "Hprof.h"
  20
  21 /* Set DUMP_PRIM_DATA to 1 if you want to include the contents
  22  * of primitive arrays (byte arrays, character arrays, etc.)
  23  * in heap dumps.  This can be a large amount of data.
  24  */
  25 #define DUMP_PRIM_DATA 1
  26
  27 #define OBJECTS_PER_SEGMENT     ((size_t)128)
  28 #define BYTES_PER_SEGMENT       ((size_t)4096)
  29
  30 /* The static field-name for the synthetic object generated to account
  31  * for class Static overhead.
  32  */
  33 #define STATIC_OVERHEAD_NAME    "$staticOverhead"
  34 /* The ID for the synthetic object generated to account for class
  35  * Static overhead.
  36  */
  37 #define CLASS_STATICS_ID(clazz) ((hprof_object_id)(((u4)(clazz)) | 1))
  38
  39 int hprofStartHeapDump(hprof_context_t *ctx)
  40 {
  41     UNUSED_PARAMETER(ctx);
  42
  43     ctx->objectsInSegment = OBJECTS_PER_SEGMENT;
  44     ctx->currentHeap = HPROF_HEAP_DEFAULT;
  45     return 0;
  46 }
  47
  48 int hprofFinishHeapDump(hprof_context_t *ctx)
  49 {
  50     return hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_END, HPROF_TIME);
  51 }
  52
  53 int hprofSetGcScanState(hprof_context_t *ctx,
  54                         hprof_heap_tag_t state,
  55                         u4 threadSerialNumber)
  56 {
  57     /* Used by hprofMarkRootObject()
  58      */
  59     ctx->gcScanState = state;
  60     ctx->gcThreadSerialNumber = threadSerialNumber;
  61     return 0;
  62 }
  63
  64 static hprof_basic_type signatureToBasicTypeAndSize(const char *sig,
  65                                                     size_t *sizeOut)
  66 {
  67     char c = sig[0];
  68     hprof_basic_type ret;
  69     size_t size;
  70
  71     switch (c) {
  72     case '[':
  73     case 'L': ret = hprof_basic_object;  size = 4; break;
  74     case 'Z': ret = hprof_basic_boolean; size = 1; break;
  75     case 'C': ret = hprof_basic_char;    size = 2; break;
  76     case 'F': ret = hprof_basic_float;   size = 4; break;
  77     case 'D': ret = hprof_basic_double;  size = 8; break;
  78     case 'B': ret = hprof_basic_byte;    size = 1; break;
  79     case 'S': ret = hprof_basic_short;   size = 2; break;
  80     default: assert(false);
  81     case 'I': ret = hprof_basic_int;     size = 4; break;
  82     case 'J': ret = hprof_basic_long;    size = 8; break;
  83     }
  84
  85     if (sizeOut != NULL) {
  86         *sizeOut = size;
  87     }
  88
  89     return ret;
  90 }
  91
  92 static hprof_basic_type primitiveToBasicTypeAndSize(PrimitiveType prim,
  93                                                     size_t *sizeOut)
  94 {
  95     hprof_basic_type ret;
  96     size_t size;
  97
  98     switch (prim) {
  99     case PRIM_BOOLEAN: ret = hprof_basic_boolean; size = 1; break;
 100     case PRIM_CHAR:    ret = hprof_basic_char;    size = 2; break;
 101     case PRIM_FLOAT:   ret = hprof_basic_float;   size = 4; break;
 102     case PRIM_DOUBLE:  ret = hprof_basic_double;  size = 8; break;
 103     case PRIM_BYTE:    ret = hprof_basic_byte;    size = 1; break;
 104     case PRIM_SHORT:   ret = hprof_basic_short;   size = 2; break;
 105     default: assert(false);
 106     case PRIM_INT:     ret = hprof_basic_int;     size = 4; break;
 107     case PRIM_LONG:    ret = hprof_basic_long;    size = 8; break;
 108     }
 109
 110     if (sizeOut != NULL) {
 111         *sizeOut = size;
 112     }
 113
 114     return ret;
 115 }
 116
 117 /* Always called when marking objects, but only does
 118  * something when ctx->gcScanState is non-zero, which is usually
 119  * only true when marking the root set or unreachable
 120  * objects.  Used to add rootset references to obj.
 121  */
 122 int hprofMarkRootObject(hprof_context_t *ctx, const Object *obj, jobject jniObj)
 123 {
 124     hprof_record_t *rec = &ctx->curRec;
 125     int err;
 126     hprof_heap_tag_t heapTag = (hprof_heap_tag_t)ctx->gcScanState;
 127
 128     if (heapTag == 0) {
 129         return 0;
 130     }
 131
 132     if (ctx->objectsInSegment >= OBJECTS_PER_SEGMENT ||
 133         rec->length >= BYTES_PER_SEGMENT)
 134     {
 135         /* This flushes the old segment and starts a new one.
 136          */
 137         hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME);
 138         ctx->objectsInSegment = 0;
 139     }
 140
 141     switch (heapTag) {
 142     /* ID: object ID
 143      */
 144     case HPROF_ROOT_UNKNOWN:
 145     case HPROF_ROOT_STICKY_CLASS:
 146     case HPROF_ROOT_MONITOR_USED:
 147     case HPROF_ROOT_INTERNED_STRING:
 148     case HPROF_ROOT_FINALIZING:
 149     case HPROF_ROOT_DEBUGGER:
 150     case HPROF_ROOT_REFERENCE_CLEANUP:
 151     case HPROF_ROOT_VM_INTERNAL:
 152         hprofAddU1ToRecord(rec, heapTag);
 153         hprofAddIdToRecord(rec, (hprof_object_id)obj);
 154         break;
 155
 156     /* ID: object ID
 157      * ID: JNI global ref ID
 158      */
 159     case HPROF_ROOT_JNI_GLOBAL:
 160         hprofAddU1ToRecord(rec, heapTag);
 161         hprofAddIdToRecord(rec, (hprof_object_id)obj);
 162         hprofAddIdToRecord(rec, (hprof_id)jniObj);
 163         break;
 164
 165     /* ID: object ID
 166      * u4: thread serial number
 167      * u4: frame number in stack trace (-1 for empty)
 168      */
 169     case HPROF_ROOT_JNI_LOCAL:
 170     case HPROF_ROOT_JNI_MONITOR:
 171     case HPROF_ROOT_JAVA_FRAME:
 172         hprofAddU1ToRecord(rec, heapTag);
 173         hprofAddIdToRecord(rec, (hprof_object_id)obj);
 174         hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber);
 175         hprofAddU4ToRecord(rec, (u4)-1);
 176         break;
 177
 178     /* ID: object ID
 179      * u4: thread serial number
 180      */
 181     case HPROF_ROOT_NATIVE_STACK:
 182     case HPROF_ROOT_THREAD_BLOCK:
 183         hprofAddU1ToRecord(rec, heapTag);
 184         hprofAddIdToRecord(rec, (hprof_object_id)obj);
 185         hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber);
 186         break;
 187
 188     /* ID: thread object ID
 189      * u4: thread serial number
 190      * u4: stack trace serial number
 191      */
 192     case HPROF_ROOT_THREAD_OBJECT:
 193         hprofAddU1ToRecord(rec, heapTag);
 194         hprofAddIdToRecord(rec, (hprof_object_id)obj);
 195         hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber);
 196         hprofAddU4ToRecord(rec, (u4)-1);    //xxx
 197         break;
 198
 199     default:
 200         err = 0;
 201         break;
 202     }
 203
 204     ctx->objectsInSegment++;
 205
 206     return err;
 207 }
 208
 209 static int stackTraceSerialNumber(const void *obj)
 210 {
 211     return HPROF_NULL_STACK_TRACE;
 212 }
 213
 214 int hprofDumpHeapObject(hprof_context_t *ctx, const Object *obj)
 215 {
 216     const ClassObject *clazz;
 217     hprof_record_t *rec = &ctx->curRec;
 218     HprofHeapId desiredHeap;
 219
 220     desiredHeap = dvmIsZygoteObject(obj) ? HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP;
 221
 222     if (ctx->objectsInSegment >= OBJECTS_PER_SEGMENT ||
 223         rec->length >= BYTES_PER_SEGMENT)
 224     {
 225         /* This flushes the old segment and starts a new one.
 226          */
 227         hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME);
 228         ctx->objectsInSegment = 0;
 229
 230         /* Starting a new HEAP_DUMP resets the heap to default.
 231          */
 232         ctx->currentHeap = HPROF_HEAP_DEFAULT;
 233     }
 234
 235     if (desiredHeap != ctx->currentHeap) {
 236         hprof_string_id nameId;
 237
 238         /* This object is in a different heap than the current one.
 239          * Emit a HEAP_DUMP_INFO tag to change heaps.
 240          */
 241         hprofAddU1ToRecord(rec, HPROF_HEAP_DUMP_INFO);
 242         hprofAddU4ToRecord(rec, (u4)desiredHeap);   // u4: heap id
 243         switch (desiredHeap) {
 244         case HPROF_HEAP_APP:
 245             nameId = hprofLookupStringId("app");
 246             break;
 247         case HPROF_HEAP_ZYGOTE:
 248             nameId = hprofLookupStringId("zygote");
 249             break;
 250         default:
 251             /* Internal error. */
 252             assert(!"Unexpected desiredHeap");
 253             nameId = hprofLookupStringId("<ILLEGAL>");
 254             break;
 255         }
 256         hprofAddIdToRecord(rec, nameId);
 257         ctx->currentHeap = desiredHeap;
 258     }
 259
 260     clazz = obj->clazz;
 261
 262     if (clazz == NULL) {
 263         /* This object will bother HprofReader, because it has a NULL
 264          * class, so just don't dump it. It could be
 265          * gDvm.unlinkedJavaLangClass or it could be an object just
 266          * allocated which hasn't been initialized yet.
 267          */
 268     } else {
 269         if (dvmIsClassObject(obj)) {
 270             const ClassObject *thisClass = (const ClassObject *)obj;
 271             /* obj is a ClassObject.
 272              */
 273             int sFieldCount = thisClass->sfieldCount;
 274             if (sFieldCount != 0) {
 275                 int byteLength = sFieldCount*sizeof(StaticField);
 276                 /* Create a byte array to reflect the allocation of the
 277                  * StaticField array at the end of this class.
 278                  */
 279                 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_DUMP);
 280                 hprofAddIdToRecord(rec, CLASS_STATICS_ID(obj));
 281                 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj));
 282                 hprofAddU4ToRecord(rec, byteLength);
 283                 hprofAddU1ToRecord(rec, hprof_basic_byte);
 284                 for (int i = 0; i < byteLength; i++) {
 285                     hprofAddU1ToRecord(rec, 0);
 286                 }
 287             }
 288
 289             hprofAddU1ToRecord(rec, HPROF_CLASS_DUMP);
 290             hprofAddIdToRecord(rec, hprofLookupClassId(thisClass));
 291             hprofAddU4ToRecord(rec, stackTraceSerialNumber(thisClass));
 292             hprofAddIdToRecord(rec, hprofLookupClassId(thisClass->super));
 293             hprofAddIdToRecord(rec, (hprof_object_id)thisClass->classLoader);
 294             hprofAddIdToRecord(rec, (hprof_object_id)0);    // no signer
 295             hprofAddIdToRecord(rec, (hprof_object_id)0);    // no prot domain
 296             hprofAddIdToRecord(rec, (hprof_id)0);           // reserved
 297             hprofAddIdToRecord(rec, (hprof_id)0);           // reserved
 298             if (obj == (Object *)gDvm.classJavaLangClass) {
 299                 // ClassObjects have their static fields appended, so
 300                 // aren't all the same size. But they're at least this
 301                 // size.
 302                 hprofAddU4ToRecord(rec, sizeof(ClassObject)); // instance size
 303             } else {
 304                 hprofAddU4ToRecord(rec, thisClass->objectSize); // instance size
 305             }
 306
 307             hprofAddU2ToRecord(rec, 0);                     // empty const pool
 308
 309             /* Static fields
 310              */
 311             if (sFieldCount == 0) {
 312                 hprofAddU2ToRecord(rec, (u2)0);
 313             } else {
 314                 hprofAddU2ToRecord(rec, (u2)(sFieldCount+1));
 315                 hprofAddIdToRecord(rec,
 316                                    hprofLookupStringId(STATIC_OVERHEAD_NAME));
 317                 hprofAddU1ToRecord(rec, hprof_basic_object);
 318                 hprofAddIdToRecord(rec, CLASS_STATICS_ID(obj));
 319                 for (int i = 0; i < sFieldCount; i++) {
 320                     hprof_basic_type t;
 321                     size_t size;
 322                     const StaticField *f = &thisClass->sfields[i];
 323
 324                     t = signatureToBasicTypeAndSize(f->signature, &size);
 325                     hprofAddIdToRecord(rec, hprofLookupStringId(f->name));
 326                     hprofAddU1ToRecord(rec, t);
 327                     if (size == 1) {
 328                         hprofAddU1ToRecord(rec, (u1)f->value.b);
 329                     } else if (size == 2) {
 330                         hprofAddU2ToRecord(rec, (u2)f->value.c);
 331                     } else if (size == 4) {
 332                         hprofAddU4ToRecord(rec, (u4)f->value.i);
 333                     } else if (size == 8) {
 334                         hprofAddU8ToRecord(rec, (u8)f->value.j);
 335                     } else {
 336                         assert(false);
 337                     }
 338                 }
 339             }
 340
 341             /* Instance fields for this class (no superclass fields)
 342              */
 343             int iFieldCount = thisClass->ifieldCount;
 344             hprofAddU2ToRecord(rec, (u2)iFieldCount);
 345             for (int i = 0; i < iFieldCount; i++) {
 346                 const InstField *f = &thisClass->ifields[i];
 347                 hprof_basic_type t;
 348
 349                 t = signatureToBasicTypeAndSize(f->signature, NULL);
 350                 hprofAddIdToRecord(rec, hprofLookupStringId(f->name));
 351                 hprofAddU1ToRecord(rec, t);
 352             }
 353         } else if (IS_CLASS_FLAG_SET(clazz, CLASS_ISARRAY)) {
 354             const ArrayObject *aobj = (const ArrayObject *)obj;
 355             u4 length = aobj->length;
 356
 357             if (IS_CLASS_FLAG_SET(clazz, CLASS_ISOBJECTARRAY)) {
 358                 /* obj is an object array.
 359                  */
 360                 hprofAddU1ToRecord(rec, HPROF_OBJECT_ARRAY_DUMP);
 361
 362                 hprofAddIdToRecord(rec, (hprof_object_id)obj);
 363                 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj));
 364                 hprofAddU4ToRecord(rec, length);
 365                 hprofAddIdToRecord(rec, hprofLookupClassId(clazz));
 366
 367                 /* Dump the elements, which are always objects or NULL.
 368                  */
 369                 hprofAddIdListToRecord(rec,
 370                         (const hprof_object_id *)(void *)aobj->contents, length);
 371             } else {
 372                 hprof_basic_type t;
 373                 size_t size;
 374
 375                 t = primitiveToBasicTypeAndSize(clazz->elementClass->
 376                                                 primitiveType, &size);
 377
 378                 /* obj is a primitive array.
 379                  */
 380 #if DUMP_PRIM_DATA
 381                 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_DUMP);
 382 #else
 383                 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_NODATA_DUMP);
 384 #endif
 385
 386                 hprofAddIdToRecord(rec, (hprof_object_id)obj);
 387                 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj));
 388                 hprofAddU4ToRecord(rec, length);
 389                 hprofAddU1ToRecord(rec, t);
 390
 391 #if DUMP_PRIM_DATA
 392                 /* Dump the raw, packed element values.
 393                  */
 394                 if (size == 1) {
 395                     hprofAddU1ListToRecord(rec, (const u1 *)aobj->contents,
 396                             length);
 397                 } else if (size == 2) {
 398                     hprofAddU2ListToRecord(rec, (const u2 *)(void *)aobj->contents,
 399                             length);
 400                 } else if (size == 4) {
 401                     hprofAddU4ListToRecord(rec, (const u4 *)(void *)aobj->contents,
 402                             length);
 403                 } else if (size == 8) {
 404                     hprofAddU8ListToRecord(rec, (const u8 *)aobj->contents,
 405                             length);
 406                 }
 407 #endif
 408             }
 409         } else {
 410             const ClassObject *sclass;
 411             size_t sizePatchOffset, savedLen;
 412
 413             /* obj is an instance object.
 414              */
 415             hprofAddU1ToRecord(rec, HPROF_INSTANCE_DUMP);
 416             hprofAddIdToRecord(rec, (hprof_object_id)obj);
 417             hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj));
 418             hprofAddIdToRecord(rec, hprofLookupClassId(clazz));
 419
 420             /* Reserve some space for the length of the instance
 421              * data, which we won't know until we're done writing
 422              * it.
 423              */
 424             sizePatchOffset = rec->length;
 425             hprofAddU4ToRecord(rec, 0x77777777);
 426
 427             /* Write the instance data;  fields for this
 428              * class, followed by super class fields, and so on.
 429              */
 430             sclass = clazz;
 431             while (sclass != NULL) {
 432                 int ifieldCount = sclass->ifieldCount;
 433                 for (int i = 0; i < ifieldCount; i++) {
 434                     const InstField *f = &sclass->ifields[i];
 435                     size_t size;
 436
 437                     (void) signatureToBasicTypeAndSize(f->signature, &size);
 438                     if (size == 1) {
 439                         hprofAddU1ToRecord(rec,
 440                                 (u1)dvmGetFieldByte(obj, f->byteOffset));
 441                     } else if (size == 2) {
 442                         hprofAddU2ToRecord(rec,
 443                                 (u2)dvmGetFieldChar(obj, f->byteOffset));
 444                     } else if (size == 4) {
 445                         hprofAddU4ToRecord(rec,
 446                                 (u4)dvmGetFieldInt(obj, f->byteOffset));
 447                     } else if (size == 8) {
 448                         hprofAddU8ToRecord(rec,
 449                                 (u8)dvmGetFieldLong(obj, f->byteOffset));
 450                     } else {
 451                         assert(false);
 452                     }
 453                 }
 454
 455                 sclass = sclass->super;
 456             }
 457
 458             /* Patch the instance field length.
 459              */
 460             savedLen = rec->length;
 461             rec->length = sizePatchOffset;
 462             hprofAddU4ToRecord(rec, savedLen - (sizePatchOffset + 4));
 463             rec->length = savedLen;
 464         }
 465     }
 466
 467     ctx->objectsInSegment++;
 468
 469     return 0;
 470 }