Mercurial > hg > truffle
comparison src/share/vm/services/memReporter.cpp @ 6275:957c266d8bc5
Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Tue, 21 Aug 2012 10:39:19 +0200 |
parents | d2a62e0f25eb |
children | 716c64bda5ba |
comparison
equal
deleted
inserted
replaced
5891:fd8832ae511d | 6275:957c266d8bc5 |
---|---|
1 /* | |
2 * Copyright (c) 2012 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 #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 | |
31 const char* BaselineOutputer::memory_unit(size_t scale) { | |
32 switch(scale) { | |
33 case K: return "KB"; | |
34 case M: return "MB"; | |
35 case G: return "GB"; | |
36 } | |
37 ShouldNotReachHere(); | |
38 return NULL; | |
39 } | |
40 | |
41 | |
42 void BaselineReporter::report_baseline(const MemBaseline& baseline, bool summary_only) { | |
43 assert(MemTracker::is_on(), "Native memory tracking is off"); | |
44 _outputer.start(scale()); | |
45 _outputer.total_usage( | |
46 amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_reserved_amount()), | |
47 amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_committed_amount())); | |
48 | |
49 _outputer.num_of_classes(baseline.number_of_classes()); | |
50 _outputer.num_of_threads(baseline.number_of_threads()); | |
51 | |
52 report_summaries(baseline); | |
53 if (!summary_only && MemTracker::track_callsite()) { | |
54 report_callsites(baseline); | |
55 } | |
56 _outputer.done(); | |
57 } | |
58 | |
59 void BaselineReporter::report_summaries(const MemBaseline& baseline) { | |
60 _outputer.start_category_summary(); | |
61 MEMFLAGS type; | |
62 | |
63 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { | |
64 type = MemBaseline::MemType2NameMap[index]._flag; | |
65 _outputer.category_summary(type, | |
66 amount_in_current_scale(baseline.reserved_amount(type)), | |
67 amount_in_current_scale(baseline.committed_amount(type)), | |
68 amount_in_current_scale(baseline.malloc_amount(type)), | |
69 baseline.malloc_count(type), | |
70 amount_in_current_scale(baseline.arena_amount(type)), | |
71 baseline.arena_count(type)); | |
72 } | |
73 | |
74 _outputer.done_category_summary(); | |
75 } | |
76 | |
77 void BaselineReporter::report_callsites(const MemBaseline& baseline) { | |
78 _outputer.start_callsite(); | |
79 MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); | |
80 | |
81 pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_size); | |
82 pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_size); | |
83 | |
84 // walk malloc callsites | |
85 MemPointerArrayIteratorImpl malloc_itr(pBL->_malloc_cs); | |
86 MallocCallsitePointer* malloc_callsite = | |
87 (MallocCallsitePointer*)malloc_itr.current(); | |
88 while (malloc_callsite != NULL) { | |
89 _outputer.malloc_callsite(malloc_callsite->addr(), | |
90 amount_in_current_scale(malloc_callsite->amount()), malloc_callsite->count()); | |
91 malloc_callsite = (MallocCallsitePointer*)malloc_itr.next(); | |
92 } | |
93 | |
94 // walk virtual memory callsite | |
95 MemPointerArrayIteratorImpl vm_itr(pBL->_vm_cs); | |
96 VMCallsitePointer* vm_callsite = (VMCallsitePointer*)vm_itr.current(); | |
97 while (vm_callsite != NULL) { | |
98 _outputer.virtual_memory_callsite(vm_callsite->addr(), | |
99 amount_in_current_scale(vm_callsite->reserved_amount()), | |
100 amount_in_current_scale(vm_callsite->committed_amount())); | |
101 vm_callsite = (VMCallsitePointer*)vm_itr.next(); | |
102 } | |
103 pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_pc); | |
104 pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_pc); | |
105 _outputer.done_callsite(); | |
106 } | |
107 | |
108 void BaselineReporter::diff_baselines(const MemBaseline& cur, const MemBaseline& prev, | |
109 bool summary_only) { | |
110 assert(MemTracker::is_on(), "Native memory tracking is off"); | |
111 _outputer.start(scale()); | |
112 size_t total_reserved = cur.total_malloc_amount() + cur.total_reserved_amount(); | |
113 size_t total_committed = cur.total_malloc_amount() + cur.total_committed_amount(); | |
114 | |
115 _outputer.diff_total_usage( | |
116 amount_in_current_scale(total_reserved), amount_in_current_scale(total_committed), | |
117 diff_in_current_scale(total_reserved, (prev.total_malloc_amount() + prev.total_reserved_amount())), | |
118 diff_in_current_scale(total_committed, (prev.total_committed_amount() + prev.total_malloc_amount()))); | |
119 | |
120 _outputer.diff_num_of_classes(cur.number_of_classes(), | |
121 diff(cur.number_of_classes(), prev.number_of_classes())); | |
122 _outputer.diff_num_of_threads(cur.number_of_threads(), | |
123 diff(cur.number_of_threads(), prev.number_of_threads())); | |
124 | |
125 diff_summaries(cur, prev); | |
126 if (!summary_only && MemTracker::track_callsite()) { | |
127 diff_callsites(cur, prev); | |
128 } | |
129 _outputer.done(); | |
130 } | |
131 | |
132 void BaselineReporter::diff_summaries(const MemBaseline& cur, const MemBaseline& prev) { | |
133 _outputer.start_category_summary(); | |
134 MEMFLAGS type; | |
135 | |
136 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { | |
137 type = MemBaseline::MemType2NameMap[index]._flag; | |
138 _outputer.diff_category_summary(type, | |
139 amount_in_current_scale(cur.reserved_amount(type)), | |
140 amount_in_current_scale(cur.committed_amount(type)), | |
141 amount_in_current_scale(cur.malloc_amount(type)), | |
142 cur.malloc_count(type), | |
143 amount_in_current_scale(cur.arena_amount(type)), | |
144 cur.arena_count(type), | |
145 diff_in_current_scale(cur.reserved_amount(type), prev.reserved_amount(type)), | |
146 diff_in_current_scale(cur.committed_amount(type), prev.committed_amount(type)), | |
147 diff_in_current_scale(cur.malloc_amount(type), prev.malloc_amount(type)), | |
148 diff(cur.malloc_count(type), prev.malloc_count(type)), | |
149 diff_in_current_scale(cur.arena_amount(type), prev.arena_amount(type)), | |
150 diff(cur.arena_count(type), prev.arena_count(type))); | |
151 } | |
152 | |
153 _outputer.done_category_summary(); | |
154 } | |
155 | |
156 void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) { | |
157 _outputer.start_callsite(); | |
158 MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur); | |
159 MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev); | |
160 | |
161 // walk malloc callsites | |
162 MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs); | |
163 MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs); | |
164 | |
165 MallocCallsitePointer* cur_malloc_callsite = | |
166 (MallocCallsitePointer*)cur_malloc_itr.current(); | |
167 MallocCallsitePointer* prev_malloc_callsite = | |
168 (MallocCallsitePointer*)prev_malloc_itr.current(); | |
169 | |
170 while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) { | |
171 if (prev_malloc_callsite == NULL || | |
172 cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) { | |
173 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), | |
174 amount_in_current_scale(cur_malloc_callsite->amount()), | |
175 cur_malloc_callsite->count(), | |
176 diff_in_current_scale(cur_malloc_callsite->amount(), 0), | |
177 diff(cur_malloc_callsite->count(), 0)); | |
178 cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); | |
179 } else if (prev_malloc_callsite == NULL || | |
180 cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) { | |
181 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), | |
182 amount_in_current_scale(prev_malloc_callsite->amount()), | |
183 prev_malloc_callsite->count(), | |
184 diff_in_current_scale(0, prev_malloc_callsite->amount()), | |
185 diff(0, prev_malloc_callsite->count())); | |
186 prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); | |
187 } else { // the same callsite | |
188 _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), | |
189 amount_in_current_scale(cur_malloc_callsite->amount()), | |
190 cur_malloc_callsite->count(), | |
191 diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()), | |
192 diff(cur_malloc_callsite->count(), prev_malloc_callsite->count())); | |
193 cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); | |
194 prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); | |
195 } | |
196 } | |
197 | |
198 // walk virtual memory callsite | |
199 MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs); | |
200 MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs); | |
201 VMCallsitePointer* cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current(); | |
202 VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current(); | |
203 while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) { | |
204 if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) { | |
205 _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), | |
206 amount_in_current_scale(cur_vm_callsite->reserved_amount()), | |
207 amount_in_current_scale(cur_vm_callsite->committed_amount()), | |
208 diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0), | |
209 diff_in_current_scale(cur_vm_callsite->committed_amount(), 0)); | |
210 cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); | |
211 } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) { | |
212 _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(), | |
213 amount_in_current_scale(prev_vm_callsite->reserved_amount()), | |
214 amount_in_current_scale(prev_vm_callsite->committed_amount()), | |
215 diff_in_current_scale(0, prev_vm_callsite->reserved_amount()), | |
216 diff_in_current_scale(0, prev_vm_callsite->committed_amount())); | |
217 prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); | |
218 } else { // the same callsite | |
219 _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), | |
220 amount_in_current_scale(cur_vm_callsite->reserved_amount()), | |
221 amount_in_current_scale(cur_vm_callsite->committed_amount()), | |
222 diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()), | |
223 diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount())); | |
224 cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); | |
225 prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); | |
226 } | |
227 } | |
228 | |
229 _outputer.done_callsite(); | |
230 } | |
231 | |
232 size_t BaselineReporter::amount_in_current_scale(size_t amt) const { | |
233 return (size_t)(((float)amt/(float)_scale) + 0.5); | |
234 } | |
235 | |
236 int BaselineReporter::diff_in_current_scale(size_t value1, size_t value2) const { | |
237 return (int)(((float)value1 - (float)value2)/((float)_scale) + 0.5); | |
238 } | |
239 | |
240 int BaselineReporter::diff(size_t value1, size_t value2) const { | |
241 return ((int)value1 - (int)value2); | |
242 } | |
243 | |
244 void BaselineTTYOutputer::start(size_t scale, bool report_diff) { | |
245 _scale = scale; | |
246 _output->print_cr(" "); | |
247 _output->print_cr("Native Memory Tracking:"); | |
248 _output->print_cr(" "); | |
249 } | |
250 | |
251 void BaselineTTYOutputer::done() { | |
252 | |
253 } | |
254 | |
255 void BaselineTTYOutputer::total_usage(size_t total_reserved, size_t total_committed) { | |
256 const char* unit = memory_unit(_scale); | |
257 _output->print_cr("Total: reserved=%d%s, committed=%d%s", | |
258 total_reserved, unit, total_committed, unit); | |
259 } | |
260 | |
261 void BaselineTTYOutputer::start_category_summary() { | |
262 _output->print_cr(" "); | |
263 } | |
264 | |
265 /** | |
266 * report a summary of memory type | |
267 */ | |
268 void BaselineTTYOutputer::category_summary(MEMFLAGS type, | |
269 size_t reserved_amt, size_t committed_amt, size_t malloc_amt, | |
270 size_t malloc_count, size_t arena_amt, size_t arena_count) { | |
271 | |
272 // we report mtThreadStack under mtThread category | |
273 if (type == mtThreadStack) { | |
274 assert(malloc_amt == 0 && malloc_count == 0 && arena_amt == 0, | |
275 "Just check"); | |
276 _thread_stack_reserved = reserved_amt; | |
277 _thread_stack_committed = committed_amt; | |
278 } else { | |
279 const char* unit = memory_unit(_scale); | |
280 size_t total_reserved = (reserved_amt + malloc_amt + arena_amt); | |
281 size_t total_committed = (committed_amt + malloc_amt + arena_amt); | |
282 if (type == mtThread) { | |
283 total_reserved += _thread_stack_reserved; | |
284 total_committed += _thread_stack_committed; | |
285 } | |
286 | |
287 if (total_reserved > 0) { | |
288 _output->print_cr("-%26s (reserved=%d%s, committed=%d%s)", | |
289 MemBaseline::type2name(type), total_reserved, unit, | |
290 total_committed, unit); | |
291 | |
292 if (type == mtClass) { | |
293 _output->print_cr("%27s (classes #%d)", " ", _num_of_classes); | |
294 } else if (type == mtThread) { | |
295 _output->print_cr("%27s (thread #%d)", " ", _num_of_threads); | |
296 _output->print_cr("%27s (stack: reserved=%d%s, committed=%d%s)", " ", | |
297 _thread_stack_reserved, unit, _thread_stack_committed, unit); | |
298 } | |
299 | |
300 if (malloc_amt > 0) { | |
301 if (type != mtChunk) { | |
302 _output->print_cr("%27s (malloc=%d%s, #%d)", " ", malloc_amt, unit, | |
303 malloc_count); | |
304 } else { | |
305 _output->print_cr("%27s (malloc=%d%s)", " ", malloc_amt, unit); | |
306 } | |
307 } | |
308 | |
309 if (reserved_amt > 0) { | |
310 _output->print_cr("%27s (mmap: reserved=%d%s, committed=%d%s)", | |
311 " ", reserved_amt, unit, committed_amt, unit); | |
312 } | |
313 | |
314 if (arena_amt > 0) { | |
315 _output->print_cr("%27s (arena=%d%s, #%d)", " ", arena_amt, unit, arena_count); | |
316 } | |
317 | |
318 _output->print_cr(" "); | |
319 } | |
320 } | |
321 } | |
322 | |
323 void BaselineTTYOutputer::done_category_summary() { | |
324 _output->print_cr(" "); | |
325 } | |
326 | |
327 void BaselineTTYOutputer::start_callsite() { | |
328 _output->print_cr("Details:"); | |
329 _output->print_cr(" "); | |
330 } | |
331 | |
332 void BaselineTTYOutputer::done_callsite() { | |
333 _output->print_cr(" "); | |
334 } | |
335 | |
336 void BaselineTTYOutputer::malloc_callsite(address pc, size_t malloc_amt, | |
337 size_t malloc_count) { | |
338 if (malloc_amt > 0) { | |
339 const char* unit = memory_unit(_scale); | |
340 char buf[64]; | |
341 int offset; | |
342 if (pc == 0) { | |
343 _output->print("[BOOTSTRAP]%18s", " "); | |
344 } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
345 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
346 _output->print("%28s", " "); | |
347 } else { | |
348 _output->print("[" PTR_FORMAT "]%18s", pc, " "); | |
349 } | |
350 | |
351 _output->print_cr("(malloc=%d%s #%d)", malloc_amt, unit, malloc_count); | |
352 _output->print_cr(" "); | |
353 } | |
354 } | |
355 | |
356 void BaselineTTYOutputer::virtual_memory_callsite(address pc, size_t reserved_amt, | |
357 size_t committed_amt) { | |
358 if (reserved_amt > 0) { | |
359 const char* unit = memory_unit(_scale); | |
360 char buf[64]; | |
361 int offset; | |
362 if (pc == 0) { | |
363 _output->print("[BOOTSTRAP]%18s", " "); | |
364 } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
365 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
366 _output->print("%28s", " "); | |
367 } else { | |
368 _output->print("[" PTR_FORMAT "]%18s", " "); | |
369 } | |
370 | |
371 _output->print_cr("(mmap: reserved=%d%s, committed=%d%s)", | |
372 reserved_amt, unit, committed_amt, unit); | |
373 _output->print_cr(" "); | |
374 } | |
375 } | |
376 | |
377 void BaselineTTYOutputer::diff_total_usage(size_t total_reserved, | |
378 size_t total_committed, int reserved_diff, int committed_diff) { | |
379 const char* unit = memory_unit(_scale); | |
380 _output->print_cr("Total: reserved=%d%s %+d%s, committed=%d%s %+d%s", | |
381 total_reserved, unit, reserved_diff, unit, total_committed, unit, | |
382 committed_diff, unit); | |
383 } | |
384 | |
385 void BaselineTTYOutputer::diff_category_summary(MEMFLAGS type, | |
386 size_t cur_reserved_amt, size_t cur_committed_amt, | |
387 size_t cur_malloc_amt, size_t cur_malloc_count, | |
388 size_t cur_arena_amt, size_t cur_arena_count, | |
389 int reserved_diff, int committed_diff, int malloc_diff, | |
390 int malloc_count_diff, int arena_diff, int arena_count_diff) { | |
391 | |
392 if (type == mtThreadStack) { | |
393 assert(cur_malloc_amt == 0 && cur_malloc_count == 0 && | |
394 cur_arena_amt == 0, "Just check"); | |
395 _thread_stack_reserved = cur_reserved_amt; | |
396 _thread_stack_committed = cur_committed_amt; | |
397 _thread_stack_reserved_diff = reserved_diff; | |
398 _thread_stack_committed_diff = committed_diff; | |
399 } else { | |
400 const char* unit = memory_unit(_scale); | |
401 size_t total_reserved = (cur_reserved_amt + cur_malloc_amt + cur_arena_amt); | |
402 // nothing to report in this category | |
403 if (total_reserved == 0) { | |
404 return; | |
405 } | |
406 int diff_reserved = (reserved_diff + malloc_diff + arena_diff); | |
407 | |
408 // category summary | |
409 _output->print("-%26s (reserved=%d%s", MemBaseline::type2name(type), | |
410 total_reserved, unit); | |
411 | |
412 if (diff_reserved != 0) { | |
413 _output->print(" %+d%s", diff_reserved, unit); | |
414 } | |
415 | |
416 size_t total_committed = cur_committed_amt + cur_malloc_amt + cur_arena_amt; | |
417 _output->print(", committed=%d%s", total_committed, unit); | |
418 | |
419 int total_committed_diff = committed_diff + malloc_diff + arena_diff; | |
420 if (total_committed_diff != 0) { | |
421 _output->print(" %+d%s", total_committed_diff, unit); | |
422 } | |
423 | |
424 _output->print_cr(")"); | |
425 | |
426 // special cases | |
427 if (type == mtClass) { | |
428 _output->print("%27s (classes #%d", " ", _num_of_classes); | |
429 if (_num_of_classes_diff != 0) { | |
430 _output->print(" %+d", _num_of_classes_diff); | |
431 } | |
432 _output->print_cr(")"); | |
433 } else if (type == mtThread) { | |
434 // thread count | |
435 _output->print("%27s (thread #%d", " ", _num_of_threads); | |
436 if (_num_of_threads_diff != 0) { | |
437 _output->print_cr(" %+d)", _num_of_threads_diff); | |
438 } else { | |
439 _output->print_cr(")"); | |
440 } | |
441 _output->print("%27s (stack: reserved=%d%s", " ", _thread_stack_reserved, unit); | |
442 if (_thread_stack_reserved_diff != 0) { | |
443 _output->print(" %+d%s", _thread_stack_reserved_diff, unit); | |
444 } | |
445 | |
446 _output->print(", committed=%d%s", _thread_stack_committed, unit); | |
447 if (_thread_stack_committed_diff != 0) { | |
448 _output->print(" %+d%s",_thread_stack_committed_diff, unit); | |
449 } | |
450 | |
451 _output->print_cr(")"); | |
452 } | |
453 | |
454 // malloc'd memory | |
455 if (cur_malloc_amt > 0) { | |
456 _output->print("%27s (malloc=%d%s", " ", cur_malloc_amt, unit); | |
457 if (malloc_diff != 0) { | |
458 _output->print(" %+d%s", malloc_diff, unit); | |
459 } | |
460 if (type != mtChunk) { | |
461 _output->print(", #%d", cur_malloc_count); | |
462 if (malloc_count_diff) { | |
463 _output->print(" %+d", malloc_count_diff); | |
464 } | |
465 } | |
466 _output->print_cr(")"); | |
467 } | |
468 | |
469 // mmap'd memory | |
470 if (cur_reserved_amt > 0) { | |
471 _output->print("%27s (mmap: reserved=%d%s", " ", cur_reserved_amt, unit); | |
472 if (reserved_diff != 0) { | |
473 _output->print(" %+d%s", reserved_diff, unit); | |
474 } | |
475 | |
476 _output->print(", committed=%d%s", cur_committed_amt, unit); | |
477 if (committed_diff != 0) { | |
478 _output->print(" %+d%s", committed_diff, unit); | |
479 } | |
480 _output->print_cr(")"); | |
481 } | |
482 | |
483 // arena memory | |
484 if (cur_arena_amt > 0) { | |
485 _output->print("%27s (arena=%d%s", " ", cur_arena_amt, unit); | |
486 if (arena_diff != 0) { | |
487 _output->print(" %+d%s", arena_diff, unit); | |
488 } | |
489 _output->print(", #%d", cur_arena_count); | |
490 if (arena_count_diff != 0) { | |
491 _output->print(" %+d", arena_count_diff); | |
492 } | |
493 _output->print_cr(")"); | |
494 } | |
495 | |
496 _output->print_cr(" "); | |
497 } | |
498 } | |
499 | |
500 void BaselineTTYOutputer::diff_malloc_callsite(address pc, | |
501 size_t cur_malloc_amt, size_t cur_malloc_count, | |
502 int malloc_diff, int malloc_count_diff) { | |
503 if (malloc_diff != 0) { | |
504 const char* unit = memory_unit(_scale); | |
505 char buf[64]; | |
506 int offset; | |
507 if (pc == 0) { | |
508 _output->print_cr("[BOOTSTRAP]%18s", " "); | |
509 } else { | |
510 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
511 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
512 _output->print("%28s", " "); | |
513 } else { | |
514 _output->print("[" PTR_FORMAT "]%18s", pc, " "); | |
515 } | |
516 } | |
517 | |
518 _output->print("(malloc=%d%s", cur_malloc_amt, unit); | |
519 if (malloc_diff != 0) { | |
520 _output->print(" %+d%s", malloc_diff, unit); | |
521 } | |
522 _output->print(", #%d", cur_malloc_count); | |
523 if (malloc_count_diff != 0) { | |
524 _output->print(" %+d", malloc_count_diff); | |
525 } | |
526 _output->print_cr(")"); | |
527 _output->print_cr(" "); | |
528 } | |
529 } | |
530 | |
531 void BaselineTTYOutputer::diff_virtual_memory_callsite(address pc, | |
532 size_t cur_reserved_amt, size_t cur_committed_amt, | |
533 int reserved_diff, int committed_diff) { | |
534 if (reserved_diff != 0 || committed_diff != 0) { | |
535 const char* unit = memory_unit(_scale); | |
536 char buf[64]; | |
537 int offset; | |
538 if (pc == 0) { | |
539 _output->print_cr("[BOOSTRAP]%18s", " "); | |
540 } else { | |
541 if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { | |
542 _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); | |
543 _output->print("%28s", " "); | |
544 } else { | |
545 _output->print("[" PTR_FORMAT "]%18s", " "); | |
546 } | |
547 } | |
548 | |
549 _output->print("(mmap: reserved=%d%s", cur_reserved_amt, unit); | |
550 if (reserved_diff != 0) { | |
551 _output->print(" %+d%s", reserved_diff, unit); | |
552 } | |
553 _output->print(", committed=%d%s", cur_committed_amt, unit); | |
554 if (committed_diff != 0) { | |
555 _output->print(" %+d%s", committed_diff, unit); | |
556 } | |
557 _output->print_cr(")"); | |
558 _output->print_cr(" "); | |
559 } | |
560 } |