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