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 <fcntl.h> 18 #include <stdlib.h> 19 20 #include "Dalvik.h" 21 #include "HeapInternal.h" 22 #include "HeapSource.h" 23 #include "Float12.h" 24 25 int dvmGetHeapDebugInfo(HeapDebugInfoType info) 26 { 27 switch (info) { 28 case kVirtualHeapSize: 29 return (int)dvmHeapSourceGetValue(HS_FOOTPRINT, NULL, 0); 30 case kVirtualHeapAllocated: 31 return (int)dvmHeapSourceGetValue(HS_BYTES_ALLOCATED, NULL, 0); 32 default: 33 return -1; 34 } 35 } 36 37 /* Looks up the cmdline for the process and tries to find 38 * the most descriptive five characters, then inserts the 39 * short name into the provided event value. 40 */ 41 #define PROC_NAME_LEN 5 42 static void insertProcessName(long long *ep) 43 { 44 static bool foundRealName = false; 45 static char name[PROC_NAME_LEN] = { 'X', 'X', 'X', 'X', 'X' }; 46 long long event = *ep; 47 48 if (!foundRealName) { 49 int fd = open("/proc/self/cmdline", O_RDONLY); 50 if (fd > 0) { 51 char buf[128]; 52 ssize_t n = read(fd, buf, sizeof(buf) - 1); 53 close(fd); 54 if (n > 0) { 55 memset(name, 0, sizeof(name)); 56 if (n <= PROC_NAME_LEN) { 57 // The whole name fits. 58 memcpy(name, buf, n); 59 } else { 60 /* We need to truncate. The name will look something 61 * like "com.android.home". Favor the characters 62 * immediately following the last dot. 63 */ 64 buf[n] = '\0'; 65 char *dot = strrchr(buf, '.'); 66 if (dot == NULL) { 67 /* Or, look for a slash, in case it's something like 68 * "/system/bin/runtime". 69 */ 70 dot = strrchr(buf, '/'); 71 } 72 if (dot != NULL) { 73 dot++; // Skip the dot 74 size_t dotlen = strlen(dot); 75 if (dotlen < PROC_NAME_LEN) { 76 /* Use all available characters. We know that 77 * n > PROC_NAME_LEN from the check above. 78 */ 79 dot -= PROC_NAME_LEN - dotlen; 80 } 81 strncpy(name, dot, PROC_NAME_LEN); 82 } else { 83 // No dot; just use the leading characters. 84 memcpy(name, buf, PROC_NAME_LEN); 85 } 86 } 87 if (strcmp(buf, "zygote") != 0) { 88 /* If the process is no longer called "zygote", 89 * cache this name. 90 */ 91 foundRealName = true; 92 } 93 } 94 } 95 } 96 97 event &= ~(0xffffffffffLL << 24); 98 event |= (long long)name[0] << 56; 99 event |= (long long)name[1] << 48; 100 event |= (long long)name[2] << 40; 101 event |= (long long)name[3] << 32; 102 event |= (long long)name[4] << 24; 103 104 *ep = event; 105 } 106 107 // See device/data/etc/event-log-tags 108 #define EVENT_LOG_TAG_dvm_gc_info 20001 109 #define EVENT_LOG_TAG_dvm_gc_madvise_info 20002 110 111 void dvmLogGcStats(size_t numFreed, size_t sizeFreed, size_t gcTimeMs) 112 { 113 const GcHeap *gcHeap = gDvm.gcHeap; 114 size_t perHeapActualSize[HEAP_SOURCE_MAX_HEAP_COUNT], 115 perHeapAllowedSize[HEAP_SOURCE_MAX_HEAP_COUNT], 116 perHeapNumAllocated[HEAP_SOURCE_MAX_HEAP_COUNT], 117 perHeapSizeAllocated[HEAP_SOURCE_MAX_HEAP_COUNT]; 118 unsigned char eventBuf[1 + (1 + sizeof(long long)) * 4]; 119 size_t actualSize, allowedSize, numAllocated, sizeAllocated; 120 size_t i; 121 size_t softLimit = dvmHeapSourceGetIdealFootprint(); 122 size_t nHeaps = dvmHeapSourceGetNumHeaps(); 123 124 /* Enough to quiet down gcc for unitialized variable check */ 125 perHeapActualSize[0] = perHeapAllowedSize[0] = perHeapNumAllocated[0] = 126 perHeapSizeAllocated[0] = 0; 127 actualSize = dvmHeapSourceGetValue(HS_FOOTPRINT, perHeapActualSize, 128 HEAP_SOURCE_MAX_HEAP_COUNT); 129 allowedSize = dvmHeapSourceGetValue(HS_ALLOWED_FOOTPRINT, 130 perHeapAllowedSize, HEAP_SOURCE_MAX_HEAP_COUNT); 131 numAllocated = dvmHeapSourceGetValue(HS_OBJECTS_ALLOCATED, 132 perHeapNumAllocated, HEAP_SOURCE_MAX_HEAP_COUNT); 133 sizeAllocated = dvmHeapSourceGetValue(HS_BYTES_ALLOCATED, 134 perHeapSizeAllocated, HEAP_SOURCE_MAX_HEAP_COUNT); 135 136 /* 137 * Construct the the first 64-bit value to write to the log. 138 * Global information: 139 * 140 * [63 ] Must be zero 141 * [62-24] ASCII process identifier 142 * [23-12] GC time in ms 143 * [11- 0] Bytes freed 144 * 145 */ 146 long long event0; 147 event0 = 0LL << 63 | 148 (long long)intToFloat12(gcTimeMs) << 12 | 149 (long long)intToFloat12(sizeFreed); 150 insertProcessName(&event0); 151 152 /* 153 * Aggregated heap stats: 154 * 155 * [63-62] 10 156 * [61-60] Reserved; must be zero 157 * [59-48] Objects freed 158 * [47-36] Actual size (current footprint) 159 * [35-24] Allowed size (current hard max) 160 * [23-12] Objects allocated 161 * [11- 0] Bytes allocated 162 */ 163 long long event1; 164 event1 = 2LL << 62 | 165 (long long)intToFloat12(numFreed) << 48 | 166 (long long)intToFloat12(actualSize) << 36 | 167 (long long)intToFloat12(allowedSize) << 24 | 168 (long long)intToFloat12(numAllocated) << 12 | 169 (long long)intToFloat12(sizeAllocated); 170 171 /* 172 * Report the current state of the zygote heap(s). 173 * 174 * The active heap is always heap[0]. We can be in one of three states 175 * at present: 176 * 177 * (1) Still in the zygote. Zygote using heap[0]. 178 * (2) In the zygote, when the first child is started. We created a 179 * new heap just before the first fork() call, so the original 180 * "zygote heap" is now heap[1], and we have a small heap[0] for 181 * anything we do from here on. 182 * (3) In an app process. The app gets a new heap[0], and can also 183 * see the two zygote heaps [1] and [2] (probably unwise to 184 * assume any specific ordering). 185 * 186 * So if nHeaps == 1, we want the stats from heap[0]; else we want 187 * the sum of the values from heap[1] to heap[nHeaps-1]. 188 * 189 * 190 * Zygote heap stats (except for the soft limit, which belongs to the 191 * active heap): 192 * 193 * [63-62] 11 194 * [61-60] Reserved; must be zero 195 * [59-48] Soft Limit (for the active heap) 196 * [47-36] Actual size (current footprint) 197 * [35-24] Allowed size (current hard max) 198 * [23-12] Objects allocated 199 * [11- 0] Bytes allocated 200 */ 201 long long event2; 202 size_t zActualSize, zAllowedSize, zNumAllocated, zSizeAllocated; 203 int firstHeap = (nHeaps == 1) ? 0 : 1; 204 size_t hh; 205 206 zActualSize = zAllowedSize = zNumAllocated = zSizeAllocated = 0; 207 for (hh = firstHeap; hh < nHeaps; hh++) { 208 zActualSize += perHeapActualSize[hh]; 209 zAllowedSize += perHeapAllowedSize[hh]; 210 zNumAllocated += perHeapNumAllocated[hh]; 211 zSizeAllocated += perHeapSizeAllocated[hh]; 212 } 213 event2 = 3LL << 62 | 214 (long long)intToFloat12(softLimit) << 48 | 215 (long long)intToFloat12(zActualSize) << 36 | 216 (long long)intToFloat12(zAllowedSize) << 24 | 217 (long long)intToFloat12(zNumAllocated) << 12 | 218 (long long)intToFloat12(zSizeAllocated); 219 220 /* 221 * Report the current external allocation stats and the native heap 222 * summary. 223 * 224 * [63-48] Reserved; must be zero (TODO: put new data in these slots) 225 * [47-36] dlmalloc_footprint 226 * [35-24] mallinfo: total allocated space 227 * [23-12] External byte limit 228 * [11- 0] External bytes allocated 229 */ 230 long long event3; 231 size_t externalLimit, externalBytesAllocated; 232 size_t uordblks, footprint; 233 234 #if 0 235 /* 236 * This adds 2-5msec to the GC cost on a DVT, or about 2-3% of the cost 237 * of a GC, so it's not horribly expensive but it's not free either. 238 */ 239 extern size_t dlmalloc_footprint(void); 240 struct mallinfo mi; 241 //u8 start, end; 242 243 //start = dvmGetRelativeTimeNsec(); 244 mi = mallinfo(); 245 uordblks = mi.uordblks; 246 footprint = dlmalloc_footprint(); 247 //end = dvmGetRelativeTimeNsec(); 248 //LOGD("mallinfo+footprint took %dusec; used=%zd footprint=%zd\n", 249 // (int)((end - start) / 1000), mi.uordblks, footprint); 250 #else 251 uordblks = footprint = 0; 252 #endif 253 254 externalLimit = 255 dvmHeapSourceGetValue(HS_EXTERNAL_LIMIT, NULL, 0); 256 externalBytesAllocated = 257 dvmHeapSourceGetValue(HS_EXTERNAL_BYTES_ALLOCATED, NULL, 0); 258 event3 = 259 (long long)intToFloat12(footprint) << 36 | 260 (long long)intToFloat12(uordblks) << 24 | 261 (long long)intToFloat12(externalLimit) << 12 | 262 (long long)intToFloat12(externalBytesAllocated); 263 264 /* Build the event data. 265 * [ 0: 0] item count (4) 266 * [ 1: 1] EVENT_TYPE_LONG 267 * [ 2: 9] event0 268 * [10:10] EVENT_TYPE_LONG 269 * [11:18] event1 270 * [19:19] EVENT_TYPE_LONG 271 * [20:27] event2 272 * [28:28] EVENT_TYPE_LONG 273 * [29:36] event2 274 */ 275 unsigned char *c = eventBuf; 276 *c++ = 4; 277 *c++ = EVENT_TYPE_LONG; 278 memcpy(c, &event0, sizeof(event0)); 279 c += sizeof(event0); 280 *c++ = EVENT_TYPE_LONG; 281 memcpy(c, &event1, sizeof(event1)); 282 c += sizeof(event1); 283 *c++ = EVENT_TYPE_LONG; 284 memcpy(c, &event2, sizeof(event2)); 285 c += sizeof(event2); 286 *c++ = EVENT_TYPE_LONG; 287 memcpy(c, &event3, sizeof(event3)); 288 289 (void) android_btWriteLog(EVENT_LOG_TAG_dvm_gc_info, EVENT_TYPE_LIST, 290 eventBuf, sizeof(eventBuf)); 291 } 292 293 void dvmLogMadviseStats(size_t madvisedSizes[], size_t arrayLen) 294 { 295 unsigned char eventBuf[1 + (1 + sizeof(int)) * 2]; 296 size_t total, zyg; 297 size_t firstHeap, i; 298 size_t nHeaps = dvmHeapSourceGetNumHeaps(); 299 300 assert(arrayLen >= nHeaps); 301 302 firstHeap = nHeaps > 1 ? 1 : 0; 303 total = 0; 304 zyg = 0; 305 for (i = 0; i < nHeaps; i++) { 306 total += madvisedSizes[i]; 307 if (i >= firstHeap) { 308 zyg += madvisedSizes[i]; 309 } 310 } 311 312 /* Build the event data. 313 * [ 0: 0] item count (2) 314 * [ 1: 1] EVENT_TYPE_INT 315 * [ 2: 5] total madvise byte count 316 * [ 6: 6] EVENT_TYPE_INT 317 * [ 7:10] zygote heap madvise byte count 318 */ 319 unsigned char *c = eventBuf; 320 *c++ = 2; 321 *c++ = EVENT_TYPE_INT; 322 memcpy(c, &total, sizeof(total)); 323 c += sizeof(total); 324 *c++ = EVENT_TYPE_INT; 325 memcpy(c, &zyg, sizeof(zyg)); 326 c += sizeof(zyg); 327 328 (void) android_btWriteLog(EVENT_LOG_TAG_dvm_gc_madvise_info, 329 EVENT_TYPE_LIST, eventBuf, sizeof(eventBuf)); 330 } 331 332 #if 0 333 #include <errno.h> 334 #include <stdio.h> 335 336 typedef struct HeapDumpContext { 337 FILE *fp; 338 void *chunkStart; 339 size_t chunkLen; 340 bool chunkFree; 341 } HeapDumpContext; 342 343 static void 344 dump_context(const HeapDumpContext *ctx) 345 { 346 fprintf(ctx->fp, "0x%08x %12.12zd %s\n", (uintptr_t)ctx->chunkStart, 347 ctx->chunkLen, ctx->chunkFree ? "FREE" : "USED"); 348 } 349 350 static void 351 heap_chunk_callback(const void *chunkptr, size_t chunklen, 352 const void *userptr, size_t userlen, void *arg) 353 { 354 HeapDumpContext *ctx = (HeapDumpContext *)arg; 355 bool chunkFree = (userptr == NULL); 356 357 if (chunkFree != ctx->chunkFree || 358 ((char *)ctx->chunkStart + ctx->chunkLen) != chunkptr) 359 { 360 /* The new chunk is of a different type or isn't 361 * contiguous with the current chunk. Dump the 362 * old one and start a new one. 363 */ 364 if (ctx->chunkStart != NULL) { 365 /* It's not the first chunk. */ 366 dump_context(ctx); 367 } 368 ctx->chunkStart = (void *)chunkptr; 369 ctx->chunkLen = chunklen; 370 ctx->chunkFree = chunkFree; 371 } else { 372 /* Extend the current chunk. 373 */ 374 ctx->chunkLen += chunklen; 375 } 376 } 377 378 /* Dumps free and used ranges, as text, to the named file. 379 */ 380 void dvmDumpHeapToFile(const char *fileName) 381 { 382 HeapDumpContext ctx; 383 FILE *fp; 384 385 fp = fopen(fileName, "w+"); 386 if (fp == NULL) { 387 LOGE("Can't open %s for writing: %s\n", fileName, strerror(errno)); 388 return; 389 } 390 LOGW("Dumping heap to %s...\n", fileName); 391 392 fprintf(fp, "==== Dalvik heap dump ====\n"); 393 memset(&ctx, 0, sizeof(ctx)); 394 ctx.fp = fp; 395 dvmHeapSourceWalk(heap_chunk_callback, (void *)&ctx); 396 dump_context(&ctx); 397 fprintf(fp, "==== end heap dump ====\n"); 398 399 LOGW("Dumped heap to %s.\n", fileName); 400 401 fclose(fp); 402 } 403 #endif 404
