jdk-sandbox: comparison src/hotspot/share/runtime/compilationPolicy.cpp

equal deleted inserted replaced

-:2d40e6a7ce8e
+:ff559f979c4b
 #endif
 return compile_queue->first();
 }
 #ifndef PRODUCT
-void NonTieredCompPolicy::trace_osr_completion(nmethod* osr_nm) {
+void SimpleCompPolicy::trace_osr_completion(nmethod* osr_nm) {
 if (TraceOnStackReplacement) {
 if (osr_nm == NULL) tty->print_cr("compilation failed");
 else tty->print_cr("nmethod " INTPTR_FORMAT, p2i(osr_nm));
 }
 }
 #endif // !PRODUCT
-void NonTieredCompPolicy::initialize() {
+void SimpleCompPolicy::initialize() {
 // Setup the compiler thread numbers
 if (CICompilerCountPerCPU) {
 // Example: if CICompilerCountPerCPU is true, then we get
 // max(log2(8)-1,1) = 2 compiler threads on an 8-way machine.
 // May help big-app startup time.
 //   zero for the c1 compilation levels in server compilation mode runs
 //   and c2 compilation levels in client compilation mode runs.
 // - with COMPILER2 not defined it should return zero for c2 compilation levels.
 // - with COMPILER1 not defined it should return zero for c1 compilation levels.
 // - if neither is defined - always return zero.
-int NonTieredCompPolicy::compiler_count(CompLevel comp_level) {
+int SimpleCompPolicy::compiler_count(CompLevel comp_level) {
 assert(!TieredCompilation, "This policy should not be used with TieredCompilation");
 if (COMPILER2_PRESENT(is_server_compilation_mode_vm() && is_c2_compile(comp_level) ||)
 is_client_compilation_mode_vm() && is_c1_compile(comp_level)) {
 return _compiler_count;
 }
 return 0;
 }
-void NonTieredCompPolicy::reset_counter_for_invocation_event(const methodHandle& m) {
+void SimpleCompPolicy::reset_counter_for_invocation_event(const methodHandle& m) {
 // Make sure invocation and backedge counter doesn't overflow again right away
 // as would be the case for native methods.
 // BUT also make sure the method doesn't look like it was never executed.
 // Set carry bit and reduce counter's value to min(count, CompileThreshold/2).
 mcs->backedge_counter()->set_carry();
 assert(!m->was_never_executed(), "don't reset to 0 -- could be mistaken for never-executed");
 }
-void NonTieredCompPolicy::reset_counter_for_back_branch_event(const methodHandle& m) {
+void SimpleCompPolicy::reset_counter_for_back_branch_event(const methodHandle& m) {
 // Delay next back-branch event but pump up invocation counter to trigger
 // whole method compilation.
 MethodCounters* mcs = m->method_counters();
 assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 InvocationCounter* i = mcs->invocation_counter();
 }
 }
 }
 // Called at the end of the safepoint
-void NonTieredCompPolicy::do_safepoint_work() {
+void SimpleCompPolicy::do_safepoint_work() {
 if(UseCounterDecay && CounterDecay::is_decay_needed()) {
 CounterDecay::decay();
 }
 }
-void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
+void SimpleCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
 ScopeDesc* sd = trap_scope;
 MethodCounters* mcs;
 InvocationCounter* c;
 for (; !sd->is_top(); sd = sd->sender()) {
 mcs = sd->method()->method_counters();
 }
 }
 // This method can be called by any component of the runtime to notify the policy
 // that it's recommended to delay the compilation of this method.
-void NonTieredCompPolicy::delay_compilation(Method* method) {
+void SimpleCompPolicy::delay_compilation(Method* method) {
 MethodCounters* mcs = method->method_counters();
 if (mcs != NULL) {
 mcs->invocation_counter()->decay();
 mcs->backedge_counter()->decay();
 }
 }
-void NonTieredCompPolicy::disable_compilation(Method* method) {
+void SimpleCompPolicy::disable_compilation(Method* method) {
 MethodCounters* mcs = method->method_counters();
 if (mcs != NULL) {
 mcs->invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
 mcs->backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
 }
 }
-CompileTask* NonTieredCompPolicy::select_task(CompileQueue* compile_queue) {
+CompileTask* SimpleCompPolicy::select_task(CompileQueue* compile_queue) {
 return select_task_helper(compile_queue);
 }
-bool NonTieredCompPolicy::is_mature(Method* method) {
+bool SimpleCompPolicy::is_mature(Method* method) {
 MethodData* mdo = method->method_data();
 assert(mdo != NULL, "Should be");
 uint current = mdo->mileage_of(method);
 uint initial = mdo->creation_mileage();
 if (current < initial)
 else
 target = (uint)( (ProfileMaturityPercentage * CompileThreshold) / 100 );
 return (current >= initial + target);
 }
-nmethod* NonTieredCompPolicy::event(const methodHandle& method, const methodHandle& inlinee, int branch_bci,
+nmethod* SimpleCompPolicy::event(const methodHandle& method, const methodHandle& inlinee, int branch_bci,
 int bci, CompLevel comp_level, CompiledMethod* nm, JavaThread* thread) {
 assert(comp_level == CompLevel_none, "This should be only called from the interpreter");
 NOT_PRODUCT(trace_frequency_counter_overflow(method, branch_bci, bci));
 if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) {
 // If certain JVMTI events (e.g. frame pop event) are requested then the
 }
 return NULL;
 }
 #ifndef PRODUCT
-void NonTieredCompPolicy::trace_frequency_counter_overflow(const methodHandle& m, int branch_bci, int bci) {
+void SimpleCompPolicy::trace_frequency_counter_overflow(const methodHandle& m, int branch_bci, int bci) {
 if (TraceInvocationCounterOverflow) {
 MethodCounters* mcs = m->method_counters();
 assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 InvocationCounter* ic = mcs->invocation_counter();
 InvocationCounter* bc = mcs->backedge_counter();
 }
 }
 }
 }
-void NonTieredCompPolicy::trace_osr_request(const methodHandle& method, nmethod* osr, int bci) {
+void SimpleCompPolicy::trace_osr_request(const methodHandle& method, nmethod* osr, int bci) {
 if (TraceOnStackReplacement) {
 ResourceMark rm;
 tty->print(osr != NULL ? "Reused OSR entry for " : "Requesting OSR entry for ");
 method->print_short_name(tty);
 tty->print_cr(" at bci %d", bci);
 }
 }
 #endif // !PRODUCT
-// SimpleCompPolicy - compile current method
 void SimpleCompPolicy::method_invocation_event(const methodHandle& m, JavaThread* thread) {
 const int comp_level = CompLevel_highest_tier;
 const int hot_count = m->invocation_count();
 reset_counter_for_invocation_event(m);

changeset 58398	ff559f979c4b
parent 58367	b3ca57ddfc92