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

comparison src/share/vm/compiler/compileBroker.cpp @ 13086:096c224171c4

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 20 Nov 2013 00:10:38 +0100
parents	f6c511451e4a 78da3894b86f
children	77fbf02f701c

comparison

equal deleted inserted replaced

-:92b7ec34ddfa
+:096c224171c4
 #endif // ndef DTRACE_ENABLED
 bool CompileBroker::_initialized = false;
 volatile bool CompileBroker::_should_block = false;
+volatile jint CompileBroker::_print_compilation_warning = 0;
 volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;
 // The installed compiler(s)
 AbstractCompiler* CompileBroker::_compilers[2];
 CompileQueue* CompileBroker::_c2_method_queue    = NULL;
 CompileQueue* CompileBroker::_c1_method_queue    = NULL;
 CompileTask*  CompileBroker::_task_free_list     = NULL;
-GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;
+GrowableArray<CompilerThread*>* CompileBroker::_compiler_threads = NULL;
 class CompilationLog : public StringEventLog {
 public:
 CompilationLog() : StringEventLog("Compilation events") {
 log->mark_file_end();
 }
-// ------------------------------------------------------------------
-// CompileQueue::add
-//
 // Add a CompileTask to a CompileQueue
 void CompileQueue::add(CompileTask* task) {
 assert(lock()->owned_by_self(), "must own lock");
 task->set_next(NULL);
 // Notify CompilerThreads that a task is available.
 lock()->notify_all();
 }
+void CompileQueue::delete_all() {
+assert(lock()->owned_by_self(), "must own lock");
+if (_first != NULL) {
+for (CompileTask* task = _first; task != NULL; task = task->next()) {
+delete task;
+}
+_first = NULL;
+}
+}
 // ------------------------------------------------------------------
 // CompileQueue::get
 //
 // Get the next CompileTask from a CompileQueue
 CompileTask* CompileQueue::get() {
 // having no compile jobs: First, we compiled everything we wanted. Second,
 // we ran out of code cache so compilation has been disabled. In the latter
 // case we perform code cache sweeps to free memory such that we can re-enable
 // compilation.
 while (_first == NULL) {
+// Exit loop if compilation is disabled forever
+if (CompileBroker::is_compilation_disabled_forever()) {
+return NULL;
+}
 if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs()) {
 // Wait a certain amount of time to possibly do another sweep.
 // We must wait until stack scanning has happened so that we can
 // transition a method's state from 'not_entrant' to 'zombie'.
 long wait_time = NmethodSweepCheckInterval * 1000;
 // (i.e., there is enough free space in the code cache) there is
 // no need to invoke the sweeper. As a result, the hotness of methods
 // remains unchanged. This behavior is desired, since we want to keep
 // the stable state, i.e., we do not want to evict methods from the
 // code cache if it is unnecessary.
-lock()->wait();
+// We need a timed wait here, since compiler threads can exit if compilation
-}
+// is disabled forever. We use 5 seconds wait time; the exiting of compiler threads
-}
+// is not critical and we do not want idle compiler threads to wake up too often.
+lock()->wait(!Mutex::_no_safepoint_check_flag, 5*1000);
+}
+}
+if (CompileBroker::is_compilation_disabled_forever()) {
+return NULL;
+}
 CompileTask* task = CompilationPolicy::policy()->select_task(this);
 remove(task);
 return task;
 }
 //
 // Initialize the Compilation object
 void CompileBroker::compilation_init() {
 _last_method_compiled[0] = '\0';
+// No need to initialize compilation system if we do not use it.
+if (!UseCompiler) {
+return;
+}
 #ifndef SHARK
 // 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 GRAAL
 _initialized = true;
 }
+CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters,
-// ------------------------------------------------------------------
+AbstractCompiler* comp, TRAPS) {
-// CompileBroker::make_compiler_thread
-CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
 CompilerThread* compiler_thread = NULL;
 Klass* k =
 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(),
 true, CHECK_0);
 os::set_native_priority(compiler_thread, native_prio);
 java_lang_Thread::set_daemon(thread_oop());
 compiler_thread->set_threadObj(thread_oop());
+compiler_thread->set_compiler(comp);
 Threads::add(compiler_thread);
 Thread::start(compiler_thread);
 }
 // Let go of Threads_lock before yielding
 return compiler_thread;
 }
-// ------------------------------------------------------------------
-// CompileBroker::init_compiler_threads
-//
-// Initialize the compilation queue
 void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {
 EXCEPTION_MARK;
 #if !defined(ZERO) && !defined(SHARK) && !defined(GRAALVM)
 assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
 #endif // !ZERO && !SHARK && !GRAALVM
+// Initialize the compilation queue
 if (c2_compiler_count > 0) {
 _c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
+_compilers[1]->set_num_compiler_threads(c2_compiler_count);
 }
 if (c1_compiler_count > 0) {
 _c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
+_compilers[0]->set_num_compiler_threads(c1_compiler_count);
 }
 int compiler_count = c1_compiler_count + c2_compiler_count;
-_method_threads =
+_compiler_threads =
 new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true);
 char name_buffer[256];
 for (int i = 0; i < c2_compiler_count; i++) {
 // Create a name for our thread.
 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);
+// Shark and C2
-_method_threads->append(new_thread);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, _compilers[1], CHECK);
+_compiler_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);
+// C1
-_method_threads->append(new_thread);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, _compilers[0], CHECK);
+_compiler_threads->append(new_thread);
 }
 if (UsePerfData) {
-PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
+PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes, compiler_count, CHECK);
-compiler_count, CHECK);
 }
 }
 // Set the methods on the stack as on_stack so that redefine classes doesn't
 }
 if (_c1_method_queue != NULL) {
 _c1_method_queue->mark_on_stack();
 }
 }
-// ------------------------------------------------------------------
-// CompileBroker::is_idle
-bool CompileBroker::is_idle() {
-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) {
-return false;
-}
-}
-// No pending or active compilations.
-return true;
-}
-}
 // ------------------------------------------------------------------
 // CompileBroker::compile_method
 //
 // Request compilation of a method.
 // by a compiler thread), and compiled method registration.
 if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
 return;
 }
 #ifdef GRAALVM
-if (!JavaThread::current()->is_compiling()) {
+// Detect recursive request in Java
 GraalCompiler::instance()->compile_method(method, osr_bci, is_compile_blocking(method, osr_bci));
-} else {
-// Recursive compile request => ignore.
-}
 #else
 // Outputs from the following MutexLocker block:
 CompileTask* task     = NULL;
 bool         blocking = false;
 // a lock the compiling thread can not acquire. Prefetch it here.
 if (JvmtiExport::should_post_compiled_method_load()) {
 method->jmethod_id();
 }
-// If the compiler is shut off due to code cache getting full
-// fail out now so blocking compiles dont hang the java thread
-if (!should_compile_new_jobs()) {
-CompilationPolicy::policy()->delay_compilation(method());
-return NULL;
-}
 // do the compilation
 if (method->is_native()) {
 if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {
 // Acquire our lock.
 int compile_id;
 {
 MutexLocker locker(MethodCompileQueue_lock, THREAD);
 compile_id = assign_compile_id(method, standard_entry_bci);
 }
+// To properly handle the appendix argument for out-of-line calls we are using a small trampoline that
+// pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime).
+//
+// Since normal compiled-to-compiled calls are not able to handle such a thing we MUST generate an adapter
+// in this case.  If we can't generate one and use it we can not execute the out-of-line method handle calls.
 (void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id);
 } else {
 return NULL;
 }
 } else {
+// If the compiler is shut off due to code cache getting full
+// fail out now so blocking compiles dont hang the java thread
+if (!should_compile_new_jobs()) {
+CompilationPolicy::policy()->delay_compilation(method());
+return NULL;
+}
 compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, THREAD);
 }
 // return requested nmethod
 // We accept a higher level osr method
 // waiting on a CompileTask, we know that no one else will
 // be using this CompileTask; we can free it.
 free_task(task);
 }
+// Initialize compiler thread(s) + compiler object(s). The postcondition
+// of this function is that the compiler runtimes are initialized and that
+//compiler threads can start compiling.
+bool CompileBroker::init_compiler_runtime() {
+CompilerThread* thread = CompilerThread::current();
+AbstractCompiler* comp = thread->compiler();
+// Final sanity check - the compiler object must exist
+guarantee(comp != NULL, "Compiler object must exist");
+int system_dictionary_modification_counter;
+{
+MutexLocker locker(Compile_lock, thread);
+system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
+}
+{
+// Must switch to native to allocate ci_env
+ThreadToNativeFromVM ttn(thread);
+ciEnv ci_env(NULL, system_dictionary_modification_counter);
+// Cache Jvmti state
+ci_env.cache_jvmti_state();
+// Cache DTrace flags
+ci_env.cache_dtrace_flags();
+// Switch back to VM state to do compiler initialization
+ThreadInVMfromNative tv(thread);
+ResetNoHandleMark rnhm;
+if (!comp->is_shark()) {
+// Perform per-thread and global initializations
+comp->initialize();
+}
+}
+if (comp->is_failed()) {
+disable_compilation_forever();
+// If compiler initialization failed, no compiler thread that is specific to a
+// particular compiler runtime will ever start to compile methods.
+shutdown_compiler_runtime(comp, thread);
+return false;
+}
+// C1 specific check
+if (comp->is_c1() && (thread->get_buffer_blob() == NULL)) {
+warning("Initialization of %s thread failed (no space to run compilers)", thread->name());
+return false;
+}
+return true;
+}
+// If C1 and/or C2 initialization failed, we shut down all compilation.
+// We do this to keep things simple. This can be changed if it ever turns out to be
+// a problem.
+void CompileBroker::shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread) {
+// Free buffer blob, if allocated
+if (thread->get_buffer_blob() != NULL) {
+MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+CodeCache::free(thread->get_buffer_blob());
+}
+if (comp->should_perform_shutdown()) {
+// There are two reasons for shutting down the compiler
+// 1) compiler runtime initialization failed
+// 2) The code cache is full and the following flag is set: -XX:-UseCodeCacheFlushing
+warning("Shutting down compiler %s (no space to run compilers)", comp->name());
+// Only one thread per compiler runtime object enters here
+// Set state to shut down
+comp->set_shut_down();
+MutexLocker mu(MethodCompileQueue_lock, thread);
+CompileQueue* queue;
+if (_c1_method_queue != NULL) {
+_c1_method_queue->delete_all();
+queue = _c1_method_queue;
+_c1_method_queue = NULL;
+delete _c1_method_queue;
+}
+if (_c2_method_queue != NULL) {
+_c2_method_queue->delete_all();
+queue = _c2_method_queue;
+_c2_method_queue = NULL;
+delete _c2_method_queue;
+}
+// We could delete compiler runtimes also. However, there are references to
+// the compiler runtime(s) (e.g.,  nmethod::is_compiled_by_c1()) which then
+// fail. This can be done later if necessary.
+}
+}
 // ------------------------------------------------------------------
 // CompileBroker::compiler_thread_loop
 //
 // The main loop run by a CompilerThread.
 void CompileBroker::compiler_thread_loop() {
 CompilerThread* thread = CompilerThread::current();
 CompileQueue* queue = thread->queue();
 // For the thread that initializes the ciObjectFactory
 // this resource mark holds all the shared objects
 ResourceMark rm;
 // First thread to get here will initialize the compiler interface
 os::current_process_id());
 log->stamp();
 log->end_elem();
 }
-while (true) {
+// If compiler thread/runtime initialization fails, exit the compiler thread
-{
+if (!init_compiler_runtime()) {
-// We need this HandleMark to avoid leaking VM handles.
+return;
-HandleMark hm(thread);
+}
-if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
+// Poll for new compilation tasks as long as the JVM runs. Compilation
-// the code cache is really full
+// should only be disabled if something went wrong while initializing the
-handle_full_code_cache();
+// compiler runtimes. This, in turn, should not happen. The only known case
+// when compiler runtime initialization fails is if there is not enough free
+// space in the code cache to generate the necessary stubs, etc.
+while (!is_compilation_disabled_forever()) {
+// We need this HandleMark to avoid leaking VM handles.
+HandleMark hm(thread);
+if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
+// the code cache is really full
+handle_full_code_cache();
+}
+CompileTask* task = queue->get();
+if (task == NULL) {
+continue;
+}
+// Give compiler threads an extra quanta.  They tend to be bursty and
+// this helps the compiler to finish up the job.
+if( CompilerThreadHintNoPreempt )
+os::hint_no_preempt();
+// trace per thread time and compile statistics
+CompilerCounters* counters = ((CompilerThread*)thread)->counters();
+PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());
+// Assign the task to the current thread.  Mark this compilation
+// thread as active for the profiler.
+CompileTaskWrapper ctw(task);
+nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
+task->set_code_handle(&result_handle);
+methodHandle method(thread, task->method());
+// Never compile a method if breakpoints are present in it
+if (method()->number_of_breakpoints() == 0) {
+// Compile the method.
+if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
+#ifdef COMPILER1
+// Allow repeating compilations for the purpose of benchmarking
+// compile speed. This is not useful for customers.
+if (CompilationRepeat != 0) {
+int compile_count = CompilationRepeat;
+while (compile_count > 0) {
+invoke_compiler_on_method(task);
+nmethod* nm = method->code();
+if (nm != NULL) {
+nm->make_zombie();
+method->clear_code();
+}
+compile_count--;
+}
+}
+#endif /* COMPILER1 */
+invoke_compiler_on_method(task);
+} else {
+// After compilation is disabled, remove remaining methods from queue
+method->clear_queued_for_compilation();
 }
+}
-CompileTask* task = queue->get();
+}
-// Give compiler threads an extra quanta.  They tend to be bursty and
+// Shut down compiler runtime
-// this helps the compiler to finish up the job.
+shutdown_compiler_runtime(thread->compiler(), thread);
-if( CompilerThreadHintNoPreempt )
+}
-os::hint_no_preempt();
-// trace per thread time and compile statistics
-CompilerCounters* counters = ((CompilerThread*)thread)->counters();
-PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());
-// Assign the task to the current thread.  Mark this compilation
-// thread as active for the profiler.
-CompileTaskWrapper ctw(task);
-nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
-task->set_code_handle(&result_handle);
-methodHandle method(thread, task->method());
-// Never compile a method if breakpoints are present in it
-if (method()->number_of_breakpoints() == 0) {
-// Compile the method.
-if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
-#ifdef COMPILER1
-// Allow repeating compilations for the purpose of benchmarking
-// compile speed. This is not useful for customers.
-if (CompilationRepeat != 0) {
-int compile_count = CompilationRepeat;
-while (compile_count > 0) {
-invoke_compiler_on_method(task);
-nmethod* nm = method->code();
-if (nm != NULL) {
-nm->make_zombie();
-method->clear_code();
-}
-compile_count--;
-}
-}
-#endif /* COMPILER1 */
-invoke_compiler_on_method(task);
-} else {
-// After compilation is disabled, remove remaining methods from queue
-method->clear_queued_for_compilation();
-}
-}
-}
-}
-}
 // ------------------------------------------------------------------
 // CompileBroker::init_compiler_thread_log
 //
 // Set up state required by +LogCompilation.
 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.
-// 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 ) {
 if (xtty != NULL) {
 ResourceMark rm;
 xtty->begin_elem("code_cache_full");
 xtty->print(s.as_string());
 xtty->stamp();
 xtty->end_elem();
 }
-warning("CodeCache is full. Compiler has been disabled.");
-warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
 CodeCache::report_codemem_full();
 #ifndef PRODUCT
 if (CompileTheWorld || ExitOnFullCodeCache) {
 codecache_print(/* detailed= */ true);
 before_exit(JavaThread::current());
 #endif
 if (UseCodeCacheFlushing) {
 // Since code cache is full, immediately stop new compiles
 if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) {
 NMethodSweeper::log_sweep("disable_compiler");
-NMethodSweeper::possibly_sweep();
 }
+// Switch to 'vm_state'. This ensures that possibly_sweep() can be called
+// without having to consider the state in which the current thread is.
+ThreadInVMfromUnknown in_vm;
+NMethodSweeper::possibly_sweep();
 } else {
-UseCompiler               = false;
+disable_compilation_forever();
-AlwaysCompileLoopMethods  = false;
+}
-}
-}
+// Print warning only once
-codecache_print(/* detailed= */ true);
+if (should_print_compiler_warning()) {
+warning("CodeCache is full. Compiler has been disabled.");
+warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
+codecache_print(/* detailed= */ true);
+}
+}
 }
 // ------------------------------------------------------------------
 // CompileBroker::set_last_compile
 //

Mercurial > hg > graal-compiler

comparison src/share/vm/compiler/compileBroker.cpp @ 13086:096c224171c4