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

equal deleted inserted replaced

-:e3aa9f95b85e
+:54c1ba464b78
 #include "oops/oop.inline.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/compilationPolicy.hpp"
 #include "runtime/frame.hpp"
 #include "runtime/handles.inline.hpp"
-#include "runtime/rframe.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/thread.hpp"
 #include "runtime/tieredThresholdPolicy.hpp"
 #include "runtime/vframe.hpp"
 #include "runtime/vmOperations.hpp"
 CompilationPolicy* CompilationPolicy::_policy;
 // Determine compilation policy based on command line argument
 void compilationPolicy_init() {
-switch(CompilationPolicyChoice) {
+#ifdef TIERED
-case 0:
+if (TieredCompilation) {
+CompilationPolicy::set_policy(new TieredThresholdPolicy());
+} else {
 CompilationPolicy::set_policy(new SimpleCompPolicy());
-break;
+}
+#else
-case 1:
+CompilationPolicy::set_policy(new SimpleCompPolicy());
-#ifdef COMPILER2
+#endif
-CompilationPolicy::set_policy(new StackWalkCompPolicy());
-#else
-Unimplemented();
-#endif
-break;
-case 2:
-#ifdef TIERED
-CompilationPolicy::set_policy(new TieredThresholdPolicy());
-#else
-Unimplemented();
-#endif
-break;
-default:
-fatal("CompilationPolicyChoice must be in the range: [0-2]");
-}
 CompilationPolicy::policy()->initialize();
 }
 // Returns true if m must be compiled before executing it
 // This is intended to force compiles for methods (usually for
 #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);
 if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
 CompileBroker::compile_method(m, bci, comp_level, m, hot_count, CompileTask::Reason_BackedgeCount, thread);
 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
 }
 }
-// StackWalkCompPolicy - walk up stack to find a suitable method to compile
-#ifdef COMPILER2
-const char* StackWalkCompPolicy::_msg = NULL;
-// Consider m for compilation
-void StackWalkCompPolicy::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);
-if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m, comp_level)) {
-ResourceMark rm(thread);
-frame       fr     = thread->last_frame();
-assert(fr.is_interpreted_frame(), "must be interpreted");
-assert(fr.interpreter_frame_method() == m(), "bad method");
-RegisterMap reg_map(thread, false);
-javaVFrame* triggerVF = thread->last_java_vframe(&reg_map);
-// triggerVF is the frame that triggered its counter
-RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m());
-if (first->top_method()->code() != NULL) {
-// called obsolete method/nmethod -- no need to recompile
-} else {
-GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50);
-stack->push(first);
-RFrame* top = findTopInlinableFrame(stack);
-assert(top != NULL, "findTopInlinableFrame returned null");
-CompileBroker::compile_method(top->top_method(), InvocationEntryBci, comp_level,
-m, hot_count, CompileTask::Reason_InvocationCount, thread);
-}
-}
-}
-void StackWalkCompPolicy::method_back_branch_event(const methodHandle& m, int bci, JavaThread* thread) {
-const int comp_level = CompLevel_highest_tier;
-const int hot_count = m->backedge_count();
-if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
-CompileBroker::compile_method(m, bci, comp_level, m, hot_count, CompileTask::Reason_BackedgeCount, thread);
-NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
-}
-}
-RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) {
-// go up the stack until finding a frame that (probably) won't be inlined
-// into its caller
-RFrame* current = stack->at(0); // current choice for stopping
-assert( current && !current->is_compiled(), "" );
-const char* msg = NULL;
-while (1) {
-// before going up the stack further, check if doing so would get us into
-// compiled code
-RFrame* next = senderOf(current, stack);
-if( !next )               // No next frame up the stack?
-break;                  // Then compile with current frame
-Method* m = current->top_method();
-Method* next_m = next->top_method();
-if( !Inline ) {           // Inlining turned off
-msg = "Inlining turned off";
-break;
-}
-if (next_m->is_not_compilable()) { // Did fail to compile this before/
-msg = "caller not compilable";
-break;
-}
-if (next->num() > MaxRecompilationSearchLength) {
-// don't go up too high when searching for recompilees
-msg = "don't go up any further: > MaxRecompilationSearchLength";
-break;
-}
-if (next->distance() > MaxInterpretedSearchLength) {
-// don't go up too high when searching for recompilees
-msg = "don't go up any further: next > MaxInterpretedSearchLength";
-break;
-}
-// Compiled frame above already decided not to inline;
-// do not recompile him.
-if (next->is_compiled()) {
-msg = "not going up into optimized code";
-break;
-}
-// Interpreted frame above us was already compiled.  Do not force
-// a recompile, although if the frame above us runs long enough an
-// OSR might still happen.
-if( current->is_interpreted() && next_m->has_compiled_code() ) {
-msg = "not going up -- already compiled caller";
-break;
-}
-// Compute how frequent this call site is.  We have current method 'm'.
-// We know next method 'next_m' is interpreted.  Find the call site and
-// check the various invocation counts.
-int invcnt = 0;             // Caller counts
-if (ProfileInterpreter) {
-invcnt = next_m->interpreter_invocation_count();
-}
-int cnt = 0;                // Call site counts
-if (ProfileInterpreter && next_m->method_data() != NULL) {
-ResourceMark rm;
-int bci = next->top_vframe()->bci();
-ProfileData* data = next_m->method_data()->bci_to_data(bci);
-if (data != NULL && data->is_CounterData())
-cnt = data->as_CounterData()->count();
-}
-// Caller counts / call-site counts; i.e. is this call site
-// a hot call site for method next_m?
-int freq = (invcnt) ? cnt/invcnt : cnt;
-// Check size and frequency limits
-if ((msg = shouldInline(m, freq, cnt)) != NULL) {
-break;
-}
-// Check inlining negative tests
-if ((msg = shouldNotInline(m)) != NULL) {
-break;
-}
-// If the caller method is too big or something then we do not want to
-// compile it just to inline a method
-if (!can_be_compiled(next_m, CompLevel_any)) {
-msg = "caller cannot be compiled";
-break;
-}
-if( next_m->name() == vmSymbols::class_initializer_name() ) {
-msg = "do not compile class initializer (OSR ok)";
-break;
-}
-current = next;
-}
-assert( !current || !current->is_compiled(), "" );
-return current;
-}
-RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) {
-RFrame* sender = rf->caller();
-if (sender && sender->num() == stack->length()) stack->push(sender);
-return sender;
-}
-const char* StackWalkCompPolicy::shouldInline(const methodHandle& m, float freq, int cnt) {
-// Allows targeted inlining
-// positive filter: should send be inlined?  returns NULL (--> yes)
-// or rejection msg
-int max_size = MaxInlineSize;
-int cost = m->code_size();
-// Check for too many throws (and not too huge)
-if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) {
-return NULL;
-}
-// bump the max size if the call is frequent
-if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) {
-if (TraceFrequencyInlining) {
-tty->print("(Inlined frequent method)\n");
-m->print();
-}
-max_size = FreqInlineSize;
-}
-if (cost > max_size) {
-return (_msg = "too big");
-}
-return NULL;
-}
-const char* StackWalkCompPolicy::shouldNotInline(const methodHandle& m) {
-// negative filter: should send NOT be inlined?  returns NULL (--> inline) or rejection msg
-if (m->is_abstract()) return (_msg = "abstract method");
-// note: we allow ik->is_abstract()
-if (!m->method_holder()->is_initialized()) return (_msg = "method holder not initialized");
-if (m->is_native()) return (_msg = "native method");
-CompiledMethod* m_code = m->code();
-if (m_code != NULL && m_code->code_size() > InlineSmallCode)
-return (_msg = "already compiled into a big method");
-// use frequency-based objections only for non-trivial methods
-if (m->code_size() <= MaxTrivialSize) return NULL;
-if (UseInterpreter) {     // don't use counts with -Xcomp
-if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed");
-if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times");
-}
-if (Method::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes");
-return NULL;
-}
-#endif // COMPILER2

branch	stuefe-new-metaspace-branch
changeset 58494	54c1ba464b78
parent 58398	ff559f979c4b