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 }