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

comparison src/share/vm/compiler/compileBroker.cpp @ 20588:41dcdd636080

8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline Summary: Fixes broken memory freeing of compile queue tasks and makes sure that blocking compiles do not hang the VM if compilation gets disabled due to a full code cache. Reviewed-by: kvn, iveresov

author	anoll
date	Tue, 29 Apr 2014 07:59:22 +0200
parents	b9c94af14fd0
children	0c0e68524c17

comparison

equal deleted inserted replaced

-:ef9eda2c1abe
+:41dcdd636080
 int CompileBroker::_sum_nmethod_size             = 0;
 int CompileBroker::_sum_nmethod_code_size        = 0;
 long CompileBroker::_peak_compilation_time       = 0;
-CompileQueue* CompileBroker::_c2_method_queue    = NULL;
+CompileQueue* CompileBroker::_c2_compile_queue   = NULL;
-CompileQueue* CompileBroker::_c1_method_queue    = NULL;
+CompileQueue* CompileBroker::_c1_compile_queue   = NULL;
-CompileTask*  CompileBroker::_task_free_list     = NULL;
 GrowableArray<CompilerThread*>* CompileBroker::_compiler_threads = NULL;
 class CompilationLog : public StringEventLog {
 } else {
 task->mark_complete();
 // By convention, the compiling thread is responsible for
 // recycling a non-blocking CompileTask.
-CompileBroker::free_task(task);
+CompileTask::free(task);
 }
 }
-// ------------------------------------------------------------------
+CompileTask*  CompileTask::_task_free_list = NULL;
-// CompileTask::initialize
+#ifdef ASSERT
+int CompileTask::_num_allocated_tasks = 0;
+#endif
+/**
+* Allocate a CompileTask, from the free list if possible.
+*/
+CompileTask* CompileTask::allocate() {
+MutexLocker locker(CompileTaskAlloc_lock);
+CompileTask* task = NULL;
+if (_task_free_list != NULL) {
+task = _task_free_list;
+_task_free_list = task->next();
+task->set_next(NULL);
+} else {
+task = new CompileTask();
+DEBUG_ONLY(_num_allocated_tasks++;)
+assert (_num_allocated_tasks < 10000, "Leaking compilation tasks?");
+task->set_next(NULL);
+task->set_is_free(true);
+}
+assert(task->is_free(), "Task must be free.");
+task->set_is_free(false);
+return task;
+}
+/**
+* Add a task to the free list.
+*/
+void CompileTask::free(CompileTask* task) {
+MutexLocker locker(CompileTaskAlloc_lock);
+if (!task->is_free()) {
+task->set_code(NULL);
+assert(!task->lock()->is_locked(), "Should not be locked when freed");
+JNIHandles::destroy_global(task->_method_holder);
+JNIHandles::destroy_global(task->_hot_method_holder);
+task->set_is_free(true);
+task->set_next(_task_free_list);
+_task_free_list = task;
+}
+}
 void CompileTask::initialize(int compile_id,
 methodHandle method,
 int osr_bci,
 int comp_level,
 methodHandle hot_method,
 void CompileTask::set_code(nmethod* nm) {
 if (_code_handle == NULL && nm == NULL)  return;
 guarantee(_code_handle != NULL, "");
 _code_handle->set_code(nm);
 if (nm == NULL)  _code_handle = NULL;  // drop the handle also
-}
-// ------------------------------------------------------------------
-// CompileTask::free
-void CompileTask::free() {
-set_code(NULL);
-assert(!_lock->is_locked(), "Should not be locked when freed");
-JNIHandles::destroy_global(_method_holder);
-JNIHandles::destroy_global(_hot_method_holder);
 }
 void CompileTask::mark_on_stack() {
 // Mark these methods as something redefine classes cannot remove.
 log->mark_file_end();
 }
-// Add a CompileTask to a CompileQueue
+/**
+* Add a CompileTask to a CompileQueue
+*/
 void CompileQueue::add(CompileTask* task) {
 assert(lock()->owned_by_self(), "must own lock");
+assert(!CompileBroker::is_compilation_disabled_forever(), "Do not add task if compilation is turned off forever");
 task->set_next(NULL);
 task->set_prev(NULL);
 if (_last == NULL) {
 ++_size;
 // Mark the method as being in the compile queue.
 task->method()->set_queued_for_compilation();
-if (CIPrintCompileQueue) {
+NOT_PRODUCT(print();)
-print();
-}
 if (LogCompilation && xtty != NULL) {
 task->log_task_queued();
 }
 // Notify CompilerThreads that a task is available.
 lock()->notify_all();
 }
-void CompileQueue::delete_all() {
+void CompileQueue::free_all() {
-assert(lock()->owned_by_self(), "must own lock");
+MutexLocker mu(lock());
 if (_first != NULL) {
 for (CompileTask* task = _first; task != NULL; task = task->next()) {
-delete task;
+// Wake up thread that blocks on the compile task.
+task->lock()->notify();
+// Puts task back on the freelist.
+CompileTask::free(task);
 }
 _first = NULL;
 }
+// Wake up all threads that block on the queue.
+lock()->notify_all();
 }
 // ------------------------------------------------------------------
 // CompileQueue::get
 //
 task->mark_on_stack();
 task = task->next();
 }
 }
-// ------------------------------------------------------------------
+#ifndef PRODUCT
-// CompileQueue::print
+/**
+* Print entire compilation queue.
+*/
 void CompileQueue::print() {
-tty->print_cr("Contents of %s", name());
+if (CIPrintCompileQueue) {
-tty->print_cr("----------------------");
+ttyLocker ttyl;
-CompileTask* task = _first;
+tty->print_cr("Contents of %s", name());
-while (task != NULL) {
+tty->print_cr("----------------------");
-task->print_line();
+CompileTask* task = _first;
-task = task->next();
+while (task != NULL) {
-}
+task->print_line();
-tty->print_cr("----------------------");
+task = task->next();
 }
+tty->print_cr("----------------------");
+}
+}
+#endif // PRODUCT
 CompilerCounters::CompilerCounters(const char* thread_name, int instance, TRAPS) {
 _current_method[0] = '\0';
 _compile_type = CompileBroker::no_compile;
 int c1_count = 0;
 int c2_count = 1;
 _compilers[1] = new SharkCompiler();
 #endif // SHARK
-// Initialize the CompileTask free list
-_task_free_list = NULL;
 // Start the CompilerThreads
 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.
 #if !defined(ZERO) && !defined(SHARK)
 assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
 #endif // !ZERO && !SHARK
 // Initialize the compilation queue
 if (c2_compiler_count > 0) {
-_c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
+_c2_compile_queue  = new CompileQueue("C2 CompileQueue",  MethodCompileQueue_lock);
 _compilers[1]->set_num_compiler_threads(c2_compiler_count);
 }
 if (c1_compiler_count > 0) {
-_c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
+_c1_compile_queue  = new CompileQueue("C1 CompileQueue",  MethodCompileQueue_lock);
 _compilers[0]->set_num_compiler_threads(c1_compiler_count);
 }
 int compiler_count = c1_compiler_count + c2_compiler_count;
 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);
 // Shark and C2
-CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, _compilers[1], CHECK);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_compile_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);
 // C1
-CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, _compilers[0], CHECK);
+CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_compile_queue, counters, _compilers[0], CHECK);
 _compiler_threads->append(new_thread);
 }
 if (UsePerfData) {
 PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes, compiler_count, CHECK);
 }
 }
-// Set the methods on the stack as on_stack so that redefine classes doesn't
+/**
-// reclaim them
+* Set the methods on the stack as on_stack so that redefine classes doesn't
+* reclaim them
+*/
 void CompileBroker::mark_on_stack() {
-if (_c2_method_queue != NULL) {
+if (_c2_compile_queue != NULL) {
-_c2_method_queue->mark_on_stack();
+MutexLocker locker(_c2_compile_queue->lock());
-}
+_c2_compile_queue->mark_on_stack();
-if (_c1_method_queue != NULL) {
+}
-_c1_method_queue->mark_on_stack();
+if (_c1_compile_queue != NULL) {
+MutexLocker locker(_c1_compile_queue->lock());
+_c1_compile_queue->mark_on_stack();
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::compile_method
 methodHandle hot_method,
 int hot_count,
 const char* comment,
 Thread* thread) {
 // do nothing if compiler thread(s) is not available
-if (!_initialized ) {
+if (!_initialized) {
 return;
 }
 guarantee(!method->is_abstract(), "cannot compile abstract methods");
 assert(method->method_holder()->oop_is_instance(),
 }
 #endif
 // 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)) {
+if (compilation_is_in_queue(method)) {
 // We may want to decay our counter a bit here to prevent
 // multiple denied requests for compilation.  This is an
 // open compilation policy issue. Note: The other possibility,
 // in the case that this is a blocking compile request, is to have
 // all subsequent blocking requesters wait for completion of
 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)) {
+if (compilation_is_in_queue(method)) {
 return;
 }
 // We need to check again to see if the compilation has
 // completed.  A previous compilation may have registered
 // The compilation falls outside the allowed range.
 return;
 }
 // Should this thread wait for completion of the compile?
-blocking = is_compile_blocking(method, osr_bci);
+blocking = is_compile_blocking();
 // We will enter the compilation in the queue.
 // 14012000: Note that this sets the queued_for_compile bits in
 // the target method. We can now reason that a method cannot be
 // queued for compilation more than once, as follows:
 }
 }
 }
-// ------------------------------------------------------------------
+/**
-// CompileBroker::compilation_is_in_queue
+* See if this compilation is already requested.
-//
+*
-// See if this compilation is already requested.
+* Implementation note: there is only a single "is in queue" bit
-//
+* for each method.  This means that the check below is overly
-// Implementation note: there is only a single "is in queue" bit
+* conservative in the sense that an osr compilation in the queue
-// for each method.  This means that the check below is overly
+* will block a normal compilation from entering the queue (and vice
-// conservative in the sense that an osr compilation in the queue
+* versa).  This can be remedied by a full queue search to disambiguate
-// will block a normal compilation from entering the queue (and vice
+* cases.  If it is deemed profitable, this may be done.
-// 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) {
-bool CompileBroker::compilation_is_in_queue(methodHandle method,
-int          osr_bci) {
 return method->queued_for_compilation();
 }
 // ------------------------------------------------------------------
 // CompileBroker::compilation_is_prohibited
 // only _compilation_id is incremented.
 return Atomic::add(1, &_compilation_id);
 #endif
 }
+/**
-// ------------------------------------------------------------------
+* Should the current thread block until this compilation request
-// CompileBroker::is_compile_blocking
+* has been fulfilled?
-//
+*/
-// Should the current thread be blocked until this compilation request
+bool CompileBroker::is_compile_blocking() {
-// has been fulfilled?
-bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) {
 assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
 return !BackgroundCompilation;
 }
 int           comp_level,
 methodHandle  hot_method,
 int           hot_count,
 const char*   comment,
 bool          blocking) {
-CompileTask* new_task = allocate_task();
+CompileTask* new_task = CompileTask::allocate();
 new_task->initialize(compile_id, method, osr_bci, comp_level,
 hot_method, hot_count, comment,
 blocking);
 queue->add(new_task);
 return new_task;
 }
-// ------------------------------------------------------------------
+/**
-// CompileBroker::allocate_task
+*  Wait for the compilation task to complete.
-//
+*/
-// Allocate a CompileTask, from the free list if possible.
-CompileTask* CompileBroker::allocate_task() {
-MutexLocker locker(CompileTaskAlloc_lock);
-CompileTask* task = NULL;
-if (_task_free_list != NULL) {
-task = _task_free_list;
-_task_free_list = task->next();
-task->set_next(NULL);
-} else {
-task = new CompileTask();
-task->set_next(NULL);
-}
-return task;
-}
-// ------------------------------------------------------------------
-// CompileBroker::free_task
-//
-// Add a task to the free list.
-void CompileBroker::free_task(CompileTask* task) {
-MutexLocker locker(CompileTaskAlloc_lock);
-task->free();
-task->set_next(_task_free_list);
-_task_free_list = task;
-}
-// ------------------------------------------------------------------
-// CompileBroker::wait_for_completion
-//
-// Wait for the given method CompileTask to complete.
 void CompileBroker::wait_for_completion(CompileTask* task) {
 if (CIPrintCompileQueue) {
+ttyLocker ttyl;
 tty->print_cr("BLOCKING FOR COMPILE");
 }
 assert(task->is_blocking(), "can only wait on blocking task");
-JavaThread *thread = JavaThread::current();
+JavaThread* thread = JavaThread::current();
 thread->set_blocked_on_compilation(true);
 methodHandle method(thread, task->method());
 {
 MutexLocker waiter(task->lock(), thread);
-while (!task->is_complete())
+while (!task->is_complete() && !is_compilation_disabled_forever()) {
 task->lock()->wait();
 }
+}
+thread->set_blocked_on_compilation(false);
+if (is_compilation_disabled_forever()) {
+CompileTask::free(task);
+return;
+}
 // It is harmless to check this status without the lock, because
 // completion is a stable property (until the task object is recycled).
 assert(task->is_complete(), "Compilation should have completed");
 assert(task->code_handle() == NULL, "must be reset");
-thread->set_blocked_on_compilation(false);
 // By convention, the waiter is responsible for recycling a
 // blocking CompileTask. Since there is only one waiter ever
 // waiting on a CompileTask, we know that no one else will
 // be using this CompileTask; we can free it.
-free_task(task);
+CompileTask::free(task);
 }
-// Initialize compiler thread(s) + compiler object(s). The postcondition
+/**
-// of this function is that the compiler runtimes are initialized and that
+* Initialize compiler thread(s) + compiler object(s). The postcondition
-//compiler threads can start compiling.
+* 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");
 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
 }
 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
+* If C1 and/or C2 initialization failed, we shut down all compilation.
-// a problem.
+* 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());
+warning("%s initialization failed. Shutting down all 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);
+// Delete all queued compilation tasks to make compiler threads exit faster.
-CompileQueue* queue;
+if (_c1_compile_queue != NULL) {
-if (_c1_method_queue != NULL) {
+_c1_compile_queue->free_all();
-_c1_method_queue->delete_all();
+}
-queue = _c1_method_queue;
-_c1_method_queue = NULL;
+if (_c2_compile_queue != NULL) {
-delete _c1_method_queue;
+_c2_compile_queue->free_all();
 }
-if (_c2_method_queue != NULL) {
+// Set flags so that we continue execution with using interpreter only.
-_c2_method_queue->delete_all();
+UseCompiler    = false;
-queue = _c2_method_queue;
+UseInterpreter = true;
-_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.
 }

Mercurial > hg > graal-compiler

comparison src/share/vm/compiler/compileBroker.cpp @ 20588:41dcdd636080