stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8005204: Code Cache Reduction: command line options implementation

Browse Source 
Adding more detailed output on CodeCache usage

Reviewed-by: kvn, vladidan
This commit is contained in:
Alexander Harlap 2013-01-14 13:52:08 -05:00 committed by Vladimir Danushevsky
parent 5613847626
commit 95cbed6639
6 changed files with 70 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
hotspot/src/share/vm/code/codeCache.cpp
View File

@ -30,6 +30,7 @@
#include "code/icBuffer.hpp"
#include "code/nmethod.hpp"
#include "code/pcDesc.hpp"
#include "compiler/compileBroker.hpp"
#include "gc_implementation/shared/markSweep.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/gcLocker.hpp"
@ -39,6 +40,7 @@
#include "oops/objArrayOop.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/arguments.hpp"
#include "runtime/icache.hpp"
#include "runtime/java.hpp"
#include "runtime/mutexLocker.hpp"
@ -168,6 +170,8 @@ nmethod* CodeCache::next_nmethod (CodeBlob* cb) {
return (nmethod*)cb;
}
static size_t maxCodeCacheUsed = 0;
CodeBlob* CodeCache::allocate(int size) {
// Do not seize the CodeCache lock here--if the caller has not
// already done so, we are going to lose bigtime, since the code
@ -192,6 +196,8 @@ CodeBlob* CodeCache::allocate(int size) {
(address)_heap->end() - (address)_heap->begin());
}
}
maxCodeCacheUsed = MAX2(maxCodeCacheUsed, ((address)_heap->high_boundary() -
(address)_heap->low_boundary()) - unallocated_capacity());
verify_if_often();
print_trace("allocation", cb, size);
return cb;
@ -928,7 +934,14 @@ void CodeCache::print_internals() {
FREE_C_HEAP_ARRAY(int, buckets, mtCode);
}
#endif // !PRODUCT
void CodeCache::print() {
print_summary(tty);
#ifndef PRODUCT
if (!Verbose) return;
CodeBlob_sizes live;
CodeBlob_sizes dead;
@ -953,7 +966,7 @@ void CodeCache::print() {
}
if (Verbose) {
if (WizardMode) {
// print the oop_map usage
int code_size = 0;
int number_of_blobs = 0;
@ -977,20 +990,30 @@ void CodeCache::print() {
tty->print_cr(" map size = %d", map_size);
}
#endif // !PRODUCT
}
#endif // PRODUCT
void CodeCache::print_summary(outputStream* st, bool detailed) {
size_t total = (_heap->high_boundary() - _heap->low_boundary());
st->print_cr("CodeCache: size=" SIZE_FORMAT "Kb used=" SIZE_FORMAT
"Kb max_used=" SIZE_FORMAT "Kb free=" SIZE_FORMAT
"Kb max_free_chunk=" SIZE_FORMAT "Kb",
total/K, (total - unallocated_capacity())/K,
maxCodeCacheUsed/K, unallocated_capacity()/K, largest_free_block()/K);
void CodeCache::print_bounds(outputStream* st) {
st->print_cr("Code Cache [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
_heap->low_boundary(),
_heap->high(),
_heap->high_boundary());
st->print_cr(" total_blobs=" UINT32_FORMAT " nmethods=" UINT32_FORMAT
" adapters=" UINT32_FORMAT " free_code_cache=" SIZE_FORMAT "Kb"
" largest_free_block=" SIZE_FORMAT,
nof_blobs(), nof_nmethods(), nof_adapters(),
unallocated_capacity()/K, largest_free_block());
if (detailed) {
st->print_cr(" bounds [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT "]",
_heap->low_boundary(),
_heap->high(),
_heap->high_boundary());
st->print_cr(" total_blobs=" UINT32_FORMAT " nmethods=" UINT32_FORMAT
" adapters=" UINT32_FORMAT,
nof_blobs(), nof_nmethods(), nof_adapters());
st->print_cr(" compilation: %s", CompileBroker::should_compile_new_jobs() ?
"enabled" : Arguments::mode() == Arguments::_int ?
"disabled (interpreter mode)" :
"disabled (not enough contiguous free space left)");
}
}
void CodeCache::log_state(outputStream* st) {

4
hotspot/src/share/vm/code/codeCache.hpp
View File

@ -145,11 +145,11 @@ class CodeCache : AllStatic {
static void prune_scavenge_root_nmethods();
// Printing/debugging
static void print() PRODUCT_RETURN; // prints summary
static void print(); // prints summary
static void print_internals();
static void verify(); // verifies the code cache
static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
static void print_bounds(outputStream* st); // Prints a summary of the bounds of the code cache
static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage
static void log_state(outputStream* st);
// The full limits of the codeCache

21
hotspot/src/share/vm/compiler/compileBroker.cpp
View File

@ -1714,6 +1714,20 @@ void CompileBroker::maybe_block() {
}
}
// wrapper for CodeCache::print_summary()
static void codecache_print(bool detailed)
{
ResourceMark rm;
stringStream s;
// Dump code cache into a buffer before locking the tty,
{
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
CodeCache::print_summary(&s, detailed);
}
ttyLocker ttyl;
tty->print_cr(s.as_string());
}
// ------------------------------------------------------------------
// CompileBroker::invoke_compiler_on_method
//
@ -1841,6 +1855,9 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
tty->print_cr("size: %d time: %d inlined: %d bytes", code_size, (int)time.milliseconds(), task->num_inlined_bytecodes());
}
if (PrintCodeCacheOnCompilation)
codecache_print(/* detailed= */ false);
// Disable compilation, if required.
switch (compilable) {
case ciEnv::MethodCompilable_never:
@ -1885,6 +1902,7 @@ void CompileBroker::handle_full_code_cache() {
UseInterpreter = true;
if (UseCompiler || AlwaysCompileLoopMethods ) {
if (xtty != NULL) {
ResourceMark rm;
stringStream s;
// Dump code cache state into a buffer before locking the tty,
// because log_state() will use locks causing lock conflicts.
@ -1898,9 +1916,9 @@ void CompileBroker::handle_full_code_cache() {
}
warning("CodeCache is full. Compiler has been disabled.");
warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
CodeCache::print_bounds(tty);
#ifndef PRODUCT
if (CompileTheWorld || ExitOnFullCodeCache) {
codecache_print(/* detailed= */ true);
before_exit(JavaThread::current());
exit_globals(); // will delete tty
vm_direct_exit(CompileTheWorld ? 0 : 1);
@ -1913,6 +1931,7 @@ void CompileBroker::handle_full_code_cache() {
AlwaysCompileLoopMethods = false;
}
}
codecache_print(/* detailed= */ true);
}
// ------------------------------------------------------------------

9
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -929,11 +929,14 @@ class CommandLineFlags {
"Starts debugger when an implicit OS (e.g., NULL) " \
"exception happens") \
\
notproduct(bool, PrintCodeCache, false, \
"Print the compiled_code cache when exiting") \
product(bool, PrintCodeCache, false, \
"Print the code cache memory usage when exiting") \
\
develop(bool, PrintCodeCache2, false, \
"Print detailed info on the compiled_code cache when exiting") \
"Print detailed usage info on the code cache when exiting") \
\
product(bool, PrintCodeCacheOnCompilation, false, \
"Print the code cache memory usage each time a method is compiled") \
\
diagnostic(bool, PrintStubCode, false, \
"Print generated stub code") \

6
hotspot/src/share/vm/runtime/java.cpp
View File

@ -368,6 +368,12 @@ void print_statistics() {
if (CITime) {
CompileBroker::print_times();
}
if (PrintCodeCache) {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
CodeCache::print();
}
#ifdef COMPILER2
if (PrintPreciseBiasedLockingStatistics) {
OptoRuntime::print_named_counters();

2
hotspot/src/share/vm/utilities/vmError.cpp
View File

@ -702,7 +702,7 @@ void VMError::report(outputStream* st) {
if (_verbose && Universe::is_fully_initialized()) {
// print code cache information before vm abort
CodeCache::print_bounds(st);
CodeCache::print_summary(st);
st->cr();
}