Mercurial > hg > truffle
annotate src/share/vm/services/memReporter.cpp @ 17937:78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
8043029: Change 8037816 breaks HS build with older GCC versions which don't support diagnostic pragmas
8043164: Format warning in traceStream.hpp
Summary: Backport of main fix + two corrections, enables clang compilation, turns on format attributes, corrects/mutes warnings
Reviewed-by: kvn, coleenp, iveresov, twisti
| author | drchase |
|---|---|
| date | Thu, 22 May 2014 15:52:41 -0400 |
| parents | 55fb97c4c58d |
| children | 52b4284cb496 833b0f92429a |
| rev | line source |
|---|---|
| 6197 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17467
diff
changeset
|
2 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| 6197 | 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 #include "classfile/systemDictionary.hpp" | |
| 26 #include "runtime/os.hpp" | |
| 27 #include "services/memReporter.hpp" | |
| 28 #include "services/memPtrArray.hpp" | |
| 29 #include "services/memTracker.hpp" | |
| 30 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17467
diff
changeset
|
31 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17467
diff
changeset
|
32 |
| 6197 | 33 const char* BaselineOutputer::memory_unit(size_t scale) { |
| 34 switch(scale) { | |
| 35 case K: return "KB"; | |
| 36 case M: return "MB"; | |
| 37 case G: return "GB"; | |
| 38 } | |
| 39 ShouldNotReachHere(); | |
| 40 return NULL; | |
| 41 } | |
| 42 | |
| 43 | |
| 44 void BaselineReporter::report_baseline(const MemBaseline& baseline, bool summary_only) { | |
| 45 assert(MemTracker::is_on(), "Native memory tracking is off"); | |
| 46 _outputer.start(scale()); | |
| 47 _outputer.total_usage( | |
| 48 amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_reserved_amount()), | |
| 49 amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_committed_amount())); | |
| 50 | |
| 51 _outputer.num_of_classes(baseline.number_of_classes()); | |
| 52 _outputer.num_of_threads(baseline.number_of_threads()); | |
| 53 | |
| 54 report_summaries(baseline); | |
| 55 if (!summary_only && MemTracker::track_callsite()) { | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
56 report_virtual_memory_map(baseline); |
| 6197 | 57 report_callsites(baseline); |
| 58 } | |
| 59 _outputer.done(); | |
| 60 } | |
| 61 | |
| 62 void BaselineReporter::report_summaries(const MemBaseline& baseline) { | |
| 63 _outputer.start_category_summary(); | |
| 64 MEMFLAGS type; | |
| 65 | |
| 66 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { | |
| 67 type = MemBaseline::MemType2NameMap[index]._flag; | |
| 68 _outputer.category_summary(type, | |
| 69 amount_in_current_scale(baseline.reserved_amount(type)), | |
| 70 amount_in_current_scale(baseline.committed_amount(type)), | |
| 71 amount_in_current_scale(baseline.malloc_amount(type)), | |
| 72 baseline.malloc_count(type), | |
| 73 amount_in_current_scale(baseline.arena_amount(type)), | |
| 74 baseline.arena_count(type)); | |
| 75 } | |
| 76 | |
| 77 _outputer.done_category_summary(); | |
| 78 } | |
| 79 | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
80 void BaselineReporter::report_virtual_memory_map(const MemBaseline& baseline) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
81 _outputer.start_virtual_memory_map(); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
82 MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
83 MemPointerArrayIteratorImpl itr = MemPointerArrayIteratorImpl(pBL->_vm_map); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
84 VMMemRegionEx* rgn = (VMMemRegionEx*)itr.current(); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
85 while (rgn != NULL) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
86 if (rgn->is_reserved_region()) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
87 _outputer.reserved_memory_region(FLAGS_TO_MEMORY_TYPE(rgn->flags()), |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
88 rgn->base(), rgn->base() + rgn->size(), amount_in_current_scale(rgn->size()), rgn->pc()); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
89 } else { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
90 _outputer.committed_memory_region(rgn->base(), rgn->base() + rgn->size(), |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
91 amount_in_current_scale(rgn->size()), rgn->pc()); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
92 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
93 rgn = (VMMemRegionEx*)itr.next(); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
94 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
95 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
96 _outputer.done_virtual_memory_map(); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
97 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
98 |
| 6197 | 99 void BaselineReporter::report_callsites(const MemBaseline& baseline) { |
| 100 _outputer.start_callsite(); | |
| 101 MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); | |
| 102 | |
| 103 pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_size); | |
| 104 pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_size); | |
| 105 | |
| 106 // walk malloc callsites | |
| 107 MemPointerArrayIteratorImpl malloc_itr(pBL->_malloc_cs); | |
| 108 MallocCallsitePointer* malloc_callsite = | |
| 109 (MallocCallsitePointer*)malloc_itr.current(); | |
| 110 while (malloc_callsite != NULL) { | |
| 111 _outputer.malloc_callsite(malloc_callsite->addr(), | |
| 112 amount_in_current_scale(malloc_callsite->amount()), malloc_callsite->count()); | |
| 113 malloc_callsite = (MallocCallsitePointer*)malloc_itr.next(); | |
| 114 } | |
| 115 | |
| 116 // walk virtual memory callsite | |
| 117 MemPointerArrayIteratorImpl vm_itr(pBL->_vm_cs); | |
| 118 VMCallsitePointer* vm_callsite = (VMCallsitePointer*)vm_itr.current(); | |
| 119 while (vm_callsite != NULL) { | |
| 120 _outputer.virtual_memory_callsite(vm_callsite->addr(), | |
| 121 amount_in_current_scale(vm_callsite->reserved_amount()), | |
| 122 amount_in_current_scale(vm_callsite->committed_amount())); | |
| 123 vm_callsite = (VMCallsitePointer*)vm_itr.next(); | |
| 124 } | |
| 125 pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_pc); | |
| 126 pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_pc); | |
| 127 _outputer.done_callsite(); | |
| 128 } | |
| 129 | |
| 130 void BaselineReporter::diff_baselines(const MemBaseline& cur, const MemBaseline& prev, | |
| 131 bool summary_only) { | |
| 132 assert(MemTracker::is_on(), "Native memory tracking is off"); | |
| 133 _outputer.start(scale()); | |
| 134 size_t total_reserved = cur.total_malloc_amount() + cur.total_reserved_amount(); | |
| 135 size_t total_committed = cur.total_malloc_amount() + cur.total_committed_amount(); | |
| 136 | |
| 137 _outputer.diff_total_usage( | |
| 138 amount_in_current_scale(total_reserved), amount_in_current_scale(total_committed), | |
| 139 diff_in_current_scale(total_reserved, (prev.total_malloc_amount() + prev.total_reserved_amount())), | |
| 140 diff_in_current_scale(total_committed, (prev.total_committed_amount() + prev.total_malloc_amount()))); | |
| 141 | |
| 142 _outputer.diff_num_of_classes(cur.number_of_classes(), | |
| 143 diff(cur.number_of_classes(), prev.number_of_classes())); | |
| 144 _outputer.diff_num_of_threads(cur.number_of_threads(), | |
| 145 diff(cur.number_of_threads(), prev.number_of_threads())); | |
| 146 | |
| 147 diff_summaries(cur, prev); | |
| 148 if (!summary_only && MemTracker::track_callsite()) { | |
| 149 diff_callsites(cur, prev); | |
| 150 } | |
| 151 _outputer.done(); | |
| 152 } | |
| 153 | |
| 154 void BaselineReporter::diff_summaries(const MemBaseline& cur, const MemBaseline& prev) { | |
| 155 _outputer.start_category_summary(); | |
| 156 MEMFLAGS type; | |
| 157 | |
| 158 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { | |
| 159 type = MemBaseline::MemType2NameMap[index]._flag; | |
| 160 _outputer.diff_category_summary(type, | |
| 161 amount_in_current_scale(cur.reserved_amount(type)), | |
| 162 amount_in_current_scale(cur.committed_amount(type)), | |
| 163 amount_in_current_scale(cur.malloc_amount(type)), | |
| 164 cur.malloc_count(type), | |
| 165 amount_in_current_scale(cur.arena_amount(type)), | |
| 166 cur.arena_count(type), | |
| 167 diff_in_current_scale(cur.reserved_amount(type), prev.reserved_amount(type)), | |
| 168 diff_in_current_scale(cur.committed_amount(type), prev.committed_amount(type)), | |
| 169 diff_in_current_scale(cur.malloc_amount(type), prev.malloc_amount(type)), | |
| 170 diff(cur.malloc_count(type), prev.malloc_count(type)), | |
| 171 diff_in_current_scale(cur.arena_amount(type), prev.arena_amount(type)), | |
| 172 diff(cur.arena_count(type), prev.arena_count(type))); | |
| 173 } | |
| 174 | |
| 175 _outputer.done_category_summary(); | |
| 176 } | |
| 177 | |
| 178 void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) { | |
| 179 _outputer.start_callsite(); | |
| 180 MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur); | |
| 181 MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev); | |
| 182 | |
| 183 // walk malloc callsites | |
| 184 MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs); | |
| 185 MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs); | |
| 186 | |
| 187 MallocCallsitePointer* cur_malloc_callsite = | |
| 188 (MallocCallsitePointer*)cur_malloc_itr.current(); | |
| 189 MallocCallsitePointer* prev_malloc_callsite = | |
| 190 (MallocCallsitePointer*)prev_malloc_itr.current(); | |
| 191 | |
| 192 while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) { | |
|
11052
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
193 if (prev_malloc_callsite == NULL) { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
194 assert(cur_malloc_callsite != NULL, "sanity check"); |
|
10984
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
195 // this is a new callsite |
| 6197 | 196 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
| 197 amount_in_current_scale(cur_malloc_callsite->amount()), | |
| 198 cur_malloc_callsite->count(), | |
| 199 diff_in_current_scale(cur_malloc_callsite->amount(), 0), | |
| 200 diff(cur_malloc_callsite->count(), 0)); | |
| 201 cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); | |
|
11052
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
202 } else if (cur_malloc_callsite == NULL) { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
203 assert(prev_malloc_callsite != NULL, "Sanity check"); |
|
10984
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
204 // this callsite is already gone |
|
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
205 _outputer.diff_malloc_callsite(prev_malloc_callsite->addr(), |
|
11052
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
206 0, 0, |
| 6197 | 207 diff_in_current_scale(0, prev_malloc_callsite->amount()), |
| 208 diff(0, prev_malloc_callsite->count())); | |
| 209 prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); | |
|
11052
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
210 } else { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
211 assert(cur_malloc_callsite != NULL, "Sanity check"); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
212 assert(prev_malloc_callsite != NULL, "Sanity check"); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
213 if (cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
214 // this is a new callsite |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
215 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
216 amount_in_current_scale(cur_malloc_callsite->amount()), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
217 cur_malloc_callsite->count(), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
218 diff_in_current_scale(cur_malloc_callsite->amount(), 0), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
219 diff(cur_malloc_callsite->count(), 0)); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
220 cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
221 } else if (cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
222 // this callsite is already gone |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
223 _outputer.diff_malloc_callsite(prev_malloc_callsite->addr(), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
224 0, 0, |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
225 diff_in_current_scale(0, prev_malloc_callsite->amount()), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
226 diff(0, prev_malloc_callsite->count())); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
227 prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
228 } else { |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
229 // the same callsite |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
230 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
231 amount_in_current_scale(cur_malloc_callsite->amount()), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
232 cur_malloc_callsite->count(), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
233 diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()), |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
234 diff(cur_malloc_callsite->count(), prev_malloc_callsite->count())); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
235 cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
236 prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); |
|
8cff1de240de
8017478: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
10984
diff
changeset
|
237 } |
| 6197 | 238 } |
| 239 } | |
| 240 | |
| 241 // walk virtual memory callsite | |
| 242 MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs); | |
| 243 MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs); | |
| 244 VMCallsitePointer* cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current(); | |
| 245 VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current(); | |
| 246 while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) { | |
| 247 if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) { | |
|
10984
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
248 // this is a new callsite |
| 6197 | 249 _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), |
| 250 amount_in_current_scale(cur_vm_callsite->reserved_amount()), | |
| 251 amount_in_current_scale(cur_vm_callsite->committed_amount()), | |
| 252 diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0), | |
| 253 diff_in_current_scale(cur_vm_callsite->committed_amount(), 0)); | |
| 254 cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); | |
| 255 } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) { | |
|
10984
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
256 // this callsite is already gone |
| 6197 | 257 _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(), |
|
10984
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
258 amount_in_current_scale(0), |
|
cd2118b62475
8013917: Kitchensink crashed with SIGSEGV in BaselineReporter::diff_callsites
zgu
parents:
8668
diff
changeset
|
259 amount_in_current_scale(0), |
| 6197 | 260 diff_in_current_scale(0, prev_vm_callsite->reserved_amount()), |
| 261 diff_in_current_scale(0, prev_vm_callsite->committed_amount())); | |
| 262 prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); | |
| 263 } else { // the same callsite | |
| 264 _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), | |
| 265 amount_in_current_scale(cur_vm_callsite->reserved_amount()), | |
| 266 amount_in_current_scale(cur_vm_callsite->committed_amount()), | |
| 267 diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()), | |
| 268 diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount())); | |
| 269 cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); | |
| 270 prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); | |
| 271 } | |
| 272 } | |
| 273 | |
| 274 _outputer.done_callsite(); | |
| 275 } | |
| 276 | |
| 277 size_t BaselineReporter::amount_in_current_scale(size_t amt) const { | |
| 278 return (size_t)(((float)amt/(float)_scale) + 0.5); | |
| 279 } | |
| 280 | |
| 281 int BaselineReporter::diff_in_current_scale(size_t value1, size_t value2) const { | |
| 282 return (int)(((float)value1 - (float)value2)/((float)_scale) + 0.5); | |
| 283 } | |
| 284 | |
| 285 int BaselineReporter::diff(size_t value1, size_t value2) const { | |
| 286 return ((int)value1 - (int)value2); | |
| 287 } | |
| 288 | |
| 289 void BaselineTTYOutputer::start(size_t scale, bool report_diff) { | |
| 290 _scale = scale; | |
| 291 _output->print_cr(" "); | |
| 292 _output->print_cr("Native Memory Tracking:"); | |
| 293 _output->print_cr(" "); | |
| 294 } | |
| 295 | |
| 296 void BaselineTTYOutputer::done() { | |
| 297 | |
| 298 } | |
| 299 | |
| 300 void BaselineTTYOutputer::total_usage(size_t total_reserved, size_t total_committed) { | |
| 301 const char* unit = memory_unit(_scale); | |
| 302 _output->print_cr("Total: reserved=%d%s, committed=%d%s", | |
| 303 total_reserved, unit, total_committed, unit); | |
| 304 } | |
| 305 | |
| 306 void BaselineTTYOutputer::start_category_summary() { | |
| 307 _output->print_cr(" "); | |
| 308 } | |
| 309 | |
| 310 /** | |
| 311 * report a summary of memory type | |
| 312 */ | |
| 313 void BaselineTTYOutputer::category_summary(MEMFLAGS type, | |
| 314 size_t reserved_amt, size_t committed_amt, size_t malloc_amt, | |
| 315 size_t malloc_count, size_t arena_amt, size_t arena_count) { | |
| 316 | |
| 317 // we report mtThreadStack under mtThread category | |
| 318 if (type == mtThreadStack) { | |
| 319 assert(malloc_amt == 0 && malloc_count == 0 && arena_amt == 0, | |
| 320 "Just check"); | |
| 321 _thread_stack_reserved = reserved_amt; | |
| 322 _thread_stack_committed = committed_amt; | |
| 323 } else { | |
| 324 const char* unit = memory_unit(_scale); | |
| 325 size_t total_reserved = (reserved_amt + malloc_amt + arena_amt); | |
| 326 size_t total_committed = (committed_amt + malloc_amt + arena_amt); | |
| 327 if (type == mtThread) { | |
| 328 total_reserved += _thread_stack_reserved; | |
| 329 total_committed += _thread_stack_committed; | |
| 330 } | |
| 331 | |
| 332 if (total_reserved > 0) { | |
| 333 _output->print_cr("-%26s (reserved=%d%s, committed=%d%s)", | |
| 334 MemBaseline::type2name(type), total_reserved, unit, | |
| 335 total_committed, unit); | |
| 336 | |
| 337 if (type == mtClass) { | |
| 338 _output->print_cr("%27s (classes #%d)", " ", _num_of_classes); | |
| 339 } else if (type == mtThread) { | |
| 340 _output->print_cr("%27s (thread #%d)", " ", _num_of_threads); | |
| 341 _output->print_cr("%27s (stack: reserved=%d%s, committed=%d%s)", " ", | |
| 342 _thread_stack_reserved, unit, _thread_stack_committed, unit); | |
| 343 } | |
| 344 | |
| 345 if (malloc_amt > 0) { | |
| 346 if (type != mtChunk) { | |
| 347 _output->print_cr("%27s (malloc=%d%s, #%d)", " ", malloc_amt, unit, | |
| 348 malloc_count); | |
| 349 } else { | |
| 350 _output->print_cr("%27s (malloc=%d%s)", " ", malloc_amt, unit); | |
| 351 } | |
| 352 } | |
| 353 | |
| 354 if (reserved_amt > 0) { | |
| 355 _output->print_cr("%27s (mmap: reserved=%d%s, committed=%d%s)", | |
| 356 " ", reserved_amt, unit, committed_amt, unit); | |
| 357 } | |
| 358 | |
| 359 if (arena_amt > 0) { | |
| 360 _output->print_cr("%27s (arena=%d%s, #%d)", " ", arena_amt, unit, arena_count); | |
| 361 } | |
| 362 | |
| 363 _output->print_cr(" "); | |
| 364 } | |
| 365 } | |
| 366 } | |
| 367 | |
| 368 void BaselineTTYOutputer::done_category_summary() { | |
| 369 _output->print_cr(" "); | |
| 370 } | |
| 371 | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
372 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
373 void BaselineTTYOutputer::start_virtual_memory_map() { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
374 _output->print_cr("Virtual memory map:"); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
375 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
376 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
377 void BaselineTTYOutputer::reserved_memory_region(MEMFLAGS type, address base, address end, |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
378 size_t size, address pc) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
379 const char* unit = memory_unit(_scale); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
380 char buf[128]; |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
381 int offset; |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
382 _output->print_cr(" "); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
383 _output->print_cr("[" PTR_FORMAT " - " PTR_FORMAT "] reserved %d%s for %s", base, end, size, unit, |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
384 MemBaseline::type2name(type)); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
385 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
386 _output->print_cr("\t\tfrom [%s+0x%x]", buf, offset); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
387 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
388 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
389 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
390 void BaselineTTYOutputer::committed_memory_region(address base, address end, size_t size, address pc) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
391 const char* unit = memory_unit(_scale); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
392 char buf[128]; |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
393 int offset; |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
394 _output->print("\t[" PTR_FORMAT " - " PTR_FORMAT "] committed %d%s", base, end, size, unit); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
395 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
396 _output->print_cr(" from [%s+0x%x]", buf, offset); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
397 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
398 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
399 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
400 void BaselineTTYOutputer::done_virtual_memory_map() { |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
401 _output->print_cr(" "); |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
402 } |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
403 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
404 |
|
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
405 |
| 6197 | 406 void BaselineTTYOutputer::start_callsite() { |
| 407 _output->print_cr("Details:"); | |
| 408 _output->print_cr(" "); | |
| 409 } | |
| 410 | |
| 411 void BaselineTTYOutputer::done_callsite() { | |
| 412 _output->print_cr(" "); | |
| 413 } | |
| 414 | |
| 415 void BaselineTTYOutputer::malloc_callsite(address pc, size_t malloc_amt, | |
| 416 size_t malloc_count) { | |
| 417 if (malloc_amt > 0) { | |
| 418 const char* unit = memory_unit(_scale); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
419 char buf[128]; |
| 6197 | 420 int offset; |
| 421 if (pc == 0) { | |
| 422 _output->print("[BOOTSTRAP]%18s", " "); | |
| 423 } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
| 424 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
| 425 _output->print("%28s", " "); | |
| 426 } else { | |
| 427 _output->print("[" PTR_FORMAT "]%18s", pc, " "); | |
| 428 } | |
| 429 | |
| 430 _output->print_cr("(malloc=%d%s #%d)", malloc_amt, unit, malloc_count); | |
| 431 _output->print_cr(" "); | |
| 432 } | |
| 433 } | |
| 434 | |
| 435 void BaselineTTYOutputer::virtual_memory_callsite(address pc, size_t reserved_amt, | |
| 436 size_t committed_amt) { | |
| 437 if (reserved_amt > 0) { | |
| 438 const char* unit = memory_unit(_scale); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
439 char buf[128]; |
| 6197 | 440 int offset; |
| 441 if (pc == 0) { | |
| 442 _output->print("[BOOTSTRAP]%18s", " "); | |
| 443 } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
| 444 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
| 445 _output->print("%28s", " "); | |
| 446 } else { | |
| 8668 | 447 _output->print("[" PTR_FORMAT "]%18s", pc, " "); |
| 6197 | 448 } |
| 449 | |
| 450 _output->print_cr("(mmap: reserved=%d%s, committed=%d%s)", | |
| 451 reserved_amt, unit, committed_amt, unit); | |
| 452 _output->print_cr(" "); | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 void BaselineTTYOutputer::diff_total_usage(size_t total_reserved, | |
| 457 size_t total_committed, int reserved_diff, int committed_diff) { | |
| 458 const char* unit = memory_unit(_scale); | |
| 459 _output->print_cr("Total: reserved=%d%s %+d%s, committed=%d%s %+d%s", | |
| 460 total_reserved, unit, reserved_diff, unit, total_committed, unit, | |
| 461 committed_diff, unit); | |
| 462 } | |
| 463 | |
| 464 void BaselineTTYOutputer::diff_category_summary(MEMFLAGS type, | |
| 465 size_t cur_reserved_amt, size_t cur_committed_amt, | |
| 466 size_t cur_malloc_amt, size_t cur_malloc_count, | |
| 467 size_t cur_arena_amt, size_t cur_arena_count, | |
| 468 int reserved_diff, int committed_diff, int malloc_diff, | |
| 469 int malloc_count_diff, int arena_diff, int arena_count_diff) { | |
| 470 | |
| 471 if (type == mtThreadStack) { | |
| 472 assert(cur_malloc_amt == 0 && cur_malloc_count == 0 && | |
| 473 cur_arena_amt == 0, "Just check"); | |
| 474 _thread_stack_reserved = cur_reserved_amt; | |
| 475 _thread_stack_committed = cur_committed_amt; | |
| 476 _thread_stack_reserved_diff = reserved_diff; | |
| 477 _thread_stack_committed_diff = committed_diff; | |
| 478 } else { | |
| 479 const char* unit = memory_unit(_scale); | |
| 480 size_t total_reserved = (cur_reserved_amt + cur_malloc_amt + cur_arena_amt); | |
| 481 // nothing to report in this category | |
| 482 if (total_reserved == 0) { | |
| 483 return; | |
| 484 } | |
| 485 int diff_reserved = (reserved_diff + malloc_diff + arena_diff); | |
| 486 | |
| 487 // category summary | |
| 488 _output->print("-%26s (reserved=%d%s", MemBaseline::type2name(type), | |
| 489 total_reserved, unit); | |
| 490 | |
| 491 if (diff_reserved != 0) { | |
| 492 _output->print(" %+d%s", diff_reserved, unit); | |
| 493 } | |
| 494 | |
| 495 size_t total_committed = cur_committed_amt + cur_malloc_amt + cur_arena_amt; | |
| 496 _output->print(", committed=%d%s", total_committed, unit); | |
| 497 | |
| 498 int total_committed_diff = committed_diff + malloc_diff + arena_diff; | |
| 499 if (total_committed_diff != 0) { | |
| 500 _output->print(" %+d%s", total_committed_diff, unit); | |
| 501 } | |
| 502 | |
| 503 _output->print_cr(")"); | |
| 504 | |
| 505 // special cases | |
| 506 if (type == mtClass) { | |
| 507 _output->print("%27s (classes #%d", " ", _num_of_classes); | |
| 508 if (_num_of_classes_diff != 0) { | |
| 509 _output->print(" %+d", _num_of_classes_diff); | |
| 510 } | |
| 511 _output->print_cr(")"); | |
| 512 } else if (type == mtThread) { | |
| 513 // thread count | |
| 514 _output->print("%27s (thread #%d", " ", _num_of_threads); | |
| 515 if (_num_of_threads_diff != 0) { | |
| 516 _output->print_cr(" %+d)", _num_of_threads_diff); | |
| 517 } else { | |
| 518 _output->print_cr(")"); | |
| 519 } | |
| 520 _output->print("%27s (stack: reserved=%d%s", " ", _thread_stack_reserved, unit); | |
| 521 if (_thread_stack_reserved_diff != 0) { | |
| 522 _output->print(" %+d%s", _thread_stack_reserved_diff, unit); | |
| 523 } | |
| 524 | |
| 525 _output->print(", committed=%d%s", _thread_stack_committed, unit); | |
| 526 if (_thread_stack_committed_diff != 0) { | |
| 527 _output->print(" %+d%s",_thread_stack_committed_diff, unit); | |
| 528 } | |
| 529 | |
| 530 _output->print_cr(")"); | |
| 531 } | |
| 532 | |
| 533 // malloc'd memory | |
| 534 if (cur_malloc_amt > 0) { | |
| 535 _output->print("%27s (malloc=%d%s", " ", cur_malloc_amt, unit); | |
| 536 if (malloc_diff != 0) { | |
| 537 _output->print(" %+d%s", malloc_diff, unit); | |
| 538 } | |
| 539 if (type != mtChunk) { | |
| 540 _output->print(", #%d", cur_malloc_count); | |
| 541 if (malloc_count_diff) { | |
| 542 _output->print(" %+d", malloc_count_diff); | |
| 543 } | |
| 544 } | |
| 545 _output->print_cr(")"); | |
| 546 } | |
| 547 | |
| 548 // mmap'd memory | |
| 549 if (cur_reserved_amt > 0) { | |
| 550 _output->print("%27s (mmap: reserved=%d%s", " ", cur_reserved_amt, unit); | |
| 551 if (reserved_diff != 0) { | |
| 552 _output->print(" %+d%s", reserved_diff, unit); | |
| 553 } | |
| 554 | |
| 555 _output->print(", committed=%d%s", cur_committed_amt, unit); | |
| 556 if (committed_diff != 0) { | |
| 557 _output->print(" %+d%s", committed_diff, unit); | |
| 558 } | |
| 559 _output->print_cr(")"); | |
| 560 } | |
| 561 | |
| 562 // arena memory | |
| 563 if (cur_arena_amt > 0) { | |
| 564 _output->print("%27s (arena=%d%s", " ", cur_arena_amt, unit); | |
| 565 if (arena_diff != 0) { | |
| 566 _output->print(" %+d%s", arena_diff, unit); | |
| 567 } | |
| 568 _output->print(", #%d", cur_arena_count); | |
| 569 if (arena_count_diff != 0) { | |
| 570 _output->print(" %+d", arena_count_diff); | |
| 571 } | |
| 572 _output->print_cr(")"); | |
| 573 } | |
| 574 | |
| 575 _output->print_cr(" "); | |
| 576 } | |
| 577 } | |
| 578 | |
| 579 void BaselineTTYOutputer::diff_malloc_callsite(address pc, | |
| 580 size_t cur_malloc_amt, size_t cur_malloc_count, | |
| 581 int malloc_diff, int malloc_count_diff) { | |
| 582 if (malloc_diff != 0) { | |
| 583 const char* unit = memory_unit(_scale); | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6197
diff
changeset
|
584 char buf[128]; |
| 6197 | 585 int offset; |
| 586 if (pc == 0) { | |
| 587 _output->print_cr("[BOOTSTRAP]%18s", " "); | |
| 588 } else { | |
| 589 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
| 590 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
| 591 _output->print("%28s", " "); | |
| 592 } else { | |
| 593 _output->print("[" PTR_FORMAT "]%18s", pc, " "); | |
| 594 } | |
| 595 } | |
| 596 | |
| 597 _output->print("(malloc=%d%s", cur_malloc_amt, unit); | |
| 598 if (malloc_diff != 0) { | |
| 599 _output->print(" %+d%s", malloc_diff, unit); | |
| 600 } | |
| 601 _output->print(", #%d", cur_malloc_count); | |
| 602 if (malloc_count_diff != 0) { | |
| 603 _output->print(" %+d", malloc_count_diff); | |
| 604 } | |
| 605 _output->print_cr(")"); | |
| 606 _output->print_cr(" "); | |
| 607 } | |
| 608 } | |
| 609 | |
| 610 void BaselineTTYOutputer::diff_virtual_memory_callsite(address pc, | |
| 611 size_t cur_reserved_amt, size_t cur_committed_amt, | |
| 612 int reserved_diff, int committed_diff) { | |
| 613 if (reserved_diff != 0 || committed_diff != 0) { | |
| 614 const char* unit = memory_unit(_scale); | |
| 615 char buf[64]; | |
| 616 int offset; | |
| 617 if (pc == 0) { | |
| 618 _output->print_cr("[BOOSTRAP]%18s", " "); | |
| 619 } else { | |
| 620 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
| 621 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
| 622 _output->print("%28s", " "); | |
| 623 } else { | |
| 8668 | 624 _output->print("[" PTR_FORMAT "]%18s", pc, " "); |
| 6197 | 625 } |
| 626 } | |
| 627 | |
| 628 _output->print("(mmap: reserved=%d%s", cur_reserved_amt, unit); | |
| 629 if (reserved_diff != 0) { | |
| 630 _output->print(" %+d%s", reserved_diff, unit); | |
| 631 } | |
| 632 _output->print(", committed=%d%s", cur_committed_amt, unit); | |
| 633 if (committed_diff != 0) { | |
| 634 _output->print(" %+d%s", committed_diff, unit); | |
| 635 } | |
| 636 _output->print_cr(")"); | |
| 637 _output->print_cr(" "); | |
| 638 } | |
| 639 } |