memReporter.cpp revision 3758:716c64bda5ba
1155192Srwatson/* 2155192Srwatson * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. 3155406Srwatson * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4155192Srwatson * 5155192Srwatson * This code is free software; you can redistribute it and/or modify it 6155192Srwatson * under the terms of the GNU General Public License version 2 only, as 7155192Srwatson * published by the Free Software Foundation. 8155192Srwatson * 9155192Srwatson * This code is distributed in the hope that it will be useful, but WITHOUT 10155192Srwatson * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11155192Srwatson * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12155192Srwatson * version 2 for more details (a copy is included in the LICENSE file that 13155192Srwatson * accompanied this code). 14155192Srwatson * 15155192Srwatson * You should have received a copy of the GNU General Public License version 16155192Srwatson * 2 along with this work; if not, write to the Free Software Foundation, 17155192Srwatson * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18155192Srwatson * 19155192Srwatson * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20155192Srwatson * or visit www.oracle.com if you need additional information or have any 21155192Srwatson * questions. 22155192Srwatson * 23155192Srwatson */ 24155192Srwatson#include "precompiled.hpp" 25155192Srwatson#include "classfile/systemDictionary.hpp" 26155192Srwatson#include "runtime/os.hpp" 27155192Srwatson#include "services/memReporter.hpp" 28155192Srwatson#include "services/memPtrArray.hpp" 29155192Srwatson#include "services/memTracker.hpp" 30155192Srwatson 31155192Srwatsonconst char* BaselineOutputer::memory_unit(size_t scale) { 32155192Srwatson switch(scale) { 33155192Srwatson case K: return "KB"; 34155192Srwatson case M: return "MB"; 35155192Srwatson case G: return "GB"; 36155192Srwatson } 37155192Srwatson ShouldNotReachHere(); 38155192Srwatson return NULL; 39155192Srwatson} 40155192Srwatson 41155192Srwatson 42155192Srwatsonvoid BaselineReporter::report_baseline(const MemBaseline& baseline, bool summary_only) { 43155192Srwatson assert(MemTracker::is_on(), "Native memory tracking is off"); 44155192Srwatson _outputer.start(scale()); 45155192Srwatson _outputer.total_usage( 46155192Srwatson amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_reserved_amount()), 47155192Srwatson amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_committed_amount())); 48155192Srwatson 49155192Srwatson _outputer.num_of_classes(baseline.number_of_classes()); 50155192Srwatson _outputer.num_of_threads(baseline.number_of_threads()); 51155192Srwatson 52155192Srwatson report_summaries(baseline); 53155192Srwatson if (!summary_only && MemTracker::track_callsite()) { 54155192Srwatson report_virtual_memory_map(baseline); 55155192Srwatson report_callsites(baseline); 56155192Srwatson } 57155192Srwatson _outputer.done(); 58155192Srwatson} 59155192Srwatson 60155406Srwatsonvoid BaselineReporter::report_summaries(const MemBaseline& baseline) { 61156291Srwatson _outputer.start_category_summary(); 62155406Srwatson MEMFLAGS type; 63155406Srwatson 64155192Srwatson for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { 65155192Srwatson type = MemBaseline::MemType2NameMap[index]._flag; 66155192Srwatson _outputer.category_summary(type, 67155192Srwatson amount_in_current_scale(baseline.reserved_amount(type)), 68155192Srwatson amount_in_current_scale(baseline.committed_amount(type)), 69155192Srwatson amount_in_current_scale(baseline.malloc_amount(type)), 70155406Srwatson baseline.malloc_count(type), 71155406Srwatson amount_in_current_scale(baseline.arena_amount(type)), 72156888Srwatson baseline.arena_count(type)); 73155192Srwatson } 74155192Srwatson 75155192Srwatson _outputer.done_category_summary(); 76155192Srwatson} 77155192Srwatson 78155192Srwatsonvoid BaselineReporter::report_virtual_memory_map(const MemBaseline& baseline) { 79156889Srwatson _outputer.start_virtual_memory_map(); 80155192Srwatson MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); 81155192Srwatson MemPointerArrayIteratorImpl itr = MemPointerArrayIteratorImpl(pBL->_vm_map); 82156889Srwatson VMMemRegionEx* rgn = (VMMemRegionEx*)itr.current(); 83155192Srwatson while (rgn != NULL) { 84155192Srwatson if (rgn->is_reserved_region()) { 85156889Srwatson _outputer.reserved_memory_region(FLAGS_TO_MEMORY_TYPE(rgn->flags()), 86156889Srwatson rgn->base(), rgn->base() + rgn->size(), amount_in_current_scale(rgn->size()), rgn->pc()); 87155192Srwatson } else { 88155192Srwatson _outputer.committed_memory_region(rgn->base(), rgn->base() + rgn->size(), 89155192Srwatson amount_in_current_scale(rgn->size()), rgn->pc()); 90155192Srwatson } 91155192Srwatson rgn = (VMMemRegionEx*)itr.next(); 92155192Srwatson } 93156889Srwatson 94156889Srwatson _outputer.done_virtual_memory_map(); 95155192Srwatson} 96155192Srwatson 97155192Srwatsonvoid BaselineReporter::report_callsites(const MemBaseline& baseline) { 98155192Srwatson _outputer.start_callsite(); 99156889Srwatson MemBaseline* pBL = const_cast<MemBaseline*>(&baseline); 100155192Srwatson 101155192Srwatson pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_size); 102156889Srwatson pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_size); 103155192Srwatson 104156889Srwatson // walk malloc callsites 105155192Srwatson MemPointerArrayIteratorImpl malloc_itr(pBL->_malloc_cs); 106155192Srwatson MallocCallsitePointer* malloc_callsite = 107155192Srwatson (MallocCallsitePointer*)malloc_itr.current(); 108155192Srwatson while (malloc_callsite != NULL) { 109156889Srwatson _outputer.malloc_callsite(malloc_callsite->addr(), 110155192Srwatson amount_in_current_scale(malloc_callsite->amount()), malloc_callsite->count()); 111155192Srwatson malloc_callsite = (MallocCallsitePointer*)malloc_itr.next(); 112155192Srwatson } 113155192Srwatson 114155192Srwatson // walk virtual memory callsite 115156889Srwatson MemPointerArrayIteratorImpl vm_itr(pBL->_vm_cs); 116155192Srwatson VMCallsitePointer* vm_callsite = (VMCallsitePointer*)vm_itr.current(); 117155192Srwatson while (vm_callsite != NULL) { 118155192Srwatson _outputer.virtual_memory_callsite(vm_callsite->addr(), 119155192Srwatson amount_in_current_scale(vm_callsite->reserved_amount()), 120155192Srwatson amount_in_current_scale(vm_callsite->committed_amount())); 121155192Srwatson vm_callsite = (VMCallsitePointer*)vm_itr.next(); 122155192Srwatson } 123155192Srwatson pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_pc); 124155192Srwatson pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_pc); 125156889Srwatson _outputer.done_callsite(); 126156889Srwatson} 127156889Srwatson 128155192Srwatsonvoid BaselineReporter::diff_baselines(const MemBaseline& cur, const MemBaseline& prev, 129155192Srwatson bool summary_only) { 130155192Srwatson assert(MemTracker::is_on(), "Native memory tracking is off"); 131155192Srwatson _outputer.start(scale()); 132156889Srwatson size_t total_reserved = cur.total_malloc_amount() + cur.total_reserved_amount(); 133155192Srwatson size_t total_committed = cur.total_malloc_amount() + cur.total_committed_amount(); 134155192Srwatson 135155192Srwatson _outputer.diff_total_usage( 136155192Srwatson amount_in_current_scale(total_reserved), amount_in_current_scale(total_committed), 137155192Srwatson diff_in_current_scale(total_reserved, (prev.total_malloc_amount() + prev.total_reserved_amount())), 138155192Srwatson diff_in_current_scale(total_committed, (prev.total_committed_amount() + prev.total_malloc_amount()))); 139159261Srwatson 140155192Srwatson _outputer.diff_num_of_classes(cur.number_of_classes(), 141155192Srwatson diff(cur.number_of_classes(), prev.number_of_classes())); 142159261Srwatson _outputer.diff_num_of_threads(cur.number_of_threads(), 143159261Srwatson diff(cur.number_of_threads(), prev.number_of_threads())); 144159261Srwatson 145155192Srwatson diff_summaries(cur, prev); 146159261Srwatson if (!summary_only && MemTracker::track_callsite()) { 147155192Srwatson diff_callsites(cur, prev); 148156889Srwatson } 149156889Srwatson _outputer.done(); 150156889Srwatson} 151155192Srwatson 152155192Srwatsonvoid BaselineReporter::diff_summaries(const MemBaseline& cur, const MemBaseline& prev) { 153156889Srwatson _outputer.start_category_summary(); 154155192Srwatson MEMFLAGS type; 155155192Srwatson 156155406Srwatson for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { 157155192Srwatson type = MemBaseline::MemType2NameMap[index]._flag; 158155406Srwatson _outputer.diff_category_summary(type, 159155406Srwatson amount_in_current_scale(cur.reserved_amount(type)), 160155406Srwatson amount_in_current_scale(cur.committed_amount(type)), 161155406Srwatson amount_in_current_scale(cur.malloc_amount(type)), 162155406Srwatson cur.malloc_count(type), 163155406Srwatson amount_in_current_scale(cur.arena_amount(type)), 164155406Srwatson cur.arena_count(type), 165155406Srwatson diff_in_current_scale(cur.reserved_amount(type), prev.reserved_amount(type)), 166155406Srwatson diff_in_current_scale(cur.committed_amount(type), prev.committed_amount(type)), 167155406Srwatson diff_in_current_scale(cur.malloc_amount(type), prev.malloc_amount(type)), 168155406Srwatson diff(cur.malloc_count(type), prev.malloc_count(type)), 169155406Srwatson diff_in_current_scale(cur.arena_amount(type), prev.arena_amount(type)), 170155406Srwatson diff(cur.arena_count(type), prev.arena_count(type))); 171155406Srwatson } 172155406Srwatson 173155406Srwatson _outputer.done_category_summary(); 174155406Srwatson} 175155406Srwatson 176155406Srwatsonvoid BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) { 177155406Srwatson _outputer.start_callsite(); 178155406Srwatson MemBaseline* pBL_cur = const_cast<MemBaseline*>(&cur); 179155406Srwatson MemBaseline* pBL_prev = const_cast<MemBaseline*>(&prev); 180155406Srwatson 181155406Srwatson // walk malloc callsites 182155406Srwatson MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs); 183155406Srwatson MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs); 184155406Srwatson 185155406Srwatson MallocCallsitePointer* cur_malloc_callsite = 186155406Srwatson (MallocCallsitePointer*)cur_malloc_itr.current(); 187155406Srwatson MallocCallsitePointer* prev_malloc_callsite = 188155406Srwatson (MallocCallsitePointer*)prev_malloc_itr.current(); 189155406Srwatson 190155406Srwatson while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) { 191155406Srwatson if (prev_malloc_callsite == NULL || 192155192Srwatson cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) { 193155406Srwatson _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), 194155192Srwatson amount_in_current_scale(cur_malloc_callsite->amount()), 195155406Srwatson cur_malloc_callsite->count(), 196155192Srwatson diff_in_current_scale(cur_malloc_callsite->amount(), 0), 197155406Srwatson diff(cur_malloc_callsite->count(), 0)); 198155406Srwatson cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); 199155406Srwatson } else if (prev_malloc_callsite == NULL || 200155406Srwatson cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) { 201155192Srwatson _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), 202155406Srwatson amount_in_current_scale(prev_malloc_callsite->amount()), 203155192Srwatson prev_malloc_callsite->count(), 204155406Srwatson diff_in_current_scale(0, prev_malloc_callsite->amount()), 205155192Srwatson diff(0, prev_malloc_callsite->count())); 206155406Srwatson prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); 207155192Srwatson } else { // the same callsite 208155192Srwatson _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), 209155192Srwatson amount_in_current_scale(cur_malloc_callsite->amount()), 210155192Srwatson cur_malloc_callsite->count(), 211155192Srwatson diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()), 212155192Srwatson diff(cur_malloc_callsite->count(), prev_malloc_callsite->count())); 213155192Srwatson cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); 214155192Srwatson prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); 215155192Srwatson } 216155192Srwatson } 217155192Srwatson 218155192Srwatson // walk virtual memory callsite 219155192Srwatson MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs); 220155192Srwatson MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs); 221155192Srwatson VMCallsitePointer* cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current(); 222155192Srwatson VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current(); 223155192Srwatson while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) { 224155192Srwatson if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) { 225155192Srwatson _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), 226155192Srwatson amount_in_current_scale(cur_vm_callsite->reserved_amount()), 227156889Srwatson amount_in_current_scale(cur_vm_callsite->committed_amount()), 228155192Srwatson diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0), 229155192Srwatson diff_in_current_scale(cur_vm_callsite->committed_amount(), 0)); 230155192Srwatson cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); 231155192Srwatson } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) { 232155192Srwatson _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(), 233155192Srwatson amount_in_current_scale(prev_vm_callsite->reserved_amount()), 234155192Srwatson amount_in_current_scale(prev_vm_callsite->committed_amount()), 235155192Srwatson diff_in_current_scale(0, prev_vm_callsite->reserved_amount()), 236155192Srwatson diff_in_current_scale(0, prev_vm_callsite->committed_amount())); 237155192Srwatson prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); 238155192Srwatson } else { // the same callsite 239155192Srwatson _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), 240159261Srwatson amount_in_current_scale(cur_vm_callsite->reserved_amount()), 241159261Srwatson amount_in_current_scale(cur_vm_callsite->committed_amount()), 242155192Srwatson diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()), 243155192Srwatson diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount())); 244155406Srwatson cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); 245155406Srwatson prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); 246155406Srwatson } 247155406Srwatson } 248155192Srwatson 249155192Srwatson _outputer.done_callsite(); 250155192Srwatson} 251155192Srwatson 252155192Srwatsonsize_t BaselineReporter::amount_in_current_scale(size_t amt) const { 253155192Srwatson return (size_t)(((float)amt/(float)_scale) + 0.5); 254155192Srwatson} 255155192Srwatson 256155192Srwatsonint BaselineReporter::diff_in_current_scale(size_t value1, size_t value2) const { 257156888Srwatson return (int)(((float)value1 - (float)value2)/((float)_scale) + 0.5); 258156888Srwatson} 259155192Srwatson 260155192Srwatsonint BaselineReporter::diff(size_t value1, size_t value2) const { 261155192Srwatson return ((int)value1 - (int)value2); 262155192Srwatson} 263155192Srwatson 264155192Srwatsonvoid BaselineTTYOutputer::start(size_t scale, bool report_diff) { 265155192Srwatson _scale = scale; 266155192Srwatson _output->print_cr(" "); 267155192Srwatson _output->print_cr("Native Memory Tracking:"); 268155192Srwatson _output->print_cr(" "); 269155192Srwatson} 270155192Srwatson 271155192Srwatsonvoid BaselineTTYOutputer::done() { 272155192Srwatson 273155192Srwatson} 274155192Srwatson 275155192Srwatsonvoid BaselineTTYOutputer::total_usage(size_t total_reserved, size_t total_committed) { 276155192Srwatson const char* unit = memory_unit(_scale); 277155192Srwatson _output->print_cr("Total: reserved=%d%s, committed=%d%s", 278155192Srwatson total_reserved, unit, total_committed, unit); 279155192Srwatson} 280155192Srwatson 281155192Srwatsonvoid BaselineTTYOutputer::start_category_summary() { 282155192Srwatson _output->print_cr(" "); 283155192Srwatson} 284155192Srwatson 285155192Srwatson/** 286155192Srwatson * report a summary of memory type 287155192Srwatson */ 288155192Srwatsonvoid BaselineTTYOutputer::category_summary(MEMFLAGS type, 289155192Srwatson size_t reserved_amt, size_t committed_amt, size_t malloc_amt, 290155192Srwatson size_t malloc_count, size_t arena_amt, size_t arena_count) { 291155192Srwatson 292155192Srwatson // we report mtThreadStack under mtThread category 293155192Srwatson if (type == mtThreadStack) { 294155192Srwatson assert(malloc_amt == 0 && malloc_count == 0 && arena_amt == 0, 295155192Srwatson "Just check"); 296155192Srwatson _thread_stack_reserved = reserved_amt; 297155192Srwatson _thread_stack_committed = committed_amt; 298155192Srwatson } else { 299155192Srwatson const char* unit = memory_unit(_scale); 300155192Srwatson size_t total_reserved = (reserved_amt + malloc_amt + arena_amt); 301155406Srwatson size_t total_committed = (committed_amt + malloc_amt + arena_amt); 302155406Srwatson if (type == mtThread) { 303155406Srwatson total_reserved += _thread_stack_reserved; 304155406Srwatson total_committed += _thread_stack_committed; 305155406Srwatson } 306155192Srwatson 307155192Srwatson if (total_reserved > 0) { 308155192Srwatson _output->print_cr("-%26s (reserved=%d%s, committed=%d%s)", 309155406Srwatson MemBaseline::type2name(type), total_reserved, unit, 310155192Srwatson total_committed, unit); 311155192Srwatson 312155406Srwatson if (type == mtClass) { 313155406Srwatson _output->print_cr("%27s (classes #%d)", " ", _num_of_classes); 314155192Srwatson } else if (type == mtThread) { 315155192Srwatson _output->print_cr("%27s (thread #%d)", " ", _num_of_threads); 316155192Srwatson _output->print_cr("%27s (stack: reserved=%d%s, committed=%d%s)", " ", 317155192Srwatson _thread_stack_reserved, unit, _thread_stack_committed, unit); 318155192Srwatson } 319155192Srwatson 320155192Srwatson if (malloc_amt > 0) { 321155192Srwatson if (type != mtChunk) { 322156888Srwatson _output->print_cr("%27s (malloc=%d%s, #%d)", " ", malloc_amt, unit, 323156888Srwatson malloc_count); 324156888Srwatson } else { 325156888Srwatson _output->print_cr("%27s (malloc=%d%s)", " ", malloc_amt, unit); 326156888Srwatson } 327156888Srwatson } 328156888Srwatson 329155192Srwatson if (reserved_amt > 0) { 330155192Srwatson _output->print_cr("%27s (mmap: reserved=%d%s, committed=%d%s)", 331155192Srwatson " ", reserved_amt, unit, committed_amt, unit); 332155192Srwatson } 333155192Srwatson 334155192Srwatson if (arena_amt > 0) { 335155192Srwatson _output->print_cr("%27s (arena=%d%s, #%d)", " ", arena_amt, unit, arena_count); 336155192Srwatson } 337155192Srwatson 338155192Srwatson _output->print_cr(" "); 339155192Srwatson } 340155192Srwatson } 341155192Srwatson} 342155192Srwatson 343155192Srwatsonvoid BaselineTTYOutputer::done_category_summary() { 344155192Srwatson _output->print_cr(" "); 345155192Srwatson} 346155192Srwatson 347155192Srwatson 348155192Srwatsonvoid BaselineTTYOutputer::start_virtual_memory_map() { 349155192Srwatson _output->print_cr("Virtual memory map:"); 350155192Srwatson} 351155192Srwatson 352156889Srwatsonvoid BaselineTTYOutputer::reserved_memory_region(MEMFLAGS type, address base, address end, 353155192Srwatson size_t size, address pc) { 354155192Srwatson const char* unit = memory_unit(_scale); 355155192Srwatson char buf[128]; 356155192Srwatson int offset; 357155192Srwatson _output->print_cr(" "); 358155192Srwatson _output->print_cr("[" PTR_FORMAT " - " PTR_FORMAT "] reserved %d%s for %s", base, end, size, unit, 359155192Srwatson MemBaseline::type2name(type)); 360155192Srwatson if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 361155192Srwatson _output->print_cr("\t\tfrom [%s+0x%x]", buf, offset); 362156889Srwatson } 363155192Srwatson} 364155192Srwatson 365155192Srwatsonvoid BaselineTTYOutputer::committed_memory_region(address base, address end, size_t size, address pc) { 366155192Srwatson const char* unit = memory_unit(_scale); 367155192Srwatson char buf[128]; 368155192Srwatson int offset; 369155192Srwatson _output->print("\t[" PTR_FORMAT " - " PTR_FORMAT "] committed %d%s", base, end, size, unit); 370155192Srwatson if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 371155192Srwatson _output->print_cr(" from [%s+0x%x]", buf, offset); 372155192Srwatson } 373155192Srwatson} 374155192Srwatson 375155192Srwatsonvoid BaselineTTYOutputer::done_virtual_memory_map() { 376155192Srwatson _output->print_cr(" "); 377155192Srwatson} 378155192Srwatson 379155192Srwatson 380155192Srwatson 381155192Srwatsonvoid BaselineTTYOutputer::start_callsite() { 382155192Srwatson _output->print_cr("Details:"); 383155406Srwatson _output->print_cr(" "); 384155406Srwatson} 385155406Srwatson 386155406Srwatsonvoid BaselineTTYOutputer::done_callsite() { 387155192Srwatson _output->print_cr(" "); 388155192Srwatson} 389155192Srwatson 390155192Srwatsonvoid BaselineTTYOutputer::malloc_callsite(address pc, size_t malloc_amt, 391155406Srwatson size_t malloc_count) { 392155192Srwatson if (malloc_amt > 0) { 393155192Srwatson const char* unit = memory_unit(_scale); 394155192Srwatson char buf[128]; 395155192Srwatson int offset; 396155192Srwatson if (pc == 0) { 397155192Srwatson _output->print("[BOOTSTRAP]%18s", " "); 398155192Srwatson } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 399155192Srwatson _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); 400155192Srwatson _output->print("%28s", " "); 401155192Srwatson } else { 402155192Srwatson _output->print("[" PTR_FORMAT "]%18s", pc, " "); 403155192Srwatson } 404155192Srwatson 405155192Srwatson _output->print_cr("(malloc=%d%s #%d)", malloc_amt, unit, malloc_count); 406155192Srwatson _output->print_cr(" "); 407155192Srwatson } 408155192Srwatson} 409155192Srwatson 410155192Srwatsonvoid BaselineTTYOutputer::virtual_memory_callsite(address pc, size_t reserved_amt, 411155192Srwatson size_t committed_amt) { 412155192Srwatson if (reserved_amt > 0) { 413155192Srwatson const char* unit = memory_unit(_scale); 414155192Srwatson char buf[128]; 415155192Srwatson int offset; 416155192Srwatson if (pc == 0) { 417155406Srwatson _output->print("[BOOTSTRAP]%18s", " "); 418155192Srwatson } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 419155192Srwatson _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); 420156889Srwatson _output->print("%28s", " "); 421155192Srwatson } else { 422155192Srwatson _output->print("[" PTR_FORMAT "]%18s", " "); 423155192Srwatson } 424155192Srwatson 425155192Srwatson _output->print_cr("(mmap: reserved=%d%s, committed=%d%s)", 426155192Srwatson reserved_amt, unit, committed_amt, unit); 427155192Srwatson _output->print_cr(" "); 428159261Srwatson } 429155192Srwatson} 430155192Srwatson 431155192Srwatsonvoid BaselineTTYOutputer::diff_total_usage(size_t total_reserved, 432155192Srwatson size_t total_committed, int reserved_diff, int committed_diff) { 433155192Srwatson const char* unit = memory_unit(_scale); 434155192Srwatson _output->print_cr("Total: reserved=%d%s %+d%s, committed=%d%s %+d%s", 435155192Srwatson total_reserved, unit, reserved_diff, unit, total_committed, unit, 436159261Srwatson committed_diff, unit); 437155192Srwatson} 438155192Srwatson 439155192Srwatsonvoid BaselineTTYOutputer::diff_category_summary(MEMFLAGS type, 440155192Srwatson size_t cur_reserved_amt, size_t cur_committed_amt, 441155192Srwatson size_t cur_malloc_amt, size_t cur_malloc_count, 442155192Srwatson size_t cur_arena_amt, size_t cur_arena_count, 443155192Srwatson int reserved_diff, int committed_diff, int malloc_diff, 444155192Srwatson int malloc_count_diff, int arena_diff, int arena_count_diff) { 445155192Srwatson 446155192Srwatson if (type == mtThreadStack) { 447155192Srwatson assert(cur_malloc_amt == 0 && cur_malloc_count == 0 && 448155192Srwatson cur_arena_amt == 0, "Just check"); 449155192Srwatson _thread_stack_reserved = cur_reserved_amt; 450155192Srwatson _thread_stack_committed = cur_committed_amt; 451155192Srwatson _thread_stack_reserved_diff = reserved_diff; 452155192Srwatson _thread_stack_committed_diff = committed_diff; 453155192Srwatson } else { 454155192Srwatson const char* unit = memory_unit(_scale); 455155192Srwatson size_t total_reserved = (cur_reserved_amt + cur_malloc_amt + cur_arena_amt); 456155192Srwatson // nothing to report in this category 457155192Srwatson if (total_reserved == 0) { 458155192Srwatson return; 459155192Srwatson } 460155192Srwatson int diff_reserved = (reserved_diff + malloc_diff + arena_diff); 461155192Srwatson 462155192Srwatson // category summary 463155192Srwatson _output->print("-%26s (reserved=%d%s", MemBaseline::type2name(type), 464155192Srwatson total_reserved, unit); 465155192Srwatson 466155192Srwatson if (diff_reserved != 0) { 467155192Srwatson _output->print(" %+d%s", diff_reserved, unit); 468155192Srwatson } 469155192Srwatson 470155192Srwatson size_t total_committed = cur_committed_amt + cur_malloc_amt + cur_arena_amt; 471155192Srwatson _output->print(", committed=%d%s", total_committed, unit); 472155192Srwatson 473155192Srwatson int total_committed_diff = committed_diff + malloc_diff + arena_diff; 474155192Srwatson if (total_committed_diff != 0) { 475155192Srwatson _output->print(" %+d%s", total_committed_diff, unit); 476155192Srwatson } 477155192Srwatson 478155192Srwatson _output->print_cr(")"); 479156889Srwatson 480155192Srwatson // special cases 481156889Srwatson if (type == mtClass) { 482155192Srwatson _output->print("%27s (classes #%d", " ", _num_of_classes); 483155192Srwatson if (_num_of_classes_diff != 0) { 484155192Srwatson _output->print(" %+d", _num_of_classes_diff); 485155192Srwatson } 486155192Srwatson _output->print_cr(")"); 487155192Srwatson } else if (type == mtThread) { 488155192Srwatson // thread count 489155192Srwatson _output->print("%27s (thread #%d", " ", _num_of_threads); 490155192Srwatson if (_num_of_threads_diff != 0) { 491155192Srwatson _output->print_cr(" %+d)", _num_of_threads_diff); 492155192Srwatson } else { 493155192Srwatson _output->print_cr(")"); 494155192Srwatson } 495155192Srwatson _output->print("%27s (stack: reserved=%d%s", " ", _thread_stack_reserved, unit); 496155192Srwatson if (_thread_stack_reserved_diff != 0) { 497155192Srwatson _output->print(" %+d%s", _thread_stack_reserved_diff, unit); 498155192Srwatson } 499155192Srwatson 500155192Srwatson _output->print(", committed=%d%s", _thread_stack_committed, unit); 501155192Srwatson if (_thread_stack_committed_diff != 0) { 502155192Srwatson _output->print(" %+d%s",_thread_stack_committed_diff, unit); 503155192Srwatson } 504155192Srwatson 505155192Srwatson _output->print_cr(")"); 506155192Srwatson } 507155192Srwatson 508155192Srwatson // malloc'd memory 509155192Srwatson if (cur_malloc_amt > 0) { 510155192Srwatson _output->print("%27s (malloc=%d%s", " ", cur_malloc_amt, unit); 511155192Srwatson if (malloc_diff != 0) { 512155192Srwatson _output->print(" %+d%s", malloc_diff, unit); 513155192Srwatson } 514155192Srwatson if (type != mtChunk) { 515155192Srwatson _output->print(", #%d", cur_malloc_count); 516155192Srwatson if (malloc_count_diff) { 517155192Srwatson _output->print(" %+d", malloc_count_diff); 518155192Srwatson } 519155192Srwatson } 520155192Srwatson _output->print_cr(")"); 521155192Srwatson } 522155192Srwatson 523155192Srwatson // mmap'd memory 524155192Srwatson if (cur_reserved_amt > 0) { 525155192Srwatson _output->print("%27s (mmap: reserved=%d%s", " ", cur_reserved_amt, unit); 526155192Srwatson if (reserved_diff != 0) { 527155192Srwatson _output->print(" %+d%s", reserved_diff, unit); 528155192Srwatson } 529155192Srwatson 530155192Srwatson _output->print(", committed=%d%s", cur_committed_amt, unit); 531155192Srwatson if (committed_diff != 0) { 532156889Srwatson _output->print(" %+d%s", committed_diff, unit); 533155192Srwatson } 534155192Srwatson _output->print_cr(")"); 535155192Srwatson } 536155192Srwatson 537155192Srwatson // arena memory 538155192Srwatson if (cur_arena_amt > 0) { 539155192Srwatson _output->print("%27s (arena=%d%s", " ", cur_arena_amt, unit); 540155192Srwatson if (arena_diff != 0) { 541155192Srwatson _output->print(" %+d%s", arena_diff, unit); 542155192Srwatson } 543155192Srwatson _output->print(", #%d", cur_arena_count); 544155192Srwatson if (arena_count_diff != 0) { 545155192Srwatson _output->print(" %+d", arena_count_diff); 546155192Srwatson } 547155192Srwatson _output->print_cr(")"); 548155192Srwatson } 549155192Srwatson 550155192Srwatson _output->print_cr(" "); 551155192Srwatson } 552155195Srwatson} 553155195Srwatson 554155195Srwatsonvoid BaselineTTYOutputer::diff_malloc_callsite(address pc, 555155195Srwatson size_t cur_malloc_amt, size_t cur_malloc_count, 556155195Srwatson int malloc_diff, int malloc_count_diff) { 557155195Srwatson if (malloc_diff != 0) { 558155195Srwatson const char* unit = memory_unit(_scale); 559155195Srwatson char buf[128]; 560155195Srwatson int offset; 561155195Srwatson if (pc == 0) { 562155353Srwatson _output->print_cr("[BOOTSTRAP]%18s", " "); 563155353Srwatson } else { 564155353Srwatson if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 565155353Srwatson _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); 566155353Srwatson _output->print("%28s", " "); 567155353Srwatson } else { 568155353Srwatson _output->print("[" PTR_FORMAT "]%18s", pc, " "); 569155353Srwatson } 570155353Srwatson } 571155353Srwatson 572156889Srwatson _output->print("(malloc=%d%s", cur_malloc_amt, unit); 573156889Srwatson if (malloc_diff != 0) { 574155192Srwatson _output->print(" %+d%s", malloc_diff, unit); 575156889Srwatson } 576156889Srwatson _output->print(", #%d", cur_malloc_count); 577155192Srwatson if (malloc_count_diff != 0) { 578155192Srwatson _output->print(" %+d", malloc_count_diff); 579155192Srwatson } 580155192Srwatson _output->print_cr(")"); 581155192Srwatson _output->print_cr(" "); 582155192Srwatson } 583155192Srwatson} 584155192Srwatson 585155192Srwatsonvoid BaselineTTYOutputer::diff_virtual_memory_callsite(address pc, 586155192Srwatson size_t cur_reserved_amt, size_t cur_committed_amt, 587155192Srwatson int reserved_diff, int committed_diff) { 588155192Srwatson if (reserved_diff != 0 || committed_diff != 0) { 589155192Srwatson const char* unit = memory_unit(_scale); 590155192Srwatson char buf[64]; 591155192Srwatson int offset; 592155192Srwatson if (pc == 0) { 593155192Srwatson _output->print_cr("[BOOSTRAP]%18s", " "); 594155192Srwatson } else { 595155192Srwatson if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { 596155558Srwatson _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); 597155192Srwatson _output->print("%28s", " "); 598155192Srwatson } else { 599156889Srwatson _output->print("[" PTR_FORMAT "]%18s", " "); 600155192Srwatson } 601155192Srwatson } 602155192Srwatson 603155192Srwatson _output->print("(mmap: reserved=%d%s", cur_reserved_amt, unit); 604155192Srwatson if (reserved_diff != 0) { 605155192Srwatson _output->print(" %+d%s", reserved_diff, unit); 606155192Srwatson } 607155192Srwatson _output->print(", committed=%d%s", cur_committed_amt, unit); 608155192Srwatson if (committed_diff != 0) { 609155192Srwatson _output->print(" %+d%s", committed_diff, unit); 610155192Srwatson } 611155192Srwatson _output->print_cr(")"); 612155192Srwatson _output->print_cr(" "); 613155192Srwatson } 614155192Srwatson} 615155192Srwatson