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

comparison src/share/vm/compiler/compileBroker.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	6a0692faf9fd ecccc23346fe
children	07b088d61d5d

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 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,
 _hot_method = NULL;
 _hot_method_holder = NULL;
 _hot_count = hot_count;
 _time_queued = 0;  // tidy
 _comment = comment;
+_failure_reason = NULL;
 if (LogCompilation) {
 _time_queued = os::elapsed_counter();
 if (hot_method.not_null()) {
 if (hot_method == 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.
 void CompileTask::log_task_done(CompileLog* log) {
 Thread* thread = Thread::current();
 methodHandle method(thread, this->method());
 ResourceMark rm(thread);
+if (!_is_success) {
+const char* reason = _failure_reason != NULL ? _failure_reason : "unknown";
+log->elem("failure reason='%s'", reason);
+}
 // <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->content_size(),
 method->invocation_count());
 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() {
+/**
-assert(lock()->owned_by_self(), "must own lock");
+* Empties compilation queue by putting all compilation tasks onto
-if (_first != NULL) {
+* a freelist. Furthermore, the method wakes up all threads that are
-for (CompileTask* task = _first; task != NULL; task = task->next()) {
+* waiting on a compilation task to finish. This can happen if background
-delete task;
+* compilation is disabled.
-}
+*/
-_first = NULL;
+void CompileQueue::free_all() {
-}
+MutexLocker mu(lock());
+CompileTask* next = _first;
+// Iterate over all tasks in the compile queue
+while (next != NULL) {
+CompileTask* current = next;
+next = current->next();
+{
+// Wake up thread that blocks on the compile task.
+MutexLocker ct_lock(current->lock());
+current->lock()->notify();
+}
+// Put the task back on the freelist.
+CompileTask::free(current);
+}
+_first = NULL;
+// Wake up all threads that block on the queue.
+lock()->notify_all();
 }
 // ------------------------------------------------------------------
 // CompileQueue::get
 //
 if (CompileBroker::is_compilation_disabled_forever()) {
 return NULL;
 }
-CompileTask* task = CompilationPolicy::policy()->select_task(this);
+CompileTask* task;
+{
+No_Safepoint_Verifier nsv;
+task = CompilationPolicy::policy()->select_task(this);
+}
 remove(task);
+purge_stale_tasks(); // may temporarily release MCQ lock
 return task;
 }
-void CompileQueue::remove(CompileTask* task)
+// Clean & deallocate stale compile tasks.
-{
+// Temporarily releases MethodCompileQueue lock.
+void CompileQueue::purge_stale_tasks() {
+assert(lock()->owned_by_self(), "must own lock");
+if (_first_stale != NULL) {
+// Stale tasks are purged when MCQ lock is released,
+// but _first_stale updates are protected by MCQ lock.
+// Once task processing starts and MCQ lock is released,
+// other compiler threads can reuse _first_stale.
+CompileTask* head = _first_stale;
+_first_stale = NULL;
+{
+MutexUnlocker ul(lock());
+for (CompileTask* task = head; task != NULL; ) {
+CompileTask* next_task = task->next();
+CompileTaskWrapper ctw(task); // Frees the task
+task->set_failure_reason("stale task");
+task = next_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
 _last = task->prev();
 }
 --_size;
 }
+void CompileQueue::remove_and_mark_stale(CompileTask* task) {
+assert(lock()->owned_by_self(), "must own lock");
+remove(task);
+// Enqueue the task for reclamation (should be done outside MCQ lock)
+task->set_next(_first_stale);
+task->set_prev(NULL);
+_first_stale = task;
+}
 // methods in the compile queue need to be marked as used on the stack
 // so that they don't get reclaimed by Redefine Classes
 void CompileQueue::mark_on_stack() {
 CompileTask* task = _first;
 while (task != NULL) {
 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) && !defined(COMPILERGRAAL)
 assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
 #endif // !ZERO && !SHARK && !COMPILERGRAAL
 // 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, "%s CompilerThread%d", _compilers[1]->name(), 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. This method is executed at a safepoint.
+*/
 void CompileBroker::mark_on_stack() {
-if (_c2_method_queue != NULL) {
+assert(SafepointSynchronize::is_at_safepoint(), "sanity check");
-_c2_method_queue->mark_on_stack();
+// Since we are at a safepoint, we do not need a lock to access
-}
+// the compile queues.
-if (_c1_method_queue != NULL) {
+if (_c2_compile_queue != NULL) {
-_c1_method_queue->mark_on_stack();
+_c2_compile_queue->mark_on_stack();
+}
+if (_c1_compile_queue != NULL) {
+_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
 // by a compiler thread), and compiled method registration.
 if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
 return;
 }
+if (TieredCompilation) {
+// Tiered policy requires MethodCounters to exist before adding a method to
+// the queue. Create if we don't have them yet.
+method->get_method_counters(thread);
+}
 // Outputs from the following MutexLocker block:
 CompileTask* task     = NULL;
 bool         blocking = false;
 CompileQueue* queue  = compile_queue(comp_level);
 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();
 #ifdef COMPILERGRAAL
 if (blocking) {
 // Don't allow blocking compiles for requests triggered by Graal.
 if (thread->is_Compiler_thread()) {
 }
 }
 }
-// ------------------------------------------------------------------
+/**
-// 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
 uint CompileBroker::assign_compile_id_unlocked(Thread* thread, methodHandle method, int osr_bci) {
 MutexLocker locker(MethodCompileQueue_lock, thread);
 return assign_compile_id(method, osr_bci);
 }
+/**
-// ------------------------------------------------------------------
+* 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.
 }
 // 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();
+task->set_failure_reason("compilation is disabled");
 }
 }
 }
 // Shut down compiler runtime
 jio_snprintf(file_name, sizeof(file_name),
 "%s%shs_c" UINTX_FORMAT "_pid%u.log", dir,
 os::file_separator(), thread_id, os::current_process_id());
 }
-fp = fopen(file_name, "at");
+fp = fopen(file_name, "wt");
 if (fp != NULL) {
 if (LogCompilation && Verbose) {
 tty->print_cr("Opening compilation log %s", file_name);
 }
 CompileLog* log = new(ResourceObj::C_HEAP, mtCompiler) CompileLog(file_name, fp, thread_id);
 // Copy this bit to the enclosing block:
 compilable = ci_env.compilable();
 if (ci_env.failing()) {
+task->set_failure_reason(ci_env.failure_reason());
 const char* retry_message = ci_env.retry_message();
 if (_compilation_log != NULL) {
 _compilation_log->log_failure(thread, task, ci_env.failure_reason(), retry_message);
 }
 if (PrintCompilation) {
 break;
 }
 // Note that the queued_for_compilation bits are cleared without
 // protection of a mutex. [They were set by the requester thread,
-// when adding the task to the complie queue -- at which time the
+// when adding the task to the compile queue -- at which time the
 // compile queue lock was held. Subsequently, we acquired the compile
 // queue lock to get this task off the compile queue; thus (to belabour
 // the point somewhat) our clearing of the bits must be occurring
 // only after the setting of the bits. See also 14012000 above.
 method->clear_queued_for_compilation();

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/compiler/compileBroker.cpp @ 20804:7848fc12602b