src/share/vm/runtime/advancedThresholdPolicy.cpp

@@ -189,11 +189,11 @@
     }
     task = next_task;
   }
 
   if (max_task->comp_level() == CompLevel_full_profile && TieredStopAtLevel > CompLevel_full_profile
-      && is_method_profiled(max_method)) {
+      && is_method_profiled(max_method) && CompLevel_limited_profile >= TieredStartAtLevel) {
     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());
     }
   }

@@ -395,11 +395,12 @@
         }
       }
       break;
     }
   }
-  return MIN2(next_level, (CompLevel)TieredStopAtLevel);
+  next_level = MIN2(next_level, (CompLevel)TieredStopAtLevel);
+  return       MAX2(next_level, (CompLevel)TieredStartAtLevel);
 }
 
 // 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(),

@@ -469,10 +470,16 @@
   }
 
   if (is_compilation_enabled()) {
     CompLevel next_osr_level = loop_event(imh(), level);
     CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
+    next_osr_level = MIN2((CompLevel)TieredStartAtLevel, next_osr_level);
+    // Do not compile of TieredStartAtLevel > max_osr_level
+    if (next_osr_level > max_osr_level) {
+      return;
+    }
+
     // At the very least compile the OSR version
     if (!CompileBroker::compilation_is_in_queue(imh, bci) && next_osr_level != level) {
       compile(imh, bci, next_osr_level, thread);
     }
 

@@ -516,11 +523,11 @@
         }
       }
     } else {
       cur_level = comp_level(imh());
       next_level = call_event(imh(), cur_level);
-      if (!CompileBroker::compilation_is_in_queue(imh, bci) && next_level != cur_level) {
+      if (!CompileBroker::compilation_is_in_queue(imh, bci) && next_level != cur_level && next_level >= TieredStartAtLevel) {
         compile(imh, InvocationEntryBci, next_level, thread);
       }
     }
   }
 }