truffle: src/share/vm/compiler/compileBroker.cpp comparison

comparison src/share/vm/compiler/compileBroker.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	5571b97fc1ec d5d065957597
children	48bbaead8b6c

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1999-2010 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1999, 2010, 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.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 #include "incls/_precompiled.incl"
 #include "incls/_compileBroker.cpp.incl"
 int CompileBroker::_sum_osr_bytes_compiled       = 0;
 int CompileBroker::_sum_standard_bytes_compiled  = 0;
 int CompileBroker::_sum_nmethod_size             = 0;
 int CompileBroker::_sum_nmethod_code_size        = 0;
-CompileQueue* CompileBroker::_method_queue   = NULL;
+CompileQueue* CompileBroker::_c2_method_queue   = NULL;
+CompileQueue* CompileBroker::_c1_method_queue   = NULL;
 CompileTask*  CompileBroker::_task_free_list = NULL;
 GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;
-// CompileTaskWrapper
-//
-// Assign this task to the current thread.  Deallocate the task
-// when the compilation is complete.
-class CompileTaskWrapper : StackObj {
-public:
-CompileTaskWrapper(CompileTask* task);
-~CompileTaskWrapper();
-};
 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {
 CompilerThread* thread = CompilerThread::current();
 thread->set_task(task);
 CompileLog*     log  = thread->log();
 tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>",
 _osr_bci, bool_to_str(_is_blocking),
 bool_to_str(_is_complete), bool_to_str(_is_success));
 }
+void CompileTask::print_compilation(outputStream *st, methodOop method, char* method_name) {
+nmethod::print_compilation(st, method_name,/*title*/ NULL, method,
+is_blocking(), compile_id(), osr_bci(), comp_level());
+}
 // ------------------------------------------------------------------
 // CompileTask::print_line_on_error
 //
 // This function is called by fatal error handler when the thread
 // causing troubles is a compiler thread.
 //
 // Otherwise it's the same as CompileTask::print_line()
 //
 void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) {
 methodOop method = (methodOop)JNIHandles::resolve(_method);
 // print compiler name
 st->print("%s:", CompileBroker::compiler(comp_level())->name());
+char* method_name = NULL;
-// print compilation number
+if (method != NULL) {
-st->print("%3d", compile_id());
+method_name = method->name_and_sig_as_C_string(buf, buflen);
+}
-// print method attributes
+print_compilation(st, method, method_name);
-const bool is_osr = osr_bci() != CompileBroker::standard_entry_bci;
-{ const char blocking_char  = is_blocking()                      ? 'b' : ' ';
-const char compile_type   = is_osr                             ? '%' : ' ';
-const char sync_char      = method->is_synchronized()          ? 's' : ' ';
-const char exception_char = method->has_exception_handler()    ? '!' : ' ';
-const char tier_char      =
-is_highest_tier_compile(comp_level())                        ? ' ' : ('0' + comp_level());
-st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, tier_char);
-}
-// Use buf to get method name and signature
-if (method != NULL) st->print("%s", method->name_and_sig_as_C_string(buf, buflen));
-// print osr_bci if any
-if (is_osr) st->print(" @ %d", osr_bci());
-// print method size
-st->print_cr(" (%d bytes)", method->code_size());
 }
 // ------------------------------------------------------------------
 // CompileTask::print_line
 void CompileTask::print_line() {
 ttyLocker ttyl;  // keep the following output all in one block
 // print compiler name if requested
 if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler(comp_level())->name());
+print_compilation(tty, method(), NULL);
-// print compilation number
-tty->print("%3d", compile_id());
-// print method attributes
-const bool is_osr = osr_bci() != CompileBroker::standard_entry_bci;
-{ const char blocking_char  = is_blocking()                      ? 'b' : ' ';
-const char compile_type   = is_osr                             ? '%' : ' ';
-const char sync_char      = method->is_synchronized()          ? 's' : ' ';
-const char exception_char = method->has_exception_handler()    ? '!' : ' ';
-const char tier_char      =
-is_highest_tier_compile(comp_level())                        ? ' ' : ('0' + comp_level());
-tty->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, tier_char);
-}
-// print method name
-method->print_short_name(tty);
-// print osr_bci if any
-if (is_osr) tty->print(" @ %d", osr_bci());
-// print method size
-tty->print(" (%d bytes)", method->code_size());
-// invocation count
-tty->print_cr(" %d invocations", _hot_count);
 }
 // ------------------------------------------------------------------
 // CompileTask::log_task
 ResourceMark rm(thread);
 // <task_done ... stamp='1.234'>  </task>
 nmethod* nm = code();
 log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",
-_is_success, nm == NULL ? 0 : nm->instructions_size(),
+_is_success, nm == NULL ? 0 : nm->content_size(),
 method->invocation_count());
 int bec = method->backedge_count();
 if (bec != 0)  log->print(" backedge_count='%d'", bec);
 // Note:  "_is_complete" is about to be set, but is not.
 if (_num_inlined_bytecodes != 0) {
 // Add a CompileTask to a CompileQueue
 void CompileQueue::add(CompileTask* task) {
 assert(lock()->owned_by_self(), "must own lock");
 task->set_next(NULL);
+task->set_prev(NULL);
 if (_last == NULL) {
 // The compile queue is empty.
 assert(_first == NULL, "queue is empty");
 _first = task;
 _last = task;
 } else {
 // Append the task to the queue.
 assert(_last->next() == NULL, "not last");
 _last->set_next(task);
+task->set_prev(_last);
 _last = task;
 }
+++_size;
 // Mark the method as being in the compile queue.
 ((methodOop)JNIHandles::resolve(task->method_handle()))->set_queued_for_compilation();
 if (CIPrintCompileQueue) {
 if (LogCompilation && xtty != NULL) {
 task->log_task_queued();
 }
 // Notify CompilerThreads that a task is available.
-lock()->notify();
+lock()->notify_all();
 }
 // ------------------------------------------------------------------
 // CompileQueue::get
 //
 // Get the next CompileTask from a CompileQueue
 CompileTask* CompileQueue::get() {
+NMethodSweeper::possibly_sweep();
 MutexLocker locker(lock());
 // Wait for an available CompileTask.
 while (_first == NULL) {
 // There is no work to be done right now.  Wait.
-lock()->wait();
+if (UseCodeCacheFlushing && (!CompileBroker::should_compile_new_jobs() || CodeCache::needs_flushing())) {
-}
+// During the emergency sweeping periods, wake up and sweep occasionally
+bool timedout = lock()->wait(!Mutex::_no_safepoint_check_flag, NmethodSweepCheckInterval*1000);
-CompileTask* task = _first;
+if (timedout) {
+MutexUnlocker ul(lock());
-// Update queue first and last
+// When otherwise not busy, run nmethod sweeping
-_first =_first->next();
+NMethodSweeper::possibly_sweep();
-if (_first == NULL) {
+}
-_last = NULL;
+} else {
+// During normal operation no need to wake up on timer
+lock()->wait();
+}
+}
+CompileTask* task = CompilationPolicy::policy()->select_task(this);
+remove(task);
+return task;
+}
+void CompileQueue::remove(CompileTask* task)
+{
+assert(lock()->owned_by_self(), "must own lock");
+if (task->prev() != NULL) {
+task->prev()->set_next(task->next());
+} else {
+// max is the first element
+assert(task == _first, "Sanity");
+_first = task->next();
+}
+if (task->next() != NULL) {
+task->next()->set_prev(task->prev());
+} else {
+// max is the last element
+assert(task == _last, "Sanity");
+_last = task->prev();
 }
 // (tw) Immediately set compiling flag.
 JavaThread::current()->as_CompilerThread()->set_compiling(true);
+--_size;
-return task;
+}
-}
 // ------------------------------------------------------------------
 // CompileQueue::print
 void CompileQueue::print() {
 tty->print_cr("Contents of %s", name());
 // Initialize the Compilation object
 void CompileBroker::compilation_init() {
 _last_method_compiled[0] = '\0';
 // Set the interface to the current compiler(s).
+int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple);
+int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization);
 #ifdef COMPILER1
 if (UseC1X) {
 	  _compilers[0] = new C1XCompiler();
-} else {
+} else if (c1_count > 0) {
 	  _compilers[0] = new Compiler();
 }
 #ifndef COMPILER2
 _compilers[1] = _compilers[0];
 #endif
 #endif // COMPILER1
 #ifdef COMPILER2
-_compilers[1] = new C2Compiler();
+if (c2_count > 0) {
-#ifndef COMPILER1
+_compilers[1] = new C2Compiler();
-_compilers[0] = _compilers[1];
+}
+#endif // COMPILER2
+#ifdef SHARK
+#if defined(COMPILER1) || defined(COMPILER2)
+#error "Can't use COMPILER1 or COMPILER2 with shark"
 #endif
-#endif // COMPILER2
+_compilers[0] = new SharkCompiler();
+_compilers[1] = _compilers[0];
+#endif
 // Initialize the CompileTask free list
 _task_free_list = NULL;
 // Start the CompilerThreads
-init_compiler_threads(compiler_count());
+init_compiler_threads(c1_count, c2_count);
 // totalTime performance counter is always created as it is required
 // by the implementation of java.lang.management.CompilationMBean.
 {
 EXCEPTION_MARK;
 _perf_total_compilation =
 // ------------------------------------------------------------------
 // CompileBroker::init_compiler_threads
 //
 // Initialize the compilation queue
-void CompileBroker::init_compiler_threads(int compiler_count) {
+void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {
 EXCEPTION_MARK;
+assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
-_method_queue  = new CompileQueue("MethodQueue",  MethodCompileQueue_lock);
+if (c2_compiler_count > 0) {
+_c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
+}
+if (c1_compiler_count > 0) {
+_c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
+}
+int compiler_count = c1_compiler_count + c2_compiler_count;
 _method_threads =
 new (ResourceObj::C_HEAP) GrowableArray<CompilerThread*>(compiler_count, true);
 char name_buffer[256];
-int i;
+for (int i = 0; i < c2_compiler_count; i++) {
-for (i = 0; i < compiler_count; i++) {
 // Create a name for our thread.
-sprintf(name_buffer, "CompilerThread%d", i);
+sprintf(name_buffer, "C2 CompilerThread%d", i);
 CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK);
-CompilerThread* new_thread = make_compiler_thread(name_buffer, _method_queue, counters, CHECK);
 _method_threads->append(new_thread);
 }
+for (int i = c2_compiler_count; i < compiler_count; i++) {
+// Create a name for our thread.
+sprintf(name_buffer, "C1 CompilerThread%d", i);
+CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK);
+_method_threads->append(new_thread);
+}
 if (UsePerfData) {
 PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
 compiler_count, CHECK);
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::is_idle
 bool CompileBroker::is_idle() {
-if (!_method_queue->is_empty()) {
+if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) {
+return false;
+} else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) {
 return false;
 } else {
 int num_threads = _method_threads->length();
 for (int i=0; i<num_threads; i++) {
 if (_method_threads->at(i)->task() != NULL) {
 // real work, check to see if the method has been compiled
 // in the meantime with a definitive result.
 if (compilation_is_complete(method, osr_bci, comp_level)) {
 return;
 }
 // If this method is already in the compile queue, then
 // we do not block the current thread.
 if (compilation_is_in_queue(method, osr_bci)) {
 // We may want to decay our counter a bit here to prevent
 }
 // Outputs from the following MutexLocker block:
 CompileTask* task     = NULL;
 bool         blocking = false;
+CompileQueue* queue  = compile_queue(comp_level);
 // Acquire our lock.
 {
-MutexLocker locker(_method_queue->lock(), THREAD);
+MutexLocker locker(queue->lock(), THREAD);
 if (Thread::current()->is_Compiler_thread() && CompilerThread::current()->is_compiling() && !BackgroundCompilation) {
 TRACE_C1X_1("Recursive compile %s!", method->name_and_sig_as_C_string());
 method->set_not_compilable();
 // NOTE: in the event that there are multiple compiler threads and
 // there is de-optimization/recompilation, things will get hairy,
 // and in that case it's best to protect both the testing (here) of
 // these bits, and their updating (here and elsewhere) under a
 // common lock.
-task = create_compile_task(_method_queue,
+task = create_compile_task(queue,
 compile_id, method,
 osr_bci, comp_level,
 hot_method, hot_count, comment,
 blocking);
 }
 }
 }
 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,
+int comp_level,
 methodHandle hot_method, int hot_count,
 const char* comment, TRAPS) {
 // make sure arguments make sense
 assert(method->method_holder()->klass_part()->oop_is_instance(), "not an instance method");
 assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range");
 assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods");
 assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized");
-int comp_level = CompilationPolicy::policy()->compilation_level(method, osr_bci);
+if (!TieredCompilation) {
+comp_level = CompLevel_highest_tier;
-#ifdef TIERED
+}
-if (TieredCompilation && StressTieredRuntime) {
-static int flipper = 0;
-if (is_even(flipper++)) {
-comp_level = CompLevel_fast_compile;
-} else {
-comp_level = CompLevel_full_optimization;
-}
-}
-#ifdef SPARC
-// QQQ FIX ME
-// C2 only returns long results in G1 and c1 doesn't understand so disallow c2
-// compiles of long results
-if (TieredCompilation && method()->result_type() == T_LONG) {
-comp_level = CompLevel_fast_compile;
-}
-#endif // SPARC
-#endif // TIERED
 // return quickly if possible
 // lock, make sure that the compilation
 // isn't prohibited in a straightforward way.
 }
 if (osr_bci == InvocationEntryBci) {
 // standard compilation
 nmethod* method_code = method->code();
-if (method_code != NULL
+if (method_code != NULL) {
-#ifdef TIERED
+if (compilation_is_complete(method, osr_bci, comp_level)) {
-&& ( method_code->is_compiled_by_c2() || comp_level == CompLevel_fast_compile )
+return method_code;
-#endif // TIERED
+}
-) {
-return method_code;
 }
 if (method->is_not_compilable(comp_level)) return NULL;
 if (UseCodeCacheFlushing) {
 nmethod* saved = CodeCache::find_and_remove_saved_code(method());
 } else {
 // osr compilation
 #ifndef TIERED
 // seems like an assert of dubious value
-assert(comp_level == CompLevel_full_optimization,
+assert(comp_level == CompLevel_highest_tier,
 "all OSR compiles are assumed to be at a single compilation lavel");
 #endif // TIERED
-nmethod* nm = method->lookup_osr_nmethod_for(osr_bci);
+// We accept a higher level osr method
+nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
 if (nm != NULL) return nm;
 if (method->is_not_osr_compilable()) return NULL;
 }
 assert(!HAS_PENDING_EXCEPTION, "No exception should be present");
 }
 // If the compiler is shut off due to code cache flushing or otherwise,
 // fail out now so blocking compiles dont hang the java thread
 if (!should_compile_new_jobs() || (UseCodeCacheFlushing && CodeCache::needs_flushing())) {
-method->invocation_counter()->decay();
+CompilationPolicy::policy()->delay_compilation(method());
-method->backedge_counter()->decay();
 return NULL;
 }
 // do the compilation
 if (method->is_native()) {
 } else {
 compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, CHECK_0);
 }
 // return requested nmethod
-return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci);
+// We accept a higher level osr method
+return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
 }
 // ------------------------------------------------------------------
 // CompileBroker::compilation_is_complete
 bool is_osr = (osr_bci != standard_entry_bci);
 if (is_osr) {
 if (method->is_not_osr_compilable()) {
 return true;
 } else {
-nmethod* result = method->lookup_osr_nmethod_for(osr_bci);
+nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true);
 return (result != NULL);
 }
 } else {
 if (method->is_not_compilable(comp_level)) {
 return true;
 } else {
 nmethod* result = method->code();
 if (result == NULL) return false;
-#ifdef TIERED
+return comp_level == result->comp_level();
-if (comp_level == CompLevel_fast_compile) {
-// At worst the code is from c1
-return true;
-}
-// comp level must be full opt
-return result->is_compiled_by_c2();
-#endif // TIERED
-return true;
 }
 }
 }
 // conservative in the sense that an osr compilation in the queue
 // will block a normal compilation from entering the queue (and vice
 // versa).  This can be remedied by a full queue search to disambiguate
 // cases.  If it is deemed profitible, this may be done.
 bool CompileBroker::compilation_is_in_queue(methodHandle method,
 int          osr_bci) {
 return method->queued_for_compilation();
 }
 // ------------------------------------------------------------------
 // CompileBroker::compilation_is_prohibited
 //
 // See if this compilation is not allowed.
 bool CompileBroker::compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level) {
 bool is_native = method->is_native();
 // Some compilers may not support the compilation of natives.
-// QQQ this needs some work ought to only record not compilable at
-// the specified level
 if (is_native &&
 (!CICompileNatives || !compiler(comp_level)->supports_native())) {
-method->set_not_compilable_quietly();
+method->set_not_compilable_quietly(comp_level);
 return true;
 }
 bool is_osr = (osr_bci != standard_entry_bci);
 // Some compilers may not support on stack replacement.
 // Assign a serialized id number to this compilation request.  If the
 // number falls out of the allowed range, return a 0.  OSR
 // compilations may be numbered separately from regular compilations
 // if certain debugging flags are used.
 uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
-assert(_method_queue->lock()->owner() == JavaThread::current(),
+assert(MethodCompileQueue_lock->owner() == Thread::current(),
 "must hold the compilation queue lock");
 bool is_osr = (osr_bci != standard_entry_bci);
 assert(!method->is_native(), "no longer compile natives");
 uint id;
 if (CICountOSR && is_osr) {
 vm_exit(0);
 }
 #endif
 }
 // ------------------------------------------------------------------
 // CompileBroker::handle_full_code_cache
 //
 // The CodeCache is full.  Print out warning and disable compilation or
 // try code cache cleaning so compilation can continue later.
 void CompileBroker::handle_full_code_cache() {
 UseInterpreter = true;
 if (UseCompiler || AlwaysCompileLoopMethods ) {
-CompilerThread* thread = CompilerThread::current();
+if (xtty != NULL) {
-CompileLog* log = thread->log();
+xtty->begin_elem("code_cache_full");
-if (log != NULL) {
+xtty->stamp();
-log->begin_elem("code_cache_full");
+xtty->end_elem();
-log->stamp();
+}
-log->end_elem();
+warning("CodeCache is full. Compiler has been disabled.");
-}
+warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
 #ifndef PRODUCT
-warning("CodeCache is full. Compiler has been disabled");
 if (CompileTheWorld || ExitOnFullCodeCache) {
 before_exit(JavaThread::current());
 exit_globals(); // will delete tty
 vm_direct_exit(CompileTheWorld ? 0 : 1);
 }
 #endif
 if (UseCodeCacheFlushing) {
 NMethodSweeper::handle_full_code_cache(true);
 } else {
 UseCompiler               = false;
 AlwaysCompileLoopMethods  = false;
 tty->print_cr("%3d   seconds: %f bytes/sec : %f (bytes %d + %d inlined)",
 compile_id, time.seconds(), bytes_per_sec, method->code_size(), task->num_inlined_bytecodes());
 }
 // Collect counts of successful compilations
-_sum_nmethod_size += code->total_size();
+_sum_nmethod_size      += code->total_size();
-_sum_nmethod_code_size += code->code_size();
+_sum_nmethod_code_size += code->insts_size();
 _total_compile_count++;
 if (UsePerfData) {
-_perf_sum_nmethod_size->inc(code->total_size());
+_perf_sum_nmethod_size->inc(     code->total_size());
-_perf_sum_nmethod_code_size->inc(code->code_size());
+_perf_sum_nmethod_code_size->inc(code->insts_size());
 _perf_total_compile_count->inc();
 }
 if (is_osr) {
 if (UsePerfData) _perf_total_osr_compile_count->inc();
 tty->print_cr("    Standard compilation   : %6.3f s, Average : %2.3f",
 CompileBroker::_t_standard_compilation.seconds(),
 CompileBroker::_t_standard_compilation.seconds() / CompileBroker::_total_standard_compile_count);
 tty->print_cr("    On stack replacement   : %6.3f s, Average : %2.3f", CompileBroker::_t_osr_compilation.seconds(), CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count);
-if (compiler(CompLevel_fast_compile)) {
+if (compiler(CompLevel_simple) != NULL) {
-compiler(CompLevel_fast_compile)->print_timers();
+compiler(CompLevel_simple)->print_timers();
-if (compiler(CompLevel_fast_compile) != compiler(CompLevel_highest_tier))
+}
-compiler(CompLevel_highest_tier)->print_timers();
+if (compiler(CompLevel_full_optimization) != NULL) {
-}
+compiler(CompLevel_full_optimization)->print_timers();
+}
 tty->cr();
 int tcb = CompileBroker::_sum_osr_bytes_compiled + CompileBroker::_sum_standard_bytes_compiled;
 tty->print_cr("  Total compiled bytecodes : %6d bytes", tcb);
 tty->print_cr("    Standard compilation   : %6d bytes", CompileBroker::_sum_standard_bytes_compiled);
 tty->print_cr("    On stack replacement   : %6d bytes", CompileBroker::_sum_osr_bytes_compiled);

Mercurial > hg > truffle

comparison src/share/vm/compiler/compileBroker.cpp @ 1930:2d26b0046e0d