< prev index next >

src/hotspot/share/compiler/compileBroker.cpp

Print this page
rev 49260 : [mq]: 8198691.patch

*** 1,7 **** /* ! * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. --- 1,7 ---- /* ! * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.
*** 26,35 **** --- 26,36 ---- #include "jvm.h" #include "classfile/symbolTable.hpp" #include "classfile/systemDictionary.hpp" #include "classfile/vmSymbols.hpp" #include "code/codeCache.hpp" + #include "code/codeHeapState.hpp" #include "code/dependencyContext.hpp" #include "compiler/compileBroker.hpp" #include "compiler/compileLog.hpp" #include "compiler/compilerOracle.hpp" #include "compiler/directivesParser.hpp"
*** 2420,2424 **** --- 2421,2522 ---- tty->print_cr("Last parse: %d+++(%d) %s", _compilation_id, _last_compile_level, _last_method_compiled); } } } + + // Print general/accumulated JIT information. + void CompileBroker::print_info(outputStream *out) { + if (out == NULL) out = tty; + out->cr(); + out->print_cr("======================"); + out->print_cr(" General JIT info "); + out->print_cr("======================"); + out->cr(); + out->print_cr(" JIT is : %7s", should_compile_new_jobs() ? "on" : "off"); + out->print_cr(" Compiler threads : %7d", (int)CICompilerCount); + out->cr(); + out->print_cr("CodeCache overview"); + out->print_cr("--------------------------------------------------------"); + out->cr(); + out->print_cr(" Reserved size : " SIZE_FORMAT_W(7) " KB", CodeCache::max_capacity() / K); + out->print_cr(" Committed size : " SIZE_FORMAT_W(7) " KB", CodeCache::capacity() / K); + out->print_cr(" Unallocated capacity : " SIZE_FORMAT_W(7) " KB", CodeCache::unallocated_capacity() / K); + out->cr(); + + out->cr(); + out->print_cr("CodeCache cleaning overview"); + out->print_cr("--------------------------------------------------------"); + out->cr(); + NMethodSweeper::print(out); + out->print_cr("--------------------------------------------------------"); + out->cr(); + } + + void CompileBroker::print_heapinfo(outputStream* out, const char* function, const char* granularity) { + TimeStamp ts_total; + TimeStamp ts; + + bool allFun = !strcmp(function, "all"); + bool aggregate = !strcmp(function, "aggregate") || !strcmp(function, "analyze") || allFun; + bool usedSpace = !strcmp(function, "UsedSpace") || allFun; + bool freeSpace = !strcmp(function, "FreeSpace") || allFun; + bool methodCount = !strcmp(function, "MethodCount") || allFun; + bool methodSpace = !strcmp(function, "MethodSpace") || allFun; + bool methodAge = !strcmp(function, "MethodAge") || allFun; + bool methodNames = !strcmp(function, "MethodNames") || allFun; + bool discard = !strcmp(function, "discard") || allFun; + + if (out == NULL) { + out = tty; + } + + if (!(aggregate || usedSpace || freeSpace || methodCount || methodSpace || methodAge || methodNames || discard)) { + out->print_cr("\n__ CodeHeapStateAnalytics: Function %s is not supported", function); + out->cr(); + return; + } + + ts_total.update(); // record starting point + + if (aggregate) { + print_info(out); + } + + ts.update(); // record starting point + MutexLockerEx mu(CodeHeapStateAnalytics_lock, Mutex::_no_safepoint_check_flag); + out->cr(); + out->print_cr("__ CodeHeapStateAnalytics lock wait took %10.3f seconds _________", ts.seconds()); + out->cr(); + + if (aggregate) { + // It should be sufficient to hold the CodeCache_lock only for the aggregate step. + // All other functions operate on aggregated data - except MethodNames, but that should be safe. + // The separate CodeHeapStateAnalytics_lock protects the printing functions against + // concurrent aggregate steps. Acquire this lock before acquiring the CodeCache_lock. + // CodeHeapStateAnalytics_lock could be held by a concurrent thread for a long time, + // leading to an unnecessarily long hold time of the CodeCache_lock. + ts.update(); // record starting point + MutexLockerEx mu2(CodeCache_lock, Mutex::_no_safepoint_check_flag); + out->cr(); + out->print_cr("__ CodeCache lock wait took %10.3f seconds _________", ts.seconds()); + out->cr(); + + ts.update(); // record starting point + CodeCache::aggregate(out, granularity); + out->cr(); + out->print_cr("__ CodeCache lock hold took %10.3f seconds _________", ts.seconds()); + out->cr(); + } + + if (usedSpace) CodeCache::print_usedSpace(out); + if (freeSpace) CodeCache::print_freeSpace(out); + if (methodCount) CodeCache::print_count(out); + if (methodSpace) CodeCache::print_space(out); + if (methodAge) CodeCache::print_age(out); + if (methodNames) CodeCache::print_names(out); + if (discard) CodeCache::discard(out); + + out->cr(); + out->print_cr("__ CodeHeapStateAnalytics total duration %10.3f seconds _________", ts_total.seconds()); + out->cr(); + }
< prev index next >