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

comparison src/share/vm/compiler/compileBroker.cpp @ 22719:44bc739eae23

fixed logic deciding who frees the CompileTask for a JVMCI blocking compilation

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 02 Nov 2015 23:53:10 +0100
parents	9b3b66634d17
children	24fd08e99b35

comparison

equal deleted inserted replaced

-:f04d84a5f7c5
+:44bc739eae23
 if (log != NULL)  task->log_task_done(log);
 thread->set_task(NULL);
 task->set_code_handle(NULL);
 thread->set_env(NULL);
 if (task->is_blocking()) {
-MutexLocker notifier(task->lock(), thread);
+bool free_task = false;
-task->mark_complete();
+{
-// Notify the waiting thread that the compilation has completed.
+MutexLocker notifier(task->lock(), thread);
-task->lock()->notify_all();
+task->mark_complete();
 #ifdef COMPILERJVMCI
 if (CompileBroker::compiler(task->comp_level())->is_jvmci()) {
 // Blocking JVMCI compilations are performed with a timeout so as
 // to avoid deadlock between an application thread and a JVMCI
-// compiler thread (both of which execute Java code). In this case,
+// compiler thread (both of which execute Java code).
-// the compiling thread recycles the CompileTask.
+if (task->has_waiter()) {
+// Notify the waiting thread that the compilation has completed
+// and let it free the CompileTask.
+task->lock()->notify_all();
+} else {
+// The waiting thread timed out did not free the task.
+free_task = true;
+}
+} else {
+// Notify the waiting thread that the compilation has completed.
+task->lock()->notify_all();
+}
+#else
+// Notify the waiting thread that the compilation has completed.
+task->lock()->notify_all();
+#endif
+}
+if (free_task) {
+// The task can only be freed once the task lock is released.
 CompileTask::free(task);
 }
-#endif
 } else {
 task->mark_complete();
 // By convention, the compiling thread is responsible for
 // recycling a non-blocking CompileTask.
 _compile_id = compile_id;
 _method = method();
 _method_holder = JNIHandles::make_global(method->method_holder()->klass_holder());
 _osr_bci = osr_bci;
 _is_blocking = is_blocking;
+COMPILERJVMCI_PRESENT(_has_waiter = CompileBroker::compiler(comp_level)->is_jvmci();)
 _comp_level = comp_level;
 _num_inlined_bytecodes = 0;
 _is_complete = false;
 _is_success = false;
 JavaThread* thread = JavaThread::current();
 thread->set_blocked_on_compilation(true);
 methodHandle method(thread, task->method());
-{
+bool free_task = true;
-MutexLocker waiter(task->lock(), thread);
 #ifdef COMPILERJVMCI
 if (compiler(task->comp_level())->is_jvmci()) {
+{
+MutexLocker waiter(task->lock(), thread);
 // No need to check if compilation has completed - just
 // rely on the time out. The JVMCI compiler thread will
 // recycle the CompileTask.
 task->lock()->wait(!Mutex::_no_safepoint_check_flag, BLOCKING_JVMCI_COMPILATION_TIMEOUT);
-thread->set_blocked_on_compilation(false);
+// If the compilation completes while has_waiter is true then
-return;
+// this thread is responsible for freeing the task.  Otherwise
-}
+// the compiler thread will free the task.
+task->clear_waiter();
+free_task = task->is_complete();
+}
+} else
 #endif
+{
+MutexLocker waiter(task->lock(), thread);
 while (!task->is_complete() && !is_compilation_disabled_forever()) {
 task->lock()->wait();
 }
 }
 thread->set_blocked_on_compilation(false);
-if (is_compilation_disabled_forever()) {
+if (free_task) {
+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");
+// 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.
 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");
-// 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.
-CompileTask::free(task);
 }
 /**
 * Initialize compiler thread(s) + compiler object(s). The postcondition
 * of this function is that the compiler runtimes are initialized and that

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/compiler/compileBroker.cpp @ 22719:44bc739eae23