graal-compiler: src/share/vm/runtime/compilationPolicy.cpp comparison

comparison src/share/vm/runtime/compilationPolicy.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	3ce140f4f2c9 d1c9384eecb4
children	36bcc10e01c0

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 (UseCompiler && AlwaysCompileLoopMethods && m->has_loops() && CompileBroker::should_compile_new_jobs()); // eagerly compile loop methods
 }
 // Returns true if m is allowed to be compiled
 bool CompilationPolicy::can_be_compiled(methodHandle m, int comp_level) {
+// allow any levels for WhiteBox
+assert(WhiteBoxAPI || comp_level == CompLevel_all || is_compile(comp_level), "illegal compilation level");
 if (m->is_abstract()) return false;
 if (DontCompileHugeMethods && m->code_size() > HugeMethodLimit) return false;
 // Math intrinsics should never be compiled as this can lead to
 // monotonicity problems because the interpreter will prefer the
 // modes.
 if (!AbstractInterpreter::can_be_compiled(m)) {
 return false;
 }
 if (comp_level == CompLevel_all) {
-return !m->is_not_compilable(CompLevel_simple) && !m->is_not_compilable(CompLevel_full_optimization);
+if (TieredCompilation) {
+// enough to be compilable at any level for tiered
+return !m->is_not_compilable(CompLevel_simple) || !m->is_not_compilable(CompLevel_full_optimization);
+} else {
+// must be compilable at available level for non-tiered
+return !m->is_not_compilable(CompLevel_highest_tier);
+}
 } else if (is_compile(comp_level)) {
 return !m->is_not_compilable(comp_level);
 }
 return false;
 }
 // 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).
-m->invocation_counter()->set_carry();
+MethodCounters* mcs = m->method_counters();
-m->backedge_counter()->set_carry();
+assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
+mcs->invocation_counter()->set_carry();
+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(methodHandle m) {
 // Delay next back-branch event but pump up invocation counter to triger
 // whole method compilation.
-InvocationCounter* i = m->invocation_counter();
+MethodCounters* mcs = m->method_counters();
-InvocationCounter* b = m->backedge_counter();
+assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
+InvocationCounter* i = mcs->invocation_counter();
+InvocationCounter* b = mcs->backedge_counter();
 // Don't set invocation_counter's value too low otherwise the method will
 // look like immature (ic < ~5300) which prevents the inlining based on
 // the type profiling.
 i->set(i->state(), CompileThreshold);
 // is done at each safepoint.
 //
 class CounterDecay : public AllStatic {
 static jlong _last_timestamp;
 static void do_method(Method* m) {
-m->invocation_counter()->decay();
+MethodCounters* mcs = m->method_counters();
+if (mcs != NULL) {
+mcs->invocation_counter()->decay();
+}
 }
 public:
 static void decay();
 static bool is_decay_needed() {
 return (os::javaTimeMillis() - _last_timestamp) > CounterDecayMinIntervalLength;
 }
 }
 void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
 ScopeDesc* sd = trap_scope;
+MethodCounters* mcs;
+InvocationCounter* c;
 for (; !sd->is_top(); sd = sd->sender()) {
-// Reset ICs of inlined methods, since they can trigger compilations also.
+mcs = sd->method()->method_counters();
-sd->method()->invocation_counter()->reset();
+if (mcs != NULL) {
-}
+// Reset ICs of inlined methods, since they can trigger compilations also.
-InvocationCounter* c = sd->method()->invocation_counter();
+mcs->invocation_counter()->reset();
-if (is_osr) {
+}
-// It was an OSR method, so bump the count higher.
+}
-c->set(c->state(), CompileThreshold);
+mcs = sd->method()->method_counters();
-} else {
+if (mcs != NULL) {
-c->reset();
+c = mcs->invocation_counter();
-}
+if (is_osr) {
-sd->method()->backedge_counter()->reset();
+// It was an OSR method, so bump the count higher.
+c->set(c->state(), CompileThreshold);
+} else {
+c->reset();
+}
+mcs->backedge_counter()->reset();
+}
 }
 // This method can be called by any component of the runtime to notify the policy
 // that it's recommended to delay the complation of this method.
 void NonTieredCompPolicy::delay_compilation(Method* method) {
-method->invocation_counter()->decay();
+MethodCounters* mcs = method->method_counters();
-method->backedge_counter()->decay();
+if (mcs != NULL) {
+mcs->invocation_counter()->decay();
+mcs->backedge_counter()->decay();
+}
 }
 void NonTieredCompPolicy::disable_compilation(Method* method) {
-method->invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
+MethodCounters* mcs = method->method_counters();
-method->backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
+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) {
 return compile_queue->first();
 }
 }
 #ifndef PRODUCT
 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) {
 if (TraceInvocationCounterOverflow) {
-InvocationCounter* ic = m->invocation_counter();
+MethodCounters* mcs = m->method_counters();
-InvocationCounter* bc = m->backedge_counter();
+assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
+InvocationCounter* ic = mcs->invocation_counter();
+InvocationCounter* bc = mcs->backedge_counter();
 ResourceMark rm;
 const char* msg =
 bci == InvocationEntryBci
 ? "comp-policy cntr ovfl @ %d in entry of "
 : "comp-policy cntr ovfl @ %d in loop of ";
 const int comp_level = CompLevel_highest_tier;
 const int hot_count = m->invocation_count();
 reset_counter_for_invocation_event(m);
 const char* comment = "count";
-if (is_compilation_enabled() && can_be_compiled(m)) {
+if (is_compilation_enabled() && can_be_compiled(m, comp_level)) {
 nmethod* nm = m->code();
 #ifdef GRAALVM
 if (m->queued_for_compilation()) {
 delay_compilation(m());
 } else
 void SimpleCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) {
 const int comp_level = CompLevel_highest_tier;
 const int hot_count = m->backedge_count();
 const char* comment = "backedge_count";
-if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m)) {
+if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m, comp_level)) {
 CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
 }
 }
 // GraalCompPolicy - compile current method
 #ifdef GRAALVM
 void GraalCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) {
+MethodCounters* mcs = m->method_counters();
 int hot_count = m->invocation_count();
-jlong hot_time = m->graal_invocation_time();
+jlong hot_time = (mcs == NULL) ? 0 : mcs->graal_invocation_time();
 reset_counter_for_invocation_event(m);
 if (is_compilation_enabled() && can_be_compiled(m)) {
 nmethod* nm = m->code();
 if (nm == NULL) {
 if (hot_count > 1) {
 jlong current_time = os::javaTimeNanos();
 int time_per_call = (int) ((current_time - hot_time) / hot_count);
-m->set_graal_invocation_time(current_time);
+if (mcs != NULL) {
+mcs->set_graal_invocation_time(current_time);
+}
 if (UseNewCode) {
 if (m->queued_for_compilation()) {
 if (time_per_call < (m->graal_priority() / 5)) {
 m->set_graal_priority(time_per_call);
 m->clear_queued_for_compilation();
 const int comp_level = CompLevel_highest_tier;
 const int hot_count = m->invocation_count();
 reset_counter_for_invocation_event(m);
 const char* comment = "count";
-if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(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");
 void StackWalkCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) {
 const int comp_level = CompLevel_highest_tier;
 const int hot_count = m->backedge_count();
 const char* comment = "backedge_count";
-if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m)) {
+if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m, comp_level)) {
 CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
 }
 }
 }
 // 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)) {
+if (!can_be_compiled(next_m, CompLevel_any)) {
 msg = "caller cannot be compiled";
 break;
 }
 if( next_m->name() == vmSymbols::class_initializer_name() ) {

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/compilationPolicy.cpp @ 10408:836a62f43af9