graal-compiler: src/share/vm/compiler/compileBroker.cpp comparison

comparison src/share/vm/compiler/compileBroker.cpp @ 1783:d5d065957597

6953144: Tiered compilation Summary: Infrastructure for tiered compilation support (interpreter + c1 + c2) for 32 and 64 bit. Simple tiered policy implementation. Reviewed-by: kvn, never, phh, twisti

author	iveresov
date	Fri, 03 Sep 2010 17:51:07 -0700
parents	3e8fbc61cee8
children	2d26b0046e0d 22ef3370343b

comparison

equal deleted inserted replaced

-:f353275af40e
+:d5d065957597
 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_cr(" (%d bytes)", method->code_size());
 }
 // ------------------------------------------------------------------
 // CompileTask::log_task
 // 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.
 if (UseCodeCacheFlushing && (!CompileBroker::should_compile_new_jobs() || CodeCache::needs_flushing())) {
 // During the emergency sweeping periods, wake up and sweep occasionally
 } else {
 // During normal operation no need to wake up on timer
 lock()->wait();
 }
 }
+CompileTask* task = CompilationPolicy::policy()->select_task(this);
-CompileTask* task = _first;
+remove(task);
-// Update queue first and last
-_first =_first->next();
-if (_first == NULL) {
-_last = NULL;
-}
 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();
+}
+--_size;
+}
 // ------------------------------------------------------------------
 // CompileQueue::print
 void CompileQueue::print() {
 tty->print_cr("Contents of %s", name());
 _perf_compiles = PerfDataManager::create_counter(SUN_CI, name,
 PerfData::U_Events, CHECK);
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::compilation_init
 //
 // 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
-_compilers[0] = new Compiler();
+if (c1_count > 0) {
-#ifndef COMPILER2
+_compilers[0] = new Compiler();
-_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
 #endif // COMPILER2
 #ifdef SHARK
 #if defined(COMPILER1) || defined(COMPILER2)
 #error "Can't use COMPILER1 or COMPILER2 with shark"
 // 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);
 // Make sure the method has not slipped into the queues since
 // last we checked; note that those checks were "fast bail-outs".
 // Here we need to be more careful, see 14012000 below.
 if (compilation_is_in_queue(method, osr_bci)) {
 // 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.
 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 > graal-compiler

comparison src/share/vm/compiler/compileBroker.cpp @ 1783:d5d065957597