src/share/vm/runtime/advancedThresholdPolicy.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 22,31 ****
--- 22,32 ----
   *
   */
  
  #include "precompiled.hpp"
  #include "code/codeCache.hpp"
+ #include "compiler/compileTask.hpp"
  #include "runtime/advancedThresholdPolicy.hpp"
  #include "runtime/simpleThresholdPolicy.inline.hpp"
  
  #ifdef TIERED
  // Print an event.
*** 160,169 ****
--- 161,173 ----
    return false;
  }
  
  // Called with the queue locked and with at least one element
  CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
+ #if INCLUDE_JVMCI
+   CompileTask *max_non_jvmci_task = NULL;
+ #endif
    CompileTask *max_task = NULL;
    Method* max_method = NULL;
    jlong t = os::javaTimeMillis();
    // Iterate through the queue and find a method with a maximum rate.
    for (CompileTask* task = compile_queue->first(); task != NULL;) {
*** 177,186 ****
--- 181,191 ----
        // If a method has been stale for some time, remove it from the queue.
        if (is_stale(t, TieredCompileTaskTimeout, method) && !is_old(method)) {
          if (PrintTieredEvents) {
            print_event(REMOVE_FROM_QUEUE, method, method, task->osr_bci(), (CompLevel)task->comp_level());
          }
+         task->log_task_dequeued("stale");
          compile_queue->remove_and_mark_stale(task);
          method->clear_queued_for_compilation();
          task = next_task;
          continue;
        }
*** 192,201 ****
--- 197,215 ----
        }
      }
      task = next_task;
    }
  
+ #if INCLUDE_JVMCI
+   if (UseJVMCICompiler) {
+     if (max_non_jvmci_task != NULL) {
+       max_task = max_non_jvmci_task;
+       max_method = max_task->method();
+     }
+   }
+ #endif
+ 
    if (max_task->comp_level() == CompLevel_full_profile && TieredStopAtLevel > CompLevel_full_profile
        && is_method_profiled(max_method)) {
      max_task->set_comp_level(CompLevel_limited_profile);
      if (PrintTieredEvents) {
        print_event(UPDATE_IN_QUEUE, max_method, max_method, max_task->osr_bci(), (CompLevel)max_task->comp_level());
*** 352,361 ****
--- 366,383 ----
      case CompLevel_none:
        // If we were at full profile level, would we switch to full opt?
        if (common(p, method, CompLevel_full_profile, disable_feedback) == CompLevel_full_optimization) {
          next_level = CompLevel_full_optimization;
        } else if ((this->*p)(i, b, cur_level, method)) {
+ #if INCLUDE_JVMCI
+         if (UseJVMCICompiler) {
+           // Since JVMCI takes a while to warm up, its queue inevitably backs up during
+           // early VM execution.
+           next_level = CompLevel_full_profile;
+           break;
+         }
+ #endif
          // C1-generated fully profiled code is about 30% slower than the limited profile
          // code that has only invocation and backedge counters. The observation is that
          // if C2 queue is large enough we can spend too much time in the fully profiled code
          // while waiting for C2 to pick the method from the queue. To alleviate this problem
          // we introduce a feedback on the C2 queue size. If the C2 queue is sufficiently long