Tue, 24 Jul 2012 10:51:00 -0700
7023639: JSR 292 method handle invocation needs a fast path for compiled code
6984705: JSR 292 method handle creation should not go through JNI
Summary: remove assembly code for JDK 7 chained method handles
Reviewed-by: jrose, twisti, kvn, mhaupt
Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>
zgu@3900 | 1 | /* |
zgu@3900 | 2 | * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. |
zgu@3900 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
zgu@3900 | 4 | * |
zgu@3900 | 5 | * This code is free software; you can redistribute it and/or modify it |
zgu@3900 | 6 | * under the terms of the GNU General Public License version 2 only, as |
zgu@3900 | 7 | * published by the Free Software Foundation. |
zgu@3900 | 8 | * |
zgu@3900 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
zgu@3900 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
zgu@3900 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
zgu@3900 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
zgu@3900 | 13 | * accompanied this code). |
zgu@3900 | 14 | * |
zgu@3900 | 15 | * You should have received a copy of the GNU General Public License version |
zgu@3900 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
zgu@3900 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
zgu@3900 | 18 | * |
zgu@3900 | 19 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
zgu@3900 | 20 | * or visit www.oracle.com if you need additional information or have any |
zgu@3900 | 21 | * questions. |
zgu@3900 | 22 | * |
zgu@3900 | 23 | */ |
zgu@3900 | 24 | #include "precompiled.hpp" |
zgu@3900 | 25 | #include "classfile/systemDictionary.hpp" |
zgu@3900 | 26 | #include "runtime/os.hpp" |
zgu@3900 | 27 | #include "services/memReporter.hpp" |
zgu@3900 | 28 | #include "services/memPtrArray.hpp" |
zgu@3900 | 29 | #include "services/memTracker.hpp" |
zgu@3900 | 30 | |
zgu@3900 | 31 | const char* BaselineOutputer::memory_unit(size_t scale) { |
zgu@3900 | 32 | switch(scale) { |
zgu@3900 | 33 | case K: return "KB"; |
zgu@3900 | 34 | case M: return "MB"; |
zgu@3900 | 35 | case G: return "GB"; |
zgu@3900 | 36 | } |
zgu@3900 | 37 | ShouldNotReachHere(); |
zgu@3900 | 38 | return NULL; |
zgu@3900 | 39 | } |
zgu@3900 | 40 | |
zgu@3900 | 41 | |
zgu@3900 | 42 | void BaselineReporter::report_baseline(const MemBaseline& baseline, bool summary_only) { |
zgu@3900 | 43 | assert(MemTracker::is_on(), "Native memory tracking is off"); |
zgu@3900 | 44 | _outputer.start(scale()); |
zgu@3900 | 45 | _outputer.total_usage( |
zgu@3900 | 46 | amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_reserved_amount()), |
zgu@3900 | 47 | amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_committed_amount())); |
zgu@3900 | 48 | |
zgu@3900 | 49 | _outputer.num_of_classes(baseline.number_of_classes()); |
zgu@3900 | 50 | _outputer.num_of_threads(baseline.number_of_threads()); |
zgu@3900 | 51 | |
zgu@3900 | 52 | report_summaries(baseline); |
zgu@3900 | 53 | if (!summary_only && MemTracker::track_callsite()) { |
zgu@3900 | 54 | report_callsites(baseline); |
zgu@3900 | 55 | } |
zgu@3900 | 56 | _outputer.done(); |
zgu@3900 | 57 | } |
zgu@3900 | 58 | |
zgu@3900 | 59 | void BaselineReporter::report_summaries(const MemBaseline& baseline) { |
zgu@3900 | 60 | _outputer.start_category_summary(); |
zgu@3900 | 61 | MEMFLAGS type; |
zgu@3900 | 62 | |
zgu@3900 | 63 | for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { |
zgu@3900 | 64 | type = MemBaseline::MemType2NameMap[index]._flag; |
zgu@3900 | 65 | _outputer.category_summary(type, |
zgu@3900 | 66 | amount_in_current_scale(baseline.reserved_amount(type)), |
zgu@3900 | 67 | amount_in_current_scale(baseline.committed_amount(type)), |
zgu@3900 | 68 | amount_in_current_scale(baseline.malloc_amount(type)), |
zgu@3900 | 69 | baseline.malloc_count(type), |
zgu@3900 | 70 | amount_in_current_scale(baseline.arena_amount(type)), |
zgu@3900 | 71 | baseline.arena_count(type)); |
zgu@3900 | 72 | } |
zgu@3900 | 73 | |
zgu@3900 | 74 | _outputer.done_category_summary(); |
zgu@3900 | 75 | } |
zgu@3900 | 76 | |
zgu@3900 | 77 | void BaselineReporter::report_callsites(const MemBaseline& baseline) { |
zgu@3900 | 78 | _outputer.start_callsite(); |
zgu@3900 | 79 | MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); |
zgu@3900 | 80 | |
zgu@3900 | 81 | pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_size); |
zgu@3900 | 82 | pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_size); |
zgu@3900 | 83 | |
zgu@3900 | 84 | // walk malloc callsites |
zgu@3900 | 85 | MemPointerArrayIteratorImpl malloc_itr(pBL->_malloc_cs); |
zgu@3900 | 86 | MallocCallsitePointer* malloc_callsite = |
zgu@3900 | 87 | (MallocCallsitePointer*)malloc_itr.current(); |
zgu@3900 | 88 | while (malloc_callsite != NULL) { |
zgu@3900 | 89 | _outputer.malloc_callsite(malloc_callsite->addr(), |
zgu@3900 | 90 | amount_in_current_scale(malloc_callsite->amount()), malloc_callsite->count()); |
zgu@3900 | 91 | malloc_callsite = (MallocCallsitePointer*)malloc_itr.next(); |
zgu@3900 | 92 | } |
zgu@3900 | 93 | |
zgu@3900 | 94 | // walk virtual memory callsite |
zgu@3900 | 95 | MemPointerArrayIteratorImpl vm_itr(pBL->_vm_cs); |
zgu@3900 | 96 | VMCallsitePointer* vm_callsite = (VMCallsitePointer*)vm_itr.current(); |
zgu@3900 | 97 | while (vm_callsite != NULL) { |
zgu@3900 | 98 | _outputer.virtual_memory_callsite(vm_callsite->addr(), |
zgu@3900 | 99 | amount_in_current_scale(vm_callsite->reserved_amount()), |
zgu@3900 | 100 | amount_in_current_scale(vm_callsite->committed_amount())); |
zgu@3900 | 101 | vm_callsite = (VMCallsitePointer*)vm_itr.next(); |
zgu@3900 | 102 | } |
zgu@3900 | 103 | pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_pc); |
zgu@3900 | 104 | pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_pc); |
zgu@3900 | 105 | _outputer.done_callsite(); |
zgu@3900 | 106 | } |
zgu@3900 | 107 | |
zgu@3900 | 108 | void BaselineReporter::diff_baselines(const MemBaseline& cur, const MemBaseline& prev, |
zgu@3900 | 109 | bool summary_only) { |
zgu@3900 | 110 | assert(MemTracker::is_on(), "Native memory tracking is off"); |
zgu@3900 | 111 | _outputer.start(scale()); |
zgu@3900 | 112 | size_t total_reserved = cur.total_malloc_amount() + cur.total_reserved_amount(); |
zgu@3900 | 113 | size_t total_committed = cur.total_malloc_amount() + cur.total_committed_amount(); |
zgu@3900 | 114 | |
zgu@3900 | 115 | _outputer.diff_total_usage( |
zgu@3900 | 116 | amount_in_current_scale(total_reserved), amount_in_current_scale(total_committed), |
zgu@3900 | 117 | diff_in_current_scale(total_reserved, (prev.total_malloc_amount() + prev.total_reserved_amount())), |
zgu@3900 | 118 | diff_in_current_scale(total_committed, (prev.total_committed_amount() + prev.total_malloc_amount()))); |
zgu@3900 | 119 | |
zgu@3900 | 120 | _outputer.diff_num_of_classes(cur.number_of_classes(), |
zgu@3900 | 121 | diff(cur.number_of_classes(), prev.number_of_classes())); |
zgu@3900 | 122 | _outputer.diff_num_of_threads(cur.number_of_threads(), |
zgu@3900 | 123 | diff(cur.number_of_threads(), prev.number_of_threads())); |
zgu@3900 | 124 | |
zgu@3900 | 125 | diff_summaries(cur, prev); |
zgu@3900 | 126 | if (!summary_only && MemTracker::track_callsite()) { |
zgu@3900 | 127 | diff_callsites(cur, prev); |
zgu@3900 | 128 | } |
zgu@3900 | 129 | _outputer.done(); |
zgu@3900 | 130 | } |
zgu@3900 | 131 | |
zgu@3900 | 132 | void BaselineReporter::diff_summaries(const MemBaseline& cur, const MemBaseline& prev) { |
zgu@3900 | 133 | _outputer.start_category_summary(); |
zgu@3900 | 134 | MEMFLAGS type; |
zgu@3900 | 135 | |
zgu@3900 | 136 | for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { |
zgu@3900 | 137 | type = MemBaseline::MemType2NameMap[index]._flag; |
zgu@3900 | 138 | _outputer.diff_category_summary(type, |
zgu@3900 | 139 | amount_in_current_scale(cur.reserved_amount(type)), |
zgu@3900 | 140 | amount_in_current_scale(cur.committed_amount(type)), |
zgu@3900 | 141 | amount_in_current_scale(cur.malloc_amount(type)), |
zgu@3900 | 142 | cur.malloc_count(type), |
zgu@3900 | 143 | amount_in_current_scale(cur.arena_amount(type)), |
zgu@3900 | 144 | cur.arena_count(type), |
zgu@3900 | 145 | diff_in_current_scale(cur.reserved_amount(type), prev.reserved_amount(type)), |
zgu@3900 | 146 | diff_in_current_scale(cur.committed_amount(type), prev.committed_amount(type)), |
zgu@3900 | 147 | diff_in_current_scale(cur.malloc_amount(type), prev.malloc_amount(type)), |
zgu@3900 | 148 | diff(cur.malloc_count(type), prev.malloc_count(type)), |
zgu@3900 | 149 | diff_in_current_scale(cur.arena_amount(type), prev.arena_amount(type)), |
zgu@3900 | 150 | diff(cur.arena_count(type), prev.arena_count(type))); |
zgu@3900 | 151 | } |
zgu@3900 | 152 | |
zgu@3900 | 153 | _outputer.done_category_summary(); |
zgu@3900 | 154 | } |
zgu@3900 | 155 | |
zgu@3900 | 156 | void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) { |
zgu@3900 | 157 | _outputer.start_callsite(); |
zgu@3900 | 158 | MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur); |
zgu@3900 | 159 | MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev); |
zgu@3900 | 160 | |
zgu@3900 | 161 | // walk malloc callsites |
zgu@3900 | 162 | MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs); |
zgu@3900 | 163 | MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs); |
zgu@3900 | 164 | |
zgu@3900 | 165 | MallocCallsitePointer* cur_malloc_callsite = |
zgu@3900 | 166 | (MallocCallsitePointer*)cur_malloc_itr.current(); |
zgu@3900 | 167 | MallocCallsitePointer* prev_malloc_callsite = |
zgu@3900 | 168 | (MallocCallsitePointer*)prev_malloc_itr.current(); |
zgu@3900 | 169 | |
zgu@3900 | 170 | while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) { |
zgu@3900 | 171 | if (prev_malloc_callsite == NULL || |
zgu@3900 | 172 | cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) { |
zgu@3900 | 173 | _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
zgu@3900 | 174 | amount_in_current_scale(cur_malloc_callsite->amount()), |
zgu@3900 | 175 | cur_malloc_callsite->count(), |
zgu@3900 | 176 | diff_in_current_scale(cur_malloc_callsite->amount(), 0), |
zgu@3900 | 177 | diff(cur_malloc_callsite->count(), 0)); |
zgu@3900 | 178 | cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); |
zgu@3900 | 179 | } else if (prev_malloc_callsite == NULL || |
zgu@3900 | 180 | cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) { |
zgu@3900 | 181 | _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
zgu@3900 | 182 | amount_in_current_scale(prev_malloc_callsite->amount()), |
zgu@3900 | 183 | prev_malloc_callsite->count(), |
zgu@3900 | 184 | diff_in_current_scale(0, prev_malloc_callsite->amount()), |
zgu@3900 | 185 | diff(0, prev_malloc_callsite->count())); |
zgu@3900 | 186 | prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); |
zgu@3900 | 187 | } else { // the same callsite |
zgu@3900 | 188 | _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), |
zgu@3900 | 189 | amount_in_current_scale(cur_malloc_callsite->amount()), |
zgu@3900 | 190 | cur_malloc_callsite->count(), |
zgu@3900 | 191 | diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()), |
zgu@3900 | 192 | diff(cur_malloc_callsite->count(), prev_malloc_callsite->count())); |
zgu@3900 | 193 | cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); |
zgu@3900 | 194 | prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); |
zgu@3900 | 195 | } |
zgu@3900 | 196 | } |
zgu@3900 | 197 | |
zgu@3900 | 198 | // walk virtual memory callsite |
zgu@3900 | 199 | MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs); |
zgu@3900 | 200 | MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs); |
zgu@3900 | 201 | VMCallsitePointer* cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current(); |
zgu@3900 | 202 | VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current(); |
zgu@3900 | 203 | while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) { |
zgu@3900 | 204 | if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) { |
zgu@3900 | 205 | _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), |
zgu@3900 | 206 | amount_in_current_scale(cur_vm_callsite->reserved_amount()), |
zgu@3900 | 207 | amount_in_current_scale(cur_vm_callsite->committed_amount()), |
zgu@3900 | 208 | diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0), |
zgu@3900 | 209 | diff_in_current_scale(cur_vm_callsite->committed_amount(), 0)); |
zgu@3900 | 210 | cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); |
zgu@3900 | 211 | } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) { |
zgu@3900 | 212 | _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(), |
zgu@3900 | 213 | amount_in_current_scale(prev_vm_callsite->reserved_amount()), |
zgu@3900 | 214 | amount_in_current_scale(prev_vm_callsite->committed_amount()), |
zgu@3900 | 215 | diff_in_current_scale(0, prev_vm_callsite->reserved_amount()), |
zgu@3900 | 216 | diff_in_current_scale(0, prev_vm_callsite->committed_amount())); |
zgu@3900 | 217 | prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); |
zgu@3900 | 218 | } else { // the same callsite |
zgu@3900 | 219 | _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), |
zgu@3900 | 220 | amount_in_current_scale(cur_vm_callsite->reserved_amount()), |
zgu@3900 | 221 | amount_in_current_scale(cur_vm_callsite->committed_amount()), |
zgu@3900 | 222 | diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()), |
zgu@3900 | 223 | diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount())); |
zgu@3900 | 224 | cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); |
zgu@3900 | 225 | prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); |
zgu@3900 | 226 | } |
zgu@3900 | 227 | } |
zgu@3900 | 228 | |
zgu@3900 | 229 | _outputer.done_callsite(); |
zgu@3900 | 230 | } |
zgu@3900 | 231 | |
zgu@3900 | 232 | size_t BaselineReporter::amount_in_current_scale(size_t amt) const { |
zgu@3900 | 233 | return (size_t)(((float)amt/(float)_scale) + 0.5); |
zgu@3900 | 234 | } |
zgu@3900 | 235 | |
zgu@3900 | 236 | int BaselineReporter::diff_in_current_scale(size_t value1, size_t value2) const { |
zgu@3900 | 237 | return (int)(((float)value1 - (float)value2)/((float)_scale) + 0.5); |
zgu@3900 | 238 | } |
zgu@3900 | 239 | |
zgu@3900 | 240 | int BaselineReporter::diff(size_t value1, size_t value2) const { |
zgu@3900 | 241 | return ((int)value1 - (int)value2); |
zgu@3900 | 242 | } |
zgu@3900 | 243 | |
zgu@3900 | 244 | void BaselineTTYOutputer::start(size_t scale, bool report_diff) { |
zgu@3900 | 245 | _scale = scale; |
zgu@3900 | 246 | _output->print_cr(" "); |
zgu@3900 | 247 | _output->print_cr("Native Memory Tracking:"); |
zgu@3900 | 248 | _output->print_cr(" "); |
zgu@3900 | 249 | } |
zgu@3900 | 250 | |
zgu@3900 | 251 | void BaselineTTYOutputer::done() { |
zgu@3900 | 252 | |
zgu@3900 | 253 | } |
zgu@3900 | 254 | |
zgu@3900 | 255 | void BaselineTTYOutputer::total_usage(size_t total_reserved, size_t total_committed) { |
zgu@3900 | 256 | const char* unit = memory_unit(_scale); |
zgu@3900 | 257 | _output->print_cr("Total: reserved=%d%s, committed=%d%s", |
zgu@3900 | 258 | total_reserved, unit, total_committed, unit); |
zgu@3900 | 259 | } |
zgu@3900 | 260 | |
zgu@3900 | 261 | void BaselineTTYOutputer::start_category_summary() { |
zgu@3900 | 262 | _output->print_cr(" "); |
zgu@3900 | 263 | } |
zgu@3900 | 264 | |
zgu@3900 | 265 | /** |
zgu@3900 | 266 | * report a summary of memory type |
zgu@3900 | 267 | */ |
zgu@3900 | 268 | void BaselineTTYOutputer::category_summary(MEMFLAGS type, |
zgu@3900 | 269 | size_t reserved_amt, size_t committed_amt, size_t malloc_amt, |
zgu@3900 | 270 | size_t malloc_count, size_t arena_amt, size_t arena_count) { |
zgu@3900 | 271 | |
zgu@3900 | 272 | // we report mtThreadStack under mtThread category |
zgu@3900 | 273 | if (type == mtThreadStack) { |
zgu@3900 | 274 | assert(malloc_amt == 0 && malloc_count == 0 && arena_amt == 0, |
zgu@3900 | 275 | "Just check"); |
zgu@3900 | 276 | _thread_stack_reserved = reserved_amt; |
zgu@3900 | 277 | _thread_stack_committed = committed_amt; |
zgu@3900 | 278 | } else { |
zgu@3900 | 279 | const char* unit = memory_unit(_scale); |
zgu@3900 | 280 | size_t total_reserved = (reserved_amt + malloc_amt + arena_amt); |
zgu@3900 | 281 | size_t total_committed = (committed_amt + malloc_amt + arena_amt); |
zgu@3900 | 282 | if (type == mtThread) { |
zgu@3900 | 283 | total_reserved += _thread_stack_reserved; |
zgu@3900 | 284 | total_committed += _thread_stack_committed; |
zgu@3900 | 285 | } |
zgu@3900 | 286 | |
zgu@3900 | 287 | if (total_reserved > 0) { |
zgu@3900 | 288 | _output->print_cr("-%26s (reserved=%d%s, committed=%d%s)", |
zgu@3900 | 289 | MemBaseline::type2name(type), total_reserved, unit, |
zgu@3900 | 290 | total_committed, unit); |
zgu@3900 | 291 | |
zgu@3900 | 292 | if (type == mtClass) { |
zgu@3900 | 293 | _output->print_cr("%27s (classes #%d)", " ", _num_of_classes); |
zgu@3900 | 294 | } else if (type == mtThread) { |
zgu@3900 | 295 | _output->print_cr("%27s (thread #%d)", " ", _num_of_threads); |
zgu@3900 | 296 | _output->print_cr("%27s (stack: reserved=%d%s, committed=%d%s)", " ", |
zgu@3900 | 297 | _thread_stack_reserved, unit, _thread_stack_committed, unit); |
zgu@3900 | 298 | } |
zgu@3900 | 299 | |
zgu@3900 | 300 | if (malloc_amt > 0) { |
zgu@3900 | 301 | if (type != mtChunk) { |
zgu@3900 | 302 | _output->print_cr("%27s (malloc=%d%s, #%d)", " ", malloc_amt, unit, |
zgu@3900 | 303 | malloc_count); |
zgu@3900 | 304 | } else { |
zgu@3900 | 305 | _output->print_cr("%27s (malloc=%d%s)", " ", malloc_amt, unit); |
zgu@3900 | 306 | } |
zgu@3900 | 307 | } |
zgu@3900 | 308 | |
zgu@3900 | 309 | if (reserved_amt > 0) { |
zgu@3900 | 310 | _output->print_cr("%27s (mmap: reserved=%d%s, committed=%d%s)", |
zgu@3900 | 311 | " ", reserved_amt, unit, committed_amt, unit); |
zgu@3900 | 312 | } |
zgu@3900 | 313 | |
zgu@3900 | 314 | if (arena_amt > 0) { |
zgu@3900 | 315 | _output->print_cr("%27s (arena=%d%s, #%d)", " ", arena_amt, unit, arena_count); |
zgu@3900 | 316 | } |
zgu@3900 | 317 | |
zgu@3900 | 318 | _output->print_cr(" "); |
zgu@3900 | 319 | } |
zgu@3900 | 320 | } |
zgu@3900 | 321 | } |
zgu@3900 | 322 | |
zgu@3900 | 323 | void BaselineTTYOutputer::done_category_summary() { |
zgu@3900 | 324 | _output->print_cr(" "); |
zgu@3900 | 325 | } |
zgu@3900 | 326 | |
zgu@3900 | 327 | void BaselineTTYOutputer::start_callsite() { |
zgu@3900 | 328 | _output->print_cr("Details:"); |
zgu@3900 | 329 | _output->print_cr(" "); |
zgu@3900 | 330 | } |
zgu@3900 | 331 | |
zgu@3900 | 332 | void BaselineTTYOutputer::done_callsite() { |
zgu@3900 | 333 | _output->print_cr(" "); |
zgu@3900 | 334 | } |
zgu@3900 | 335 | |
zgu@3900 | 336 | void BaselineTTYOutputer::malloc_callsite(address pc, size_t malloc_amt, |
zgu@3900 | 337 | size_t malloc_count) { |
zgu@3900 | 338 | if (malloc_amt > 0) { |
zgu@3900 | 339 | const char* unit = memory_unit(_scale); |
zgu@3900 | 340 | char buf[64]; |
zgu@3900 | 341 | int offset; |
zgu@3900 | 342 | if (pc == 0) { |
zgu@3900 | 343 | _output->print("[BOOTSTRAP]%18s", " "); |
zgu@3900 | 344 | } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
zgu@3900 | 345 | _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); |
zgu@3900 | 346 | _output->print("%28s", " "); |
zgu@3900 | 347 | } else { |
zgu@3900 | 348 | _output->print("[" PTR_FORMAT "]%18s", pc, " "); |
zgu@3900 | 349 | } |
zgu@3900 | 350 | |
zgu@3900 | 351 | _output->print_cr("(malloc=%d%s #%d)", malloc_amt, unit, malloc_count); |
zgu@3900 | 352 | _output->print_cr(" "); |
zgu@3900 | 353 | } |
zgu@3900 | 354 | } |
zgu@3900 | 355 | |
zgu@3900 | 356 | void BaselineTTYOutputer::virtual_memory_callsite(address pc, size_t reserved_amt, |
zgu@3900 | 357 | size_t committed_amt) { |
zgu@3900 | 358 | if (reserved_amt > 0) { |
zgu@3900 | 359 | const char* unit = memory_unit(_scale); |
zgu@3900 | 360 | char buf[64]; |
zgu@3900 | 361 | int offset; |
zgu@3900 | 362 | if (pc == 0) { |
zgu@3900 | 363 | _output->print("[BOOTSTRAP]%18s", " "); |
zgu@3900 | 364 | } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
zgu@3900 | 365 | _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); |
zgu@3900 | 366 | _output->print("%28s", " "); |
zgu@3900 | 367 | } else { |
zgu@3900 | 368 | _output->print("[" PTR_FORMAT "]%18s", " "); |
zgu@3900 | 369 | } |
zgu@3900 | 370 | |
zgu@3900 | 371 | _output->print_cr("(mmap: reserved=%d%s, committed=%d%s)", |
zgu@3900 | 372 | reserved_amt, unit, committed_amt, unit); |
zgu@3900 | 373 | _output->print_cr(" "); |
zgu@3900 | 374 | } |
zgu@3900 | 375 | } |
zgu@3900 | 376 | |
zgu@3900 | 377 | void BaselineTTYOutputer::diff_total_usage(size_t total_reserved, |
zgu@3900 | 378 | size_t total_committed, int reserved_diff, int committed_diff) { |
zgu@3900 | 379 | const char* unit = memory_unit(_scale); |
zgu@3900 | 380 | _output->print_cr("Total: reserved=%d%s %+d%s, committed=%d%s %+d%s", |
zgu@3900 | 381 | total_reserved, unit, reserved_diff, unit, total_committed, unit, |
zgu@3900 | 382 | committed_diff, unit); |
zgu@3900 | 383 | } |
zgu@3900 | 384 | |
zgu@3900 | 385 | void BaselineTTYOutputer::diff_category_summary(MEMFLAGS type, |
zgu@3900 | 386 | size_t cur_reserved_amt, size_t cur_committed_amt, |
zgu@3900 | 387 | size_t cur_malloc_amt, size_t cur_malloc_count, |
zgu@3900 | 388 | size_t cur_arena_amt, size_t cur_arena_count, |
zgu@3900 | 389 | int reserved_diff, int committed_diff, int malloc_diff, |
zgu@3900 | 390 | int malloc_count_diff, int arena_diff, int arena_count_diff) { |
zgu@3900 | 391 | |
zgu@3900 | 392 | if (type == mtThreadStack) { |
zgu@3900 | 393 | assert(cur_malloc_amt == 0 && cur_malloc_count == 0 && |
zgu@3900 | 394 | cur_arena_amt == 0, "Just check"); |
zgu@3900 | 395 | _thread_stack_reserved = cur_reserved_amt; |
zgu@3900 | 396 | _thread_stack_committed = cur_committed_amt; |
zgu@3900 | 397 | _thread_stack_reserved_diff = reserved_diff; |
zgu@3900 | 398 | _thread_stack_committed_diff = committed_diff; |
zgu@3900 | 399 | } else { |
zgu@3900 | 400 | const char* unit = memory_unit(_scale); |
zgu@3900 | 401 | size_t total_reserved = (cur_reserved_amt + cur_malloc_amt + cur_arena_amt); |
zgu@3900 | 402 | // nothing to report in this category |
zgu@3900 | 403 | if (total_reserved == 0) { |
zgu@3900 | 404 | return; |
zgu@3900 | 405 | } |
zgu@3900 | 406 | int diff_reserved = (reserved_diff + malloc_diff + arena_diff); |
zgu@3900 | 407 | |
zgu@3900 | 408 | // category summary |
zgu@3900 | 409 | _output->print("-%26s (reserved=%d%s", MemBaseline::type2name(type), |
zgu@3900 | 410 | total_reserved, unit); |
zgu@3900 | 411 | |
zgu@3900 | 412 | if (diff_reserved != 0) { |
zgu@3900 | 413 | _output->print(" %+d%s", diff_reserved, unit); |
zgu@3900 | 414 | } |
zgu@3900 | 415 | |
zgu@3900 | 416 | size_t total_committed = cur_committed_amt + cur_malloc_amt + cur_arena_amt; |
zgu@3900 | 417 | _output->print(", committed=%d%s", total_committed, unit); |
zgu@3900 | 418 | |
zgu@3900 | 419 | int total_committed_diff = committed_diff + malloc_diff + arena_diff; |
zgu@3900 | 420 | if (total_committed_diff != 0) { |
zgu@3900 | 421 | _output->print(" %+d%s", total_committed_diff, unit); |
zgu@3900 | 422 | } |
zgu@3900 | 423 | |
zgu@3900 | 424 | _output->print_cr(")"); |
zgu@3900 | 425 | |
zgu@3900 | 426 | // special cases |
zgu@3900 | 427 | if (type == mtClass) { |
zgu@3900 | 428 | _output->print("%27s (classes #%d", " ", _num_of_classes); |
zgu@3900 | 429 | if (_num_of_classes_diff != 0) { |
zgu@3900 | 430 | _output->print(" %+d", _num_of_classes_diff); |
zgu@3900 | 431 | } |
zgu@3900 | 432 | _output->print_cr(")"); |
zgu@3900 | 433 | } else if (type == mtThread) { |
zgu@3900 | 434 | // thread count |
zgu@3900 | 435 | _output->print("%27s (thread #%d", " ", _num_of_threads); |
zgu@3900 | 436 | if (_num_of_threads_diff != 0) { |
zgu@3900 | 437 | _output->print_cr(" %+d)", _num_of_threads_diff); |
zgu@3900 | 438 | } else { |
zgu@3900 | 439 | _output->print_cr(")"); |
zgu@3900 | 440 | } |
zgu@3900 | 441 | _output->print("%27s (stack: reserved=%d%s", " ", _thread_stack_reserved, unit); |
zgu@3900 | 442 | if (_thread_stack_reserved_diff != 0) { |
zgu@3900 | 443 | _output->print(" %+d%s", _thread_stack_reserved_diff, unit); |
zgu@3900 | 444 | } |
zgu@3900 | 445 | |
zgu@3900 | 446 | _output->print(", committed=%d%s", _thread_stack_committed, unit); |
zgu@3900 | 447 | if (_thread_stack_committed_diff != 0) { |
zgu@3900 | 448 | _output->print(" %+d%s",_thread_stack_committed_diff, unit); |
zgu@3900 | 449 | } |
zgu@3900 | 450 | |
zgu@3900 | 451 | _output->print_cr(")"); |
zgu@3900 | 452 | } |
zgu@3900 | 453 | |
zgu@3900 | 454 | // malloc'd memory |
zgu@3900 | 455 | if (cur_malloc_amt > 0) { |
zgu@3900 | 456 | _output->print("%27s (malloc=%d%s", " ", cur_malloc_amt, unit); |
zgu@3900 | 457 | if (malloc_diff != 0) { |
zgu@3900 | 458 | _output->print(" %+d%s", malloc_diff, unit); |
zgu@3900 | 459 | } |
zgu@3900 | 460 | if (type != mtChunk) { |
zgu@3900 | 461 | _output->print(", #%d", cur_malloc_count); |
zgu@3900 | 462 | if (malloc_count_diff) { |
zgu@3900 | 463 | _output->print(" %+d", malloc_count_diff); |
zgu@3900 | 464 | } |
zgu@3900 | 465 | } |
zgu@3900 | 466 | _output->print_cr(")"); |
zgu@3900 | 467 | } |
zgu@3900 | 468 | |
zgu@3900 | 469 | // mmap'd memory |
zgu@3900 | 470 | if (cur_reserved_amt > 0) { |
zgu@3900 | 471 | _output->print("%27s (mmap: reserved=%d%s", " ", cur_reserved_amt, unit); |
zgu@3900 | 472 | if (reserved_diff != 0) { |
zgu@3900 | 473 | _output->print(" %+d%s", reserved_diff, unit); |
zgu@3900 | 474 | } |
zgu@3900 | 475 | |
zgu@3900 | 476 | _output->print(", committed=%d%s", cur_committed_amt, unit); |
zgu@3900 | 477 | if (committed_diff != 0) { |
zgu@3900 | 478 | _output->print(" %+d%s", committed_diff, unit); |
zgu@3900 | 479 | } |
zgu@3900 | 480 | _output->print_cr(")"); |
zgu@3900 | 481 | } |
zgu@3900 | 482 | |
zgu@3900 | 483 | // arena memory |
zgu@3900 | 484 | if (cur_arena_amt > 0) { |
zgu@3900 | 485 | _output->print("%27s (arena=%d%s", " ", cur_arena_amt, unit); |
zgu@3900 | 486 | if (arena_diff != 0) { |
zgu@3900 | 487 | _output->print(" %+d%s", arena_diff, unit); |
zgu@3900 | 488 | } |
zgu@3900 | 489 | _output->print(", #%d", cur_arena_count); |
zgu@3900 | 490 | if (arena_count_diff != 0) { |
zgu@3900 | 491 | _output->print(" %+d", arena_count_diff); |
zgu@3900 | 492 | } |
zgu@3900 | 493 | _output->print_cr(")"); |
zgu@3900 | 494 | } |
zgu@3900 | 495 | |
zgu@3900 | 496 | _output->print_cr(" "); |
zgu@3900 | 497 | } |
zgu@3900 | 498 | } |
zgu@3900 | 499 | |
zgu@3900 | 500 | void BaselineTTYOutputer::diff_malloc_callsite(address pc, |
zgu@3900 | 501 | size_t cur_malloc_amt, size_t cur_malloc_count, |
zgu@3900 | 502 | int malloc_diff, int malloc_count_diff) { |
zgu@3900 | 503 | if (malloc_diff != 0) { |
zgu@3900 | 504 | const char* unit = memory_unit(_scale); |
zgu@3900 | 505 | char buf[64]; |
zgu@3900 | 506 | int offset; |
zgu@3900 | 507 | if (pc == 0) { |
zgu@3900 | 508 | _output->print_cr("[BOOTSTRAP]%18s", " "); |
zgu@3900 | 509 | } else { |
zgu@3900 | 510 | if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
zgu@3900 | 511 | _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); |
zgu@3900 | 512 | _output->print("%28s", " "); |
zgu@3900 | 513 | } else { |
zgu@3900 | 514 | _output->print("[" PTR_FORMAT "]%18s", pc, " "); |
zgu@3900 | 515 | } |
zgu@3900 | 516 | } |
zgu@3900 | 517 | |
zgu@3900 | 518 | _output->print("(malloc=%d%s", cur_malloc_amt, unit); |
zgu@3900 | 519 | if (malloc_diff != 0) { |
zgu@3900 | 520 | _output->print(" %+d%s", malloc_diff, unit); |
zgu@3900 | 521 | } |
zgu@3900 | 522 | _output->print(", #%d", cur_malloc_count); |
zgu@3900 | 523 | if (malloc_count_diff != 0) { |
zgu@3900 | 524 | _output->print(" %+d", malloc_count_diff); |
zgu@3900 | 525 | } |
zgu@3900 | 526 | _output->print_cr(")"); |
zgu@3900 | 527 | _output->print_cr(" "); |
zgu@3900 | 528 | } |
zgu@3900 | 529 | } |
zgu@3900 | 530 | |
zgu@3900 | 531 | void BaselineTTYOutputer::diff_virtual_memory_callsite(address pc, |
zgu@3900 | 532 | size_t cur_reserved_amt, size_t cur_committed_amt, |
zgu@3900 | 533 | int reserved_diff, int committed_diff) { |
zgu@3900 | 534 | if (reserved_diff != 0 || committed_diff != 0) { |
zgu@3900 | 535 | const char* unit = memory_unit(_scale); |
zgu@3900 | 536 | char buf[64]; |
zgu@3900 | 537 | int offset; |
zgu@3900 | 538 | if (pc == 0) { |
zgu@3900 | 539 | _output->print_cr("[BOOSTRAP]%18s", " "); |
zgu@3900 | 540 | } else { |
zgu@3900 | 541 | if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { |
zgu@3900 | 542 | _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); |
zgu@3900 | 543 | _output->print("%28s", " "); |
zgu@3900 | 544 | } else { |
zgu@3900 | 545 | _output->print("[" PTR_FORMAT "]%18s", " "); |
zgu@3900 | 546 | } |
zgu@3900 | 547 | } |
zgu@3900 | 548 | |
zgu@3900 | 549 | _output->print("(mmap: reserved=%d%s", cur_reserved_amt, unit); |
zgu@3900 | 550 | if (reserved_diff != 0) { |
zgu@3900 | 551 | _output->print(" %+d%s", reserved_diff, unit); |
zgu@3900 | 552 | } |
zgu@3900 | 553 | _output->print(", committed=%d%s", cur_committed_amt, unit); |
zgu@3900 | 554 | if (committed_diff != 0) { |
zgu@3900 | 555 | _output->print(" %+d%s", committed_diff, unit); |
zgu@3900 | 556 | } |
zgu@3900 | 557 | _output->print_cr(")"); |
zgu@3900 | 558 | _output->print_cr(" "); |
zgu@3900 | 559 | } |
zgu@3900 | 560 | } |