1 /* 2 * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 #include "precompiled.hpp" 25 26 #include "memory/allocation.hpp" 27 #include "services/mallocTracker.hpp" 28 #include "services/memReporter.hpp" 29 #include "services/virtualMemoryTracker.hpp" 30 #include "utilities/globalDefinitions.hpp" 31 32 size_t MemReporterBase::reserved_total(const MallocMemory* malloc, const VirtualMemory* vm) const { 33 return malloc->malloc_size() + malloc->arena_size() + vm->reserved(); 34 } 35 36 size_t MemReporterBase::committed_total(const MallocMemory* malloc, const VirtualMemory* vm) const { 37 return malloc->malloc_size() + malloc->arena_size() + vm->committed(); 38 } 39 40 void MemReporterBase::print_total(size_t reserved, size_t committed) const { 41 const char* scale = current_scale(); 42 output()->print("reserved=" SIZE_FORMAT "%s, committed=" SIZE_FORMAT "%s", 43 amount_in_current_scale(reserved), scale, amount_in_current_scale(committed), scale); 44 } 45 46 void MemReporterBase::print_malloc(size_t amount, size_t count, MEMFLAGS flag) const { 47 const char* scale = current_scale(); 48 outputStream* out = output(); 49 if (flag != mtNone) { 50 out->print("(malloc=" SIZE_FORMAT "%s type=%s", 51 amount_in_current_scale(amount), scale, NMTUtil::flag_to_name(flag)); 52 } else { 53 out->print("(malloc=" SIZE_FORMAT "%s", 54 amount_in_current_scale(amount), scale); 55 } 56 57 if (count > 0) { 58 out->print(" #" SIZE_FORMAT "", count); 59 } 60 61 out->print(")"); 62 } 63 64 void MemReporterBase::print_virtual_memory(size_t reserved, size_t committed) const { 65 const char* scale = current_scale(); 66 output()->print("(mmap: reserved=" SIZE_FORMAT "%s, committed=" SIZE_FORMAT "%s)", 67 amount_in_current_scale(reserved), scale, amount_in_current_scale(committed), scale); 68 } 69 70 void MemReporterBase::print_malloc_line(size_t amount, size_t count) const { 71 output()->print("%28s", " "); 72 print_malloc(amount, count); 73 output()->print_cr(" "); 74 } 75 76 void MemReporterBase::print_virtual_memory_line(size_t reserved, size_t committed) const { 77 output()->print("%28s", " "); 78 print_virtual_memory(reserved, committed); 79 output()->print_cr(" "); 80 } 81 82 void MemReporterBase::print_arena_line(size_t amount, size_t count) const { 83 const char* scale = current_scale(); 84 output()->print_cr("%27s (arena=" SIZE_FORMAT "%s #" SIZE_FORMAT ")", " ", 85 amount_in_current_scale(amount), scale, count); 86 } 87 88 void MemReporterBase::print_virtual_memory_region(const char* type, address base, size_t size) const { 89 const char* scale = current_scale(); 90 output()->print("[" PTR_FORMAT " - " PTR_FORMAT "] %s " SIZE_FORMAT "%s", 91 p2i(base), p2i(base + size), type, amount_in_current_scale(size), scale); 92 } 93 94 95 void MemSummaryReporter::report() { 96 const char* scale = current_scale(); 97 outputStream* out = output(); 98 size_t total_reserved_amount = _malloc_snapshot->total() + 99 _vm_snapshot->total_reserved(); 100 size_t total_committed_amount = _malloc_snapshot->total() + 101 _vm_snapshot->total_committed(); 102 103 // Overall total 104 out->print_cr("\nNative Memory Tracking:\n"); 105 out->print("Total: "); 106 print_total(total_reserved_amount, total_committed_amount); 107 out->print("\n"); 108 109 // Summary by memory type 110 for (int index = 0; index < mt_number_of_types; index ++) { 111 MEMFLAGS flag = NMTUtil::index_to_flag(index); 112 // thread stack is reported as part of thread category 113 if (flag == mtThreadStack) continue; 114 MallocMemory* malloc_memory = _malloc_snapshot->by_type(flag); 115 VirtualMemory* virtual_memory = _vm_snapshot->by_type(flag); 116 117 report_summary_of_type(flag, malloc_memory, virtual_memory); 118 } 119 } 120 121 void MemSummaryReporter::report_summary_of_type(MEMFLAGS flag, 122 MallocMemory* malloc_memory, VirtualMemory* virtual_memory) { 123 124 size_t reserved_amount = reserved_total (malloc_memory, virtual_memory); 125 size_t committed_amount = committed_total(malloc_memory, virtual_memory); 126 127 // Count thread's native stack in "Thread" category 128 if (flag == mtThread) { 129 const VirtualMemory* thread_stack_usage = 130 (const VirtualMemory*)_vm_snapshot->by_type(mtThreadStack); 131 reserved_amount += thread_stack_usage->reserved(); 132 committed_amount += thread_stack_usage->committed(); 133 } else if (flag == mtNMT) { 134 // Count malloc headers in "NMT" category 135 reserved_amount += _malloc_snapshot->malloc_overhead()->size(); 136 committed_amount += _malloc_snapshot->malloc_overhead()->size(); 137 } 138 139 if (amount_in_current_scale(reserved_amount) > 0) { 140 outputStream* out = output(); 141 const char* scale = current_scale(); 142 out->print("-%26s (", NMTUtil::flag_to_name(flag)); 143 print_total(reserved_amount, committed_amount); 144 out->print_cr(")"); 145 146 if (flag == mtClass) { 147 // report class count 148 out->print_cr("%27s (classes #" SIZE_FORMAT ")", 149 " ", (_instance_class_count + _array_class_count)); 150 out->print_cr("%27s ( instance classes #" SIZE_FORMAT ", array classes #" SIZE_FORMAT ")", 151 " ", _instance_class_count, _array_class_count); 152 } else if (flag == mtThread) { 153 // report thread count 154 out->print_cr("%27s (thread #" SIZE_FORMAT ")", " ", _malloc_snapshot->thread_count()); 155 const VirtualMemory* thread_stack_usage = 156 _vm_snapshot->by_type(mtThreadStack); 157 out->print("%27s (stack: ", " "); 158 print_total(thread_stack_usage->reserved(), thread_stack_usage->committed()); 159 out->print_cr(")"); 160 } 161 162 // report malloc'd memory 163 if (amount_in_current_scale(malloc_memory->malloc_size()) > 0) { 164 // We don't know how many arena chunks are in used, so don't report the count 165 size_t count = (flag == mtChunk) ? 0 : malloc_memory->malloc_count(); 166 print_malloc_line(malloc_memory->malloc_size(), count); 167 } 168 169 if (amount_in_current_scale(virtual_memory->reserved()) > 0) { 170 print_virtual_memory_line(virtual_memory->reserved(), virtual_memory->committed()); 171 } 172 173 if (amount_in_current_scale(malloc_memory->arena_size()) > 0) { 174 print_arena_line(malloc_memory->arena_size(), malloc_memory->arena_count()); 175 } 176 177 if (flag == mtNMT && 178 amount_in_current_scale(_malloc_snapshot->malloc_overhead()->size()) > 0) { 179 out->print_cr("%27s (tracking overhead=" SIZE_FORMAT "%s)", " ", 180 amount_in_current_scale(_malloc_snapshot->malloc_overhead()->size()), scale); 181 } else if (flag == mtClass) { 182 // Metadata information 183 report_metadata(Metaspace::NonClassType); 184 if (Metaspace::using_class_space()) { 185 report_metadata(Metaspace::ClassType); 186 } 187 } 188 out->print_cr(" "); 189 } 190 } 191 192 void MemSummaryReporter::report_metadata(Metaspace::MetadataType type) const { 193 assert(type == Metaspace::NonClassType || type == Metaspace::ClassType, 194 "Invalid metadata type"); 195 const char* name = (type == Metaspace::NonClassType) ? 196 "Metadata: " : "Class space:"; 197 198 outputStream* out = output(); 199 const char* scale = current_scale(); 200 size_t committed = MetaspaceUtils::committed_bytes(type); 201 size_t used = MetaspaceUtils::used_bytes(type); 202 size_t free = (MetaspaceUtils::capacity_bytes(type) - used) 203 + MetaspaceUtils::free_chunks_total_bytes(type) 204 + MetaspaceUtils::free_bytes(type); 205 206 assert(committed >= used + free, "Sanity"); 207 size_t waste = committed - (used + free); 208 209 out->print_cr("%27s ( %s)", " ", name); 210 out->print("%27s ( ", " "); 211 print_total(MetaspaceUtils::reserved_bytes(type), committed); 212 out->print_cr(")"); 213 out->print_cr("%27s ( used=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(used), scale); 214 out->print_cr("%27s ( free=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(free), scale); 215 out->print_cr("%27s ( waste=" SIZE_FORMAT "%s =%2.2f%%)", " ", amount_in_current_scale(waste), 216 scale, ((float)waste * 100)/committed); 217 } 218 219 void MemDetailReporter::report_detail() { 220 // Start detail report 221 outputStream* out = output(); 222 out->print_cr("Details:\n"); 223 224 report_malloc_sites(); 225 report_virtual_memory_allocation_sites(); 226 } 227 228 void MemDetailReporter::report_malloc_sites() { 229 MallocSiteIterator malloc_itr = _baseline.malloc_sites(MemBaseline::by_size); 230 if (malloc_itr.is_empty()) return; 231 232 outputStream* out = output(); 233 234 const MallocSite* malloc_site; 235 while ((malloc_site = malloc_itr.next()) != NULL) { 236 // Don't report if size is too small 237 if (amount_in_current_scale(malloc_site->size()) == 0) 238 continue; 239 240 const NativeCallStack* stack = malloc_site->call_stack(); 241 stack->print_on(out); 242 out->print("%29s", " "); 243 MEMFLAGS flag = malloc_site->flags(); 244 assert((flag >= 0 && flag < (int)mt_number_of_types) && flag != mtNone, 245 "Must have a valid memory type"); 246 print_malloc(malloc_site->size(), malloc_site->count(),flag); 247 out->print_cr("\n"); 248 } 249 } 250 251 void MemDetailReporter::report_virtual_memory_allocation_sites() { 252 VirtualMemorySiteIterator virtual_memory_itr = 253 _baseline.virtual_memory_sites(MemBaseline::by_size); 254 255 if (virtual_memory_itr.is_empty()) return; 256 257 outputStream* out = output(); 258 const VirtualMemoryAllocationSite* virtual_memory_site; 259 260 while ((virtual_memory_site = virtual_memory_itr.next()) != NULL) { 261 // Don't report if size is too small 262 if (amount_in_current_scale(virtual_memory_site->reserved()) == 0) 263 continue; 264 265 const NativeCallStack* stack = virtual_memory_site->call_stack(); 266 stack->print_on(out); 267 out->print("%28s (", " "); 268 print_total(virtual_memory_site->reserved(), virtual_memory_site->committed()); 269 out->print_cr(")\n"); 270 } 271 } 272 273 274 void MemDetailReporter::report_virtual_memory_map() { 275 // Virtual memory map always in base address order 276 VirtualMemoryAllocationIterator itr = _baseline.virtual_memory_allocations(); 277 const ReservedMemoryRegion* rgn; 278 279 output()->print_cr("Virtual memory map:"); 280 while ((rgn = itr.next()) != NULL) { 281 report_virtual_memory_region(rgn); 282 } 283 } 284 285 void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion* reserved_rgn) { 286 assert(reserved_rgn != NULL, "NULL pointer"); 287 288 // Don't report if size is too small 289 if (amount_in_current_scale(reserved_rgn->size()) == 0) return; 290 291 outputStream* out = output(); 292 const char* scale = current_scale(); 293 const NativeCallStack* stack = reserved_rgn->call_stack(); 294 bool all_committed = reserved_rgn->size() == reserved_rgn->committed_size(); 295 const char* region_type = (all_committed ? "reserved and committed" : "reserved"); 296 out->print_cr(" "); 297 print_virtual_memory_region(region_type, reserved_rgn->base(), reserved_rgn->size()); 298 out->print(" for %s", NMTUtil::flag_to_name(reserved_rgn->flag())); 299 if (stack->is_empty()) { 300 out->print_cr(" "); 301 } else { 302 out->print_cr(" from"); 303 stack->print_on(out, 4); 304 } 305 306 if (all_committed) { 307 CommittedRegionIterator itr = reserved_rgn->iterate_committed_regions(); 308 const CommittedMemoryRegion* committed_rgn = itr.next(); 309 if (committed_rgn->size() == reserved_rgn->size() && committed_rgn->call_stack()->equals(*stack)) { 310 // One region spanning the entire reserved region, with the same stack trace. 311 // Don't print this regions because the "reserved and committed" line above 312 // already indicates that the region is comitted. 313 assert(itr.next() == NULL, "Unexpectedly more than one regions"); 314 return; 315 } 316 } 317 318 CommittedRegionIterator itr = reserved_rgn->iterate_committed_regions(); 319 const CommittedMemoryRegion* committed_rgn; 320 while ((committed_rgn = itr.next()) != NULL) { 321 // Don't report if size is too small 322 if (amount_in_current_scale(committed_rgn->size()) == 0) continue; 323 stack = committed_rgn->call_stack(); 324 out->print("\n\t"); 325 print_virtual_memory_region("committed", committed_rgn->base(), committed_rgn->size()); 326 if (stack->is_empty()) { 327 out->print_cr(" "); 328 } else { 329 out->print_cr(" from"); 330 stack->print_on(out, 12); 331 } 332 } 333 } 334 335 void MemSummaryDiffReporter::report_diff() { 336 const char* scale = current_scale(); 337 outputStream* out = output(); 338 out->print_cr("\nNative Memory Tracking:\n"); 339 340 // Overall diff 341 out->print("Total: "); 342 print_virtual_memory_diff(_current_baseline.total_reserved_memory(), 343 _current_baseline.total_committed_memory(), _early_baseline.total_reserved_memory(), 344 _early_baseline.total_committed_memory()); 345 346 out->print_cr("\n"); 347 348 // Summary diff by memory type 349 for (int index = 0; index < mt_number_of_types; index ++) { 350 MEMFLAGS flag = NMTUtil::index_to_flag(index); 351 // thread stack is reported as part of thread category 352 if (flag == mtThreadStack) continue; 353 diff_summary_of_type(flag, 354 _early_baseline.malloc_memory(flag), 355 _early_baseline.virtual_memory(flag), 356 _early_baseline.metaspace_snapshot(), 357 _current_baseline.malloc_memory(flag), 358 _current_baseline.virtual_memory(flag), 359 _current_baseline.metaspace_snapshot()); 360 } 361 } 362 363 void MemSummaryDiffReporter::print_malloc_diff(size_t current_amount, size_t current_count, 364 size_t early_amount, size_t early_count, MEMFLAGS flags) const { 365 const char* scale = current_scale(); 366 outputStream* out = output(); 367 368 out->print("malloc=" SIZE_FORMAT "%s", amount_in_current_scale(current_amount), scale); 369 // Report type only if it is valid 370 if (flags != mtNone) { 371 out->print(" type=%s", NMTUtil::flag_to_name(flags)); 372 } 373 374 long amount_diff = diff_in_current_scale(current_amount, early_amount); 375 if (amount_diff != 0) { 376 out->print(" %+ld%s", amount_diff, scale); 377 } 378 if (current_count > 0) { 379 out->print(" #" SIZE_FORMAT "", current_count); 380 if (current_count != early_count) { 381 out->print(" %+d", (int)(current_count - early_count)); 382 } 383 } 384 } 385 386 void MemSummaryDiffReporter::print_arena_diff(size_t current_amount, size_t current_count, 387 size_t early_amount, size_t early_count) const { 388 const char* scale = current_scale(); 389 outputStream* out = output(); 390 out->print("arena=" SIZE_FORMAT "%s", amount_in_current_scale(current_amount), scale); 391 if (diff_in_current_scale(current_amount, early_amount) != 0) { 392 out->print(" %+ld", diff_in_current_scale(current_amount, early_amount)); 393 } 394 395 out->print(" #" SIZE_FORMAT "", current_count); 396 if (current_count != early_count) { 397 out->print(" %+d", (int)(current_count - early_count)); 398 } 399 } 400 401 void MemSummaryDiffReporter::print_virtual_memory_diff(size_t current_reserved, size_t current_committed, 402 size_t early_reserved, size_t early_committed) const { 403 const char* scale = current_scale(); 404 outputStream* out = output(); 405 out->print("reserved=" SIZE_FORMAT "%s", amount_in_current_scale(current_reserved), scale); 406 long reserved_diff = diff_in_current_scale(current_reserved, early_reserved); 407 if (reserved_diff != 0) { 408 out->print(" %+ld%s", reserved_diff, scale); 409 } 410 411 out->print(", committed=" SIZE_FORMAT "%s", amount_in_current_scale(current_committed), scale); 412 long committed_diff = diff_in_current_scale(current_committed, early_committed); 413 if (committed_diff != 0) { 414 out->print(" %+ld%s", committed_diff, scale); 415 } 416 } 417 418 419 void MemSummaryDiffReporter::diff_summary_of_type(MEMFLAGS flag, 420 const MallocMemory* early_malloc, const VirtualMemory* early_vm, 421 const MetaspaceSnapshot* early_ms, 422 const MallocMemory* current_malloc, const VirtualMemory* current_vm, 423 const MetaspaceSnapshot* current_ms) const { 424 425 outputStream* out = output(); 426 const char* scale = current_scale(); 427 428 // Total reserved and committed memory in current baseline 429 size_t current_reserved_amount = reserved_total (current_malloc, current_vm); 430 size_t current_committed_amount = committed_total(current_malloc, current_vm); 431 432 // Total reserved and committed memory in early baseline 433 size_t early_reserved_amount = reserved_total(early_malloc, early_vm); 434 size_t early_committed_amount = committed_total(early_malloc, early_vm); 435 436 // Adjust virtual memory total 437 if (flag == mtThread) { 438 const VirtualMemory* early_thread_stack_usage = 439 _early_baseline.virtual_memory(mtThreadStack); 440 const VirtualMemory* current_thread_stack_usage = 441 _current_baseline.virtual_memory(mtThreadStack); 442 443 early_reserved_amount += early_thread_stack_usage->reserved(); 444 early_committed_amount += early_thread_stack_usage->committed(); 445 446 current_reserved_amount += current_thread_stack_usage->reserved(); 447 current_committed_amount += current_thread_stack_usage->committed(); 448 } else if (flag == mtNMT) { 449 early_reserved_amount += _early_baseline.malloc_tracking_overhead(); 450 early_committed_amount += _early_baseline.malloc_tracking_overhead(); 451 452 current_reserved_amount += _current_baseline.malloc_tracking_overhead(); 453 current_committed_amount += _current_baseline.malloc_tracking_overhead(); 454 } 455 456 if (amount_in_current_scale(current_reserved_amount) > 0 || 457 diff_in_current_scale(current_reserved_amount, early_reserved_amount) != 0) { 458 459 // print summary line 460 out->print("-%26s (", NMTUtil::flag_to_name(flag)); 461 print_virtual_memory_diff(current_reserved_amount, current_committed_amount, 462 early_reserved_amount, early_committed_amount); 463 out->print_cr(")"); 464 465 // detail lines 466 if (flag == mtClass) { 467 // report class count 468 out->print("%27s (classes #" SIZE_FORMAT "", " ", _current_baseline.class_count()); 469 int class_count_diff = (int)(_current_baseline.class_count() - 470 _early_baseline.class_count()); 471 if (_current_baseline.class_count() != _early_baseline.class_count()) { 472 out->print(" %+d", (int)(_current_baseline.class_count() - _early_baseline.class_count())); 473 } 474 out->print_cr(")"); 475 476 out->print("%27s ( instance classes #" SIZE_FORMAT, " ", _current_baseline.instance_class_count()); 477 if (_current_baseline.instance_class_count() != _early_baseline.instance_class_count()) { 478 out->print(" %+d", (int)(_current_baseline.instance_class_count() - _early_baseline.instance_class_count())); 479 } 480 out->print(", array classes #" SIZE_FORMAT, _current_baseline.array_class_count()); 481 if (_current_baseline.array_class_count() != _early_baseline.array_class_count()) { 482 out->print(" %+d", (int)(_current_baseline.array_class_count() - _early_baseline.array_class_count())); 483 } 484 out->print_cr(")"); 485 486 } else if (flag == mtThread) { 487 // report thread count 488 out->print("%27s (thread #" SIZE_FORMAT "", " ", _current_baseline.thread_count()); 489 int thread_count_diff = (int)(_current_baseline.thread_count() - 490 _early_baseline.thread_count()); 491 if (thread_count_diff != 0) { 492 out->print(" %+d", thread_count_diff); 493 } 494 out->print_cr(")"); 495 496 // report thread stack 497 const VirtualMemory* current_thread_stack = 498 _current_baseline.virtual_memory(mtThreadStack); 499 const VirtualMemory* early_thread_stack = 500 _early_baseline.virtual_memory(mtThreadStack); 501 502 out->print("%27s (stack: ", " "); 503 print_virtual_memory_diff(current_thread_stack->reserved(), current_thread_stack->committed(), 504 early_thread_stack->reserved(), early_thread_stack->committed()); 505 out->print_cr(")"); 506 } 507 508 // Report malloc'd memory 509 size_t current_malloc_amount = current_malloc->malloc_size(); 510 size_t early_malloc_amount = early_malloc->malloc_size(); 511 if (amount_in_current_scale(current_malloc_amount) > 0 || 512 diff_in_current_scale(current_malloc_amount, early_malloc_amount) != 0) { 513 out->print("%28s(", " "); 514 print_malloc_diff(current_malloc_amount, (flag == mtChunk) ? 0 : current_malloc->malloc_count(), 515 early_malloc_amount, early_malloc->malloc_count(), mtNone); 516 out->print_cr(")"); 517 } 518 519 // Report virtual memory 520 if (amount_in_current_scale(current_vm->reserved()) > 0 || 521 diff_in_current_scale(current_vm->reserved(), early_vm->reserved()) != 0) { 522 out->print("%27s (mmap: ", " "); 523 print_virtual_memory_diff(current_vm->reserved(), current_vm->committed(), 524 early_vm->reserved(), early_vm->committed()); 525 out->print_cr(")"); 526 } 527 528 // Report arena memory 529 if (amount_in_current_scale(current_malloc->arena_size()) > 0 || 530 diff_in_current_scale(current_malloc->arena_size(), early_malloc->arena_size()) != 0) { 531 out->print("%28s(", " "); 532 print_arena_diff(current_malloc->arena_size(), current_malloc->arena_count(), 533 early_malloc->arena_size(), early_malloc->arena_count()); 534 out->print_cr(")"); 535 } 536 537 // Report native memory tracking overhead 538 if (flag == mtNMT) { 539 size_t current_tracking_overhead = amount_in_current_scale(_current_baseline.malloc_tracking_overhead()); 540 size_t early_tracking_overhead = amount_in_current_scale(_early_baseline.malloc_tracking_overhead()); 541 542 out->print("%27s (tracking overhead=" SIZE_FORMAT "%s", " ", 543 amount_in_current_scale(_current_baseline.malloc_tracking_overhead()), scale); 544 545 long overhead_diff = diff_in_current_scale(_current_baseline.malloc_tracking_overhead(), 546 _early_baseline.malloc_tracking_overhead()); 547 if (overhead_diff != 0) { 548 out->print(" %+ld%s", overhead_diff, scale); 549 } 550 out->print_cr(")"); 551 } else if (flag == mtClass) { 552 assert(current_ms != NULL && early_ms != NULL, "Sanity"); 553 print_metaspace_diff(current_ms, early_ms); 554 } 555 out->print_cr(" "); 556 } 557 } 558 559 void MemSummaryDiffReporter::print_metaspace_diff(const MetaspaceSnapshot* current_ms, 560 const MetaspaceSnapshot* early_ms) const { 561 print_metaspace_diff(Metaspace::NonClassType, current_ms, early_ms); 562 if (Metaspace::using_class_space()) { 563 print_metaspace_diff(Metaspace::ClassType, current_ms, early_ms); 564 } 565 } 566 567 void MemSummaryDiffReporter::print_metaspace_diff(Metaspace::MetadataType type, 568 const MetaspaceSnapshot* current_ms, 569 const MetaspaceSnapshot* early_ms) const { 570 const char* name = (type == Metaspace::NonClassType) ? 571 "Metadata: " : "Class space:"; 572 573 outputStream* out = output(); 574 const char* scale = current_scale(); 575 576 out->print_cr("%27s ( %s)", " ", name); 577 out->print("%27s ( ", " "); 578 print_virtual_memory_diff(current_ms->reserved_in_bytes(type), 579 current_ms->committed_in_bytes(type), 580 early_ms->reserved_in_bytes(type), 581 early_ms->committed_in_bytes(type)); 582 out->print_cr(")"); 583 584 long diff_used = diff_in_current_scale(current_ms->used_in_bytes(type), 585 early_ms->used_in_bytes(type)); 586 long diff_free = diff_in_current_scale(current_ms->free_in_bytes(type), 587 early_ms->free_in_bytes(type)); 588 589 size_t current_waste = current_ms->committed_in_bytes(type) 590 - (current_ms->used_in_bytes(type) + current_ms->free_in_bytes(type)); 591 size_t early_waste = early_ms->committed_in_bytes(type) 592 - (early_ms->used_in_bytes(type) + early_ms->free_in_bytes(type)); 593 long diff_waste = diff_in_current_scale(current_waste, early_waste); 594 595 // Diff used 596 out->print("%27s ( used=" SIZE_FORMAT "%s", " ", 597 amount_in_current_scale(current_ms->used_in_bytes(type)), scale); 598 if (diff_used != 0) { 599 out->print(" %+ld%s", diff_used, scale); 600 } 601 out->print_cr(")"); 602 603 // Diff free 604 out->print("%27s ( free=" SIZE_FORMAT "%s", " ", 605 amount_in_current_scale(current_ms->free_in_bytes(type)), scale); 606 if (diff_free != 0) { 607 out->print(" %+ld%s", diff_free, scale); 608 } 609 out->print_cr(")"); 610 611 612 // Diff waste 613 out->print("%27s ( waste=" SIZE_FORMAT "%s =%2.2f%%", " ", 614 amount_in_current_scale(current_waste), scale, 615 ((float)current_waste * 100) / current_ms->committed_in_bytes(type)); 616 if (diff_waste != 0) { 617 out->print(" %+ld%s", diff_waste, scale); 618 } 619 out->print_cr(")"); 620 } 621 622 void MemDetailDiffReporter::report_diff() { 623 MemSummaryDiffReporter::report_diff(); 624 diff_malloc_sites(); 625 diff_virtual_memory_sites(); 626 } 627 628 void MemDetailDiffReporter::diff_malloc_sites() const { 629 MallocSiteIterator early_itr = _early_baseline.malloc_sites(MemBaseline::by_site_and_type); 630 MallocSiteIterator current_itr = _current_baseline.malloc_sites(MemBaseline::by_site_and_type); 631 632 const MallocSite* early_site = early_itr.next(); 633 const MallocSite* current_site = current_itr.next(); 634 635 while (early_site != NULL || current_site != NULL) { 636 if (early_site == NULL) { 637 new_malloc_site(current_site); 638 current_site = current_itr.next(); 639 } else if (current_site == NULL) { 640 old_malloc_site(early_site); 641 early_site = early_itr.next(); 642 } else { 643 int compVal = current_site->call_stack()->compare(*early_site->call_stack()); 644 if (compVal < 0) { 645 new_malloc_site(current_site); 646 current_site = current_itr.next(); 647 } else if (compVal > 0) { 648 old_malloc_site(early_site); 649 early_site = early_itr.next(); 650 } else { 651 diff_malloc_site(early_site, current_site); 652 early_site = early_itr.next(); 653 current_site = current_itr.next(); 654 } 655 } 656 } 657 } 658 659 void MemDetailDiffReporter::diff_virtual_memory_sites() const { 660 VirtualMemorySiteIterator early_itr = _early_baseline.virtual_memory_sites(MemBaseline::by_site); 661 VirtualMemorySiteIterator current_itr = _current_baseline.virtual_memory_sites(MemBaseline::by_site); 662 663 const VirtualMemoryAllocationSite* early_site = early_itr.next(); 664 const VirtualMemoryAllocationSite* current_site = current_itr.next(); 665 666 while (early_site != NULL || current_site != NULL) { 667 if (early_site == NULL) { 668 new_virtual_memory_site(current_site); 669 current_site = current_itr.next(); 670 } else if (current_site == NULL) { 671 old_virtual_memory_site(early_site); 672 early_site = early_itr.next(); 673 } else { 674 int compVal = current_site->call_stack()->compare(*early_site->call_stack()); 675 if (compVal < 0) { 676 new_virtual_memory_site(current_site); 677 current_site = current_itr.next(); 678 } else if (compVal > 0) { 679 old_virtual_memory_site(early_site); 680 early_site = early_itr.next(); 681 } else { 682 diff_virtual_memory_site(early_site, current_site); 683 early_site = early_itr.next(); 684 current_site = current_itr.next(); 685 } 686 } 687 } 688 } 689 690 691 void MemDetailDiffReporter::new_malloc_site(const MallocSite* malloc_site) const { 692 diff_malloc_site(malloc_site->call_stack(), malloc_site->size(), malloc_site->count(), 693 0, 0, malloc_site->flags()); 694 } 695 696 void MemDetailDiffReporter::old_malloc_site(const MallocSite* malloc_site) const { 697 diff_malloc_site(malloc_site->call_stack(), 0, 0, malloc_site->size(), 698 malloc_site->count(), malloc_site->flags()); 699 } 700 701 void MemDetailDiffReporter::diff_malloc_site(const MallocSite* early, 702 const MallocSite* current) const { 703 assert(early->flags() == current->flags(), "Must be the same memory type"); 704 diff_malloc_site(current->call_stack(), current->size(), current->count(), 705 early->size(), early->count(), early->flags()); 706 } 707 708 void MemDetailDiffReporter::diff_malloc_site(const NativeCallStack* stack, size_t current_size, 709 size_t current_count, size_t early_size, size_t early_count, MEMFLAGS flags) const { 710 outputStream* out = output(); 711 712 assert(stack != NULL, "NULL stack"); 713 714 if (diff_in_current_scale(current_size, early_size) == 0) { 715 return; 716 } 717 718 stack->print_on(out); 719 out->print("%28s (", " "); 720 print_malloc_diff(current_size, current_count, 721 early_size, early_count, flags); 722 723 out->print_cr(")\n"); 724 } 725 726 727 void MemDetailDiffReporter::new_virtual_memory_site(const VirtualMemoryAllocationSite* site) const { 728 diff_virtual_memory_site(site->call_stack(), site->reserved(), site->committed(), 0, 0); 729 } 730 731 void MemDetailDiffReporter::old_virtual_memory_site(const VirtualMemoryAllocationSite* site) const { 732 diff_virtual_memory_site(site->call_stack(), 0, 0, site->reserved(), site->committed()); 733 } 734 735 void MemDetailDiffReporter::diff_virtual_memory_site(const VirtualMemoryAllocationSite* early, 736 const VirtualMemoryAllocationSite* current) const { 737 diff_virtual_memory_site(current->call_stack(), current->reserved(), current->committed(), 738 early->reserved(), early->committed()); 739 } 740 741 void MemDetailDiffReporter::diff_virtual_memory_site(const NativeCallStack* stack, size_t current_reserved, 742 size_t current_committed, size_t early_reserved, size_t early_committed) const { 743 outputStream* out = output(); 744 745 // no change 746 if (diff_in_current_scale(current_reserved, early_reserved) == 0 && 747 diff_in_current_scale(current_committed, early_committed) == 0) { 748 return; 749 } 750 751 stack->print_on(out); 752 out->print("%28s (mmap: ", " "); 753 print_virtual_memory_diff(current_reserved, current_committed, 754 early_reserved, early_committed); 755 756 out->print_cr(")\n"); 757 }