src/share/vm/runtime/advancedThresholdPolicy.cpp

*** 25,34 ****
--- 25,37 ----
  #include "precompiled.hpp"
  #include "code/codeCache.hpp"
  #include "compiler/compileTask.hpp"
  #include "runtime/advancedThresholdPolicy.hpp"
  #include "runtime/simpleThresholdPolicy.inline.hpp"
+ #if INCLUDE_JVMCI
+ #include "jvmci/jvmciRuntime.hpp"
+ #endif
  
  #ifdef TIERED
  // Print an event.
  void AdvancedThresholdPolicy::print_specific(EventType type, methodHandle mh, methodHandle imh,
                                               int bci, CompLevel level) {
*** 451,461 ****
    }
    return MIN2(next_level, (CompLevel)TieredStopAtLevel);
  }
  
  // Determine if a method should be compiled with a normal entry point at a different level.
! CompLevel AdvancedThresholdPolicy::call_event(Method* method, CompLevel cur_level) {
    CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(),
                               common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true));
    CompLevel next_level = common(&AdvancedThresholdPolicy::call_predicate, method, cur_level);
  
    // If OSR method level is greater than the regular method level, the levels should be
--- 454,464 ----
    }
    return MIN2(next_level, (CompLevel)TieredStopAtLevel);
  }
  
  // Determine if a method should be compiled with a normal entry point at a different level.
! CompLevel AdvancedThresholdPolicy::call_event(Method* method, CompLevel cur_level, JavaThread * thread) {
    CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(),
                               common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true));
    CompLevel next_level = common(&AdvancedThresholdPolicy::call_predicate, method, cur_level);
  
    // If OSR method level is greater than the regular method level, the levels should be
*** 468,491 ****
        next_level = CompLevel_full_optimization;
      }
    } else {
      next_level = MAX2(osr_level, next_level);
    }
    return next_level;
  }
  
  // Determine if we should do an OSR compilation of a given method.
! CompLevel AdvancedThresholdPolicy::loop_event(Method* method, CompLevel cur_level) {
    CompLevel next_level = common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true);
    if (cur_level == CompLevel_none) {
      // If there is a live OSR method that means that we deopted to the interpreter
      // for the transition.
      CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level);
      if (osr_level > CompLevel_none) {
        return osr_level;
      }
    }
    return next_level;
  }
  
  // Update the rate and submit compile
  void AdvancedThresholdPolicy::submit_compile(const methodHandle& mh, int bci, CompLevel level, JavaThread* thread) {
--- 471,504 ----
        next_level = CompLevel_full_optimization;
      }
    } else {
      next_level = MAX2(osr_level, next_level);
    }
+ #if INCLUDE_JVMCI
+   if (UseJVMCICompiler) {
+     next_level = JVMCIRuntime::adjust_comp_level(method, false, next_level, thread);
+   }
+ #endif
    return next_level;
  }
  
  // Determine if we should do an OSR compilation of a given method.
! CompLevel AdvancedThresholdPolicy::loop_event(Method* method, CompLevel cur_level, JavaThread * thread) {
    CompLevel next_level = common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true);
    if (cur_level == CompLevel_none) {
      // If there is a live OSR method that means that we deopted to the interpreter
      // for the transition.
      CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level);
      if (osr_level > CompLevel_none) {
        return osr_level;
      }
    }
+ #if INCLUDE_JVMCI
+   if (UseJVMCICompiler) {
+     next_level = JVMCIRuntime::adjust_comp_level(method, true, next_level, thread);
+   }
+ #endif
    return next_level;
  }
  
  // Update the rate and submit compile
  void AdvancedThresholdPolicy::submit_compile(const methodHandle& mh, int bci, CompLevel level, JavaThread* thread) {
*** 499,509 ****
                                                        CompLevel level, CompiledMethod* nm, JavaThread* thread) {
    if (should_create_mdo(mh(), level)) {
      create_mdo(mh, thread);
    }
    if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh)) {
!     CompLevel next_level = call_event(mh(), level);
      if (next_level != level) {
        compile(mh, InvocationEntryBci, next_level, thread);
      }
    }
  }
--- 512,522 ----
                                                        CompLevel level, CompiledMethod* nm, JavaThread* thread) {
    if (should_create_mdo(mh(), level)) {
      create_mdo(mh, thread);
    }
    if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh)) {
!     CompLevel next_level = call_event(mh(), level, thread);
      if (next_level != level) {
        compile(mh, InvocationEntryBci, next_level, thread);
      }
    }
  }
*** 519,529 ****
    if (should_create_mdo(imh(), level)) {
      create_mdo(imh, thread);
    }
  
    if (is_compilation_enabled()) {
!     CompLevel next_osr_level = loop_event(imh(), level);
      CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
      // At the very least compile the OSR version
      if (!CompileBroker::compilation_is_in_queue(imh) && (next_osr_level != level)) {
        compile(imh, bci, next_osr_level, thread);
      }
--- 532,542 ----
    if (should_create_mdo(imh(), level)) {
      create_mdo(imh, thread);
    }
  
    if (is_compilation_enabled()) {
!     CompLevel next_osr_level = loop_event(imh(), level, thread);
      CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
      // At the very least compile the OSR version
      if (!CompileBroker::compilation_is_in_queue(imh) && (next_osr_level != level)) {
        compile(imh, bci, next_osr_level, thread);
      }
*** 532,542 ****
      // enough calls.
      CompLevel cur_level, next_level;
      if (mh() != imh()) { // If there is an enclosing method
        guarantee(nm != NULL, "Should have nmethod here");
        cur_level = comp_level(mh());
!       next_level = call_event(mh(), cur_level);
  
        if (max_osr_level == CompLevel_full_optimization) {
          // The inlinee OSRed to full opt, we need to modify the enclosing method to avoid deopts
          bool make_not_entrant = false;
          if (nm->is_osr_method()) {
--- 545,555 ----
      // enough calls.
      CompLevel cur_level, next_level;
      if (mh() != imh()) { // If there is an enclosing method
        guarantee(nm != NULL, "Should have nmethod here");
        cur_level = comp_level(mh());
!       next_level = call_event(mh(), cur_level, thread);
  
        if (max_osr_level == CompLevel_full_optimization) {
          // The inlinee OSRed to full opt, we need to modify the enclosing method to avoid deopts
          bool make_not_entrant = false;
          if (nm->is_osr_method()) {
*** 567,577 ****
            compile(mh, InvocationEntryBci, next_level, thread);
          }
        }
      } else {
        cur_level = comp_level(imh());
!       next_level = call_event(imh(), cur_level);
        if (!CompileBroker::compilation_is_in_queue(imh) && (next_level != cur_level)) {
          compile(imh, InvocationEntryBci, next_level, thread);
        }
      }
    }
--- 580,590 ----
            compile(mh, InvocationEntryBci, next_level, thread);
          }
        }
      } else {
        cur_level = comp_level(imh());
!       next_level = call_event(imh(), cur_level, thread);
        if (!CompileBroker::compilation_is_in_queue(imh) && (next_level != cur_level)) {
          compile(imh, InvocationEntryBci, next_level, thread);
        }
      }
    }