src/hotspot/share/runtime/tieredThresholdPolicy.cpp
changeset 54647 c0d9bc9b4e1f
parent 54015 cd701366fcf8
child 54669 ad45b3802d4e
equal deleted inserted replaced
54646:5b1eec609909 54647:c0d9bc9b4e1f
    86 bool TieredThresholdPolicy::is_trivial(Method* method) {
    86 bool TieredThresholdPolicy::is_trivial(Method* method) {
    87   if (method->is_accessor() ||
    87   if (method->is_accessor() ||
    88       method->is_constant_getter()) {
    88       method->is_constant_getter()) {
    89     return true;
    89     return true;
    90   }
    90   }
       
    91   return false;
       
    92 }
       
    93 
       
    94 bool TieredThresholdPolicy::should_compile_at_level_simple(Method* method) {
       
    95   if (TieredThresholdPolicy::is_trivial(method)) {
       
    96     return true;
       
    97   }
       
    98 #if INCLUDE_JVMCI
       
    99   if (UseJVMCICompiler) {
       
   100     AbstractCompiler* comp = CompileBroker::compiler(CompLevel_full_optimization);
       
   101     if (comp != NULL && comp->is_jvmci() && ((JVMCICompiler*) comp)->force_comp_at_level_simple(method)) {
       
   102       return true;
       
   103     }
       
   104   }
       
   105 #endif
    91   return false;
   106   return false;
    92 }
   107 }
    93 
   108 
    94 CompLevel TieredThresholdPolicy::comp_level(Method* method) {
   109 CompLevel TieredThresholdPolicy::comp_level(Method* method) {
    95   CompiledMethod *nm = method->code();
   110   CompiledMethod *nm = method->code();
   611   }
   626   }
   612 }
   627 }
   613 
   628 
   614 // Determine is a method is mature.
   629 // Determine is a method is mature.
   615 bool TieredThresholdPolicy::is_mature(Method* method) {
   630 bool TieredThresholdPolicy::is_mature(Method* method) {
   616   if (is_trivial(method)) return true;
   631   if (should_compile_at_level_simple(method)) return true;
   617   MethodData* mdo = method->method_data();
   632   MethodData* mdo = method->method_data();
   618   if (mdo != NULL) {
   633   if (mdo != NULL) {
   619     int i = mdo->invocation_count();
   634     int i = mdo->invocation_count();
   620     int b = mdo->backedge_count();
   635     int b = mdo->backedge_count();
   621     double k = ProfileMaturityPercentage / 100.0;
   636     double k = ProfileMaturityPercentage / 100.0;
   707 CompLevel TieredThresholdPolicy::common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback) {
   722 CompLevel TieredThresholdPolicy::common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback) {
   708   CompLevel next_level = cur_level;
   723   CompLevel next_level = cur_level;
   709   int i = method->invocation_count();
   724   int i = method->invocation_count();
   710   int b = method->backedge_count();
   725   int b = method->backedge_count();
   711 
   726 
   712   if (is_trivial(method)) {
   727   if (should_compile_at_level_simple(method)) {
   713     next_level = CompLevel_simple;
   728     next_level = CompLevel_simple;
   714   } else {
   729   } else {
   715     switch(cur_level) {
   730     switch(cur_level) {
   716       default: break;
   731       default: break;
   717       case CompLevel_aot: {
   732       case CompLevel_aot: {
   823       next_level = CompLevel_full_optimization;
   838       next_level = CompLevel_full_optimization;
   824     }
   839     }
   825   } else {
   840   } else {
   826     next_level = MAX2(osr_level, next_level);
   841     next_level = MAX2(osr_level, next_level);
   827   }
   842   }
   828 #if INCLUDE_JVMCI
       
   829   if (UseJVMCICompiler) {
       
   830     next_level = JVMCIRuntime::adjust_comp_level(method, false, next_level, thread);
       
   831   }
       
   832 #endif
       
   833   return next_level;
   843   return next_level;
   834 }
   844 }
   835 
   845 
   836 // Determine if we should do an OSR compilation of a given method.
   846 // Determine if we should do an OSR compilation of a given method.
   837 CompLevel TieredThresholdPolicy::loop_event(Method* method, CompLevel cur_level, JavaThread* thread) {
   847 CompLevel TieredThresholdPolicy::loop_event(Method* method, CompLevel cur_level, JavaThread* thread) {
   842     CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level);
   852     CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level);
   843     if (osr_level > CompLevel_none) {
   853     if (osr_level > CompLevel_none) {
   844       return osr_level;
   854       return osr_level;
   845     }
   855     }
   846   }
   856   }
   847 #if INCLUDE_JVMCI
       
   848   if (UseJVMCICompiler) {
       
   849     next_level = JVMCIRuntime::adjust_comp_level(method, true, next_level, thread);
       
   850   }
       
   851 #endif
       
   852   return next_level;
   857   return next_level;
   853 }
   858 }
   854 
   859 
   855 bool TieredThresholdPolicy::maybe_switch_to_aot(const methodHandle& mh, CompLevel cur_level, CompLevel next_level, JavaThread* thread) {
   860 bool TieredThresholdPolicy::maybe_switch_to_aot(const methodHandle& mh, CompLevel cur_level, CompLevel next_level, JavaThread* thread) {
   856   if (UseAOT) {
   861   if (UseAOT) {