graal-compiler: src/share/vm/oops/methodOop.cpp comparison

comparison src/share/vm/oops/methodOop.cpp @ 1783:d5d065957597

6953144: Tiered compilation Summary: Infrastructure for tiered compilation support (interpreter + c1 + c2) for 32 and 64 bit. Simple tiered policy implementation. Reviewed-by: kvn, never, phh, twisti

author	iveresov
date	Fri, 03 Sep 2010 17:51:07 -0700
parents	d2ede61b7a12
children	d257356e35f0

comparison

equal deleted inserted replaced

-:f353275af40e
+:d5d065957597
 unlink_method();
 set_interpreter_kind();
 }
-bool methodOopDesc::was_executed_more_than(int n) const {
+bool methodOopDesc::was_executed_more_than(int n) {
 // Invocation counter is reset when the methodOop is compiled.
 // If the method has compiled code we therefore assume it has
 // be excuted more than n times.
 if (is_accessor() || is_empty_method() || (code() != NULL)) {
 // interpreter doesn't bump invocation counter of trivial methods
 // compiler does not bump invocation counter of compiled methods
 return true;
-} else if (_invocation_counter.carry()) {
+}
+else if (_invocation_counter.carry() || (method_data() != NULL && method_data()->invocation_counter()->carry())) {
 // The carry bit is set when the counter overflows and causes
 // a compilation to occur.  We don't know how many times
 // the counter has been reset, so we simply assume it has
 // been executed more than n times.
 return true;
 return invocation_count() > n;
 }
 }
 #ifndef PRODUCT
-void methodOopDesc::print_invocation_count() const {
+void methodOopDesc::print_invocation_count() {
 if (is_static()) tty->print("static ");
 if (is_final()) tty->print("final ");
 if (is_synchronized()) tty->print("synchronized ");
 if (is_native()) tty->print("native ");
 method_holder()->klass_part()->name()->print_symbol_on(tty);
 bool methodOopDesc::is_not_compilable(int comp_level) const {
 if (is_method_handle_invoke()) {
 // compilers must recognize this method specially, or not at all
 return true;
 }
+if (number_of_breakpoints() > 0) {
-#ifdef COMPILER2
+return true;
-if (is_tier1_compile(comp_level)) {
+}
-if (is_not_tier1_compilable()) {
+if (comp_level == CompLevel_any) {
-return true;
+return is_not_c1_compilable() || is_not_c2_compilable();
 }
-}
+if (is_c1_compile(comp_level)) {
-#endif // COMPILER2
+return is_not_c1_compilable();
-return (_invocation_counter.state() == InvocationCounter::wait_for_nothing)
+}
-|| (number_of_breakpoints() > 0);
+if (is_c2_compile(comp_level)) {
+return is_not_c2_compilable();
+}
+return false;
 }
 // call this when compiler finds that this method is not compilable
 void methodOopDesc::set_not_compilable(int comp_level, bool report) {
 if (PrintCompilation && report) {
 xtty->begin_elem("make_not_compilable thread='%d'", (int) os::current_thread_id());
 xtty->method(methodOop(this));
 xtty->stamp();
 xtty->end_elem();
 }
-#ifdef COMPILER2
+if (comp_level == CompLevel_all) {
-if (is_tier1_compile(comp_level)) {
+set_not_c1_compilable();
-set_not_tier1_compilable();
+set_not_c2_compilable();
-return;
+} else {
-}
+if (is_c1_compile(comp_level)) {
-#endif /* COMPILER2 */
+set_not_c1_compilable();
-assert(comp_level == CompLevel_highest_tier, "unexpected compilation level");
+} else
-invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
+if (is_c2_compile(comp_level)) {
-backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
+set_not_c2_compilable();
+}
+}
+CompilationPolicy::policy()->disable_compilation(this);
 }
 // Revert to using the interpreter and clear out the nmethod
 void methodOopDesc::clear_code() {
 _from_compiled_entry = NULL;
 assert(_method_data == NULL, "unexpected method data?");
 set_method_data(NULL);
 set_interpreter_throwout_count(0);
 set_interpreter_invocation_count(0);
-_highest_tier_compile = CompLevel_none;
 }
 // Called when the method_holder is getting linked. Setup entrypoints so the method
 // is ready to be called from interpreter, compiler, and vtables.
 void methodOopDesc::link_method(methodHandle h_method, TRAPS) {
 mh->_code = code;             // Assign before allowing compiled code to exec
 int comp_level = code->comp_level();
 // In theory there could be a race here. In practice it is unlikely
 // and not worth worrying about.
-if (comp_level > mh->highest_tier_compile()) {
+if (comp_level > mh->highest_comp_level()) {
-mh->set_highest_tier_compile(comp_level);
+mh->set_highest_comp_level(comp_level);
 }
 OrderAccess::storestore();
 #ifdef SHARK
 mh->_from_interpreted_entry = code->instructions_begin();
 void methodOopDesc::clear_all_breakpoints() {
 clear_matches(this, -1);
 }
+int methodOopDesc::invocation_count() {
+if (TieredCompilation) {
+const methodDataOop mdo = method_data();
+if (invocation_counter()->carry() || ((mdo != NULL) ? mdo->invocation_counter()->carry() : false)) {
+return InvocationCounter::count_limit;
+} else {
+return invocation_counter()->count() + ((mdo != NULL) ? mdo->invocation_counter()->count() : 0);
+}
+} else {
+return invocation_counter()->count();
+}
+}
+int methodOopDesc::backedge_count() {
+if (TieredCompilation) {
+const methodDataOop mdo = method_data();
+if (backedge_counter()->carry() || ((mdo != NULL) ? mdo->backedge_counter()->carry() : false)) {
+return InvocationCounter::count_limit;
+} else {
+return backedge_counter()->count() + ((mdo != NULL) ? mdo->backedge_counter()->count() : 0);
+}
+} else {
+return backedge_counter()->count();
+}
+}
+int methodOopDesc::highest_comp_level() const {
+methodDataOop mdo = method_data();
+if (mdo != NULL) {
+return mdo->highest_comp_level();
+} else {
+return CompLevel_none;
+}
+}
+int methodOopDesc::highest_osr_comp_level() const {
+methodDataOop mdo = method_data();
+if (mdo != NULL) {
+return mdo->highest_osr_comp_level();
+} else {
+return CompLevel_none;
+}
+}
+void methodOopDesc::set_highest_comp_level(int level) {
+methodDataOop mdo = method_data();
+if (mdo != NULL) {
+mdo->set_highest_comp_level(level);
+}
+}
+void methodOopDesc::set_highest_osr_comp_level(int level) {
+methodDataOop mdo = method_data();
+if (mdo != NULL) {
+mdo->set_highest_osr_comp_level(level);
+}
+}
 BreakpointInfo::BreakpointInfo(methodOop m, int bci) {
 _bci = bci;
 _name_index = m->name_index();
 _signature_index = m->signature_index();
 _orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci);

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/methodOop.cpp @ 1783:d5d065957597