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

comparison src/share/vm/oops/method.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	c6a1ffc707ff a1ebd310d5c1
children	36bcc10e01c0

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 method_type,
 CHECK_NULL);
 int size = Method::size(access_flags.is_native());
-return new (loader_data, size, false, THREAD) Method(cm, access_flags, size);
+return new (loader_data, size, false, MetaspaceObj::MethodType, THREAD) Method(cm, access_flags, size);
 }
 Method::Method(ConstMethod* xconst, AccessFlags access_flags, int size) {
 No_Safepoint_Verifier no_safepoint;
 set_constMethod(xconst);
 set_jfr_towrite(false);
 set_force_inline(false);
 set_hidden(false);
 set_dont_inline(false);
 set_method_data(NULL);
-set_interpreter_throwout_count(0);
+set_method_counters(NULL);
 set_vtable_index(Method::garbage_vtable_index);
 // Fix and bury in Method*
 set_interpreter_entry(NULL); // sets i2i entry and from_int
 set_adapter_entry(NULL);
 clear_native_function();
 set_signature_handler(NULL);
 }
 NOT_PRODUCT(set_compiled_invocation_count(0);)
-set_interpreter_invocation_count(0);
-invocation_counter()->init();
-backedge_counter()->init();
-clear_number_of_breakpoints();
-#ifdef GRAAL
-set_graal_invocation_time(0L);
-set_graal_priority(0);
-#endif
-#ifdef TIERED
-set_rate(0);
-set_prev_event_count(0);
-set_prev_time(0);
-#endif
 }
 // Release Method*.  The nmethod will be gone when we get here because
 // we've walked the code cache.
 void Method::deallocate_contents(ClassLoaderData* loader_data) {
 MetadataFactory::free_metadata(loader_data, constMethod());
 set_constMethod(NULL);
 MetadataFactory::free_metadata(loader_data, method_data());
 set_method_data(NULL);
+MetadataFactory::free_metadata(loader_data, method_counters());
+set_method_counters(NULL);
 // The nmethod will be gone when we get here.
 if (code() != NULL) _code = NULL;
 }
 address Method::get_i2c_entry() {
 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() || (method_data() != NULL && method_data()->invocation_counter()->carry())) {
+else if ((method_counters() != NULL &&
+method_counters()->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;
 method->print_name(tty);
 tty->cr();
 // At the end of the run, the MDO, full of data, will be dumped.
 }
 }
+}
+MethodCounters* Method::build_method_counters(Method* m, TRAPS) {
+methodHandle mh(m);
+ClassLoaderData* loader_data = mh->method_holder()->class_loader_data();
+MethodCounters* counters = MethodCounters::allocate(loader_data, CHECK_NULL);
+if (mh->method_counters() == NULL) {
+mh->set_method_counters(counters);
+} else {
+MetadataFactory::free_metadata(loader_data, counters);
+}
+return mh->method_counters();
 }
 void Method::cleanup_inline_caches() {
 // The current system doesn't use inline caches in the interpreter
 // => nothing to do (keep this method around for future use)
 if (is_native()) {
 *native_function_addr() = NULL;
 set_signature_handler(NULL);
 }
 NOT_PRODUCT(set_compiled_invocation_count(0);)
-invocation_counter()->reset();
-backedge_counter()->reset();
 _adapter = NULL;
 _from_compiled_entry = NULL;
 // In case of DumpSharedSpaces, _method_data should always be NULL.
 //
 // have already been called (before an exception happened), so
 // this->_method_data may not be NULL.
 assert(!DumpSharedSpaces || _method_data == NULL, "unexpected method data?");
 set_method_data(NULL);
-set_interpreter_throwout_count(0);
+set_method_counters(NULL);
-set_interpreter_invocation_count(0);
 }
 // Called when the method_holder is getting linked. Setup entrypoints so the method
 // is ready to be called from interpreter, compiler, and vtables.
 void Method::link_method(methodHandle h_method, TRAPS) {
 assert(this == h_method(), "wrong h_method()" );
 address entry = Interpreter::entry_for_method(h_method);
 assert(entry != NULL, "interpreter entry must be non-null");
 // Sets both _i2i_entry and _from_interpreted_entry
 set_interpreter_entry(entry);
-if (is_native() && !is_method_handle_intrinsic()) {
+// Don't overwrite already registered native entries.
+if (is_native() && !has_native_function()) {
 set_native_function(
 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 !native_bind_event_is_interesting);
 }
 // This function must not hit a safepoint!
 address Method::verified_code_entry() {
 debug_only(No_Safepoint_Verifier nsv;)
 nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);
 if (code == NULL && UseCodeCacheFlushing) {
-nmethod *saved_code = CodeCache::find_and_remove_saved_code(this);
+nmethod *saved_code = CodeCache::reanimate_saved_code(this);
 if (saved_code != NULL) {
 methodHandle method(this);
 assert( ! saved_code->is_osr_method(), "should not get here for osr" );
 set_code( method, saved_code );
 }
 clear_matches(this, -1);
 }
 int Method::invocation_count() {
+MethodCounters *mcs = method_counters();
 if (TieredCompilation) {
 MethodData* const mdo = method_data();
-if (invocation_counter()->carry() || ((mdo != NULL) ? mdo->invocation_counter()->carry() : false)) {
+if (((mcs != NULL) ? mcs->invocation_counter()->carry() : false) ||
+((mdo != NULL) ? mdo->invocation_counter()->carry() : false)) {
 return InvocationCounter::count_limit;
 } else {
-return invocation_counter()->count() + ((mdo != NULL) ? mdo->invocation_counter()->count() : 0);
+return ((mcs != NULL) ? mcs->invocation_counter()->count() : 0) +
+((mdo != NULL) ? mdo->invocation_counter()->count() : 0);
 }
 } else {
-return invocation_counter()->count();
+return (mcs == NULL) ? 0 : mcs->invocation_counter()->count();
 }
 }
 int Method::backedge_count() {
+MethodCounters *mcs = method_counters();
 if (TieredCompilation) {
 MethodData* const mdo = method_data();
-if (backedge_counter()->carry() || ((mdo != NULL) ? mdo->backedge_counter()->carry() : false)) {
+if (((mcs != NULL) ? mcs->backedge_counter()->carry() : false) ||
+((mdo != NULL) ? mdo->backedge_counter()->carry() : false)) {
 return InvocationCounter::count_limit;
 } else {
-return backedge_counter()->count() + ((mdo != NULL) ? mdo->backedge_counter()->count() : 0);
+return ((mcs != NULL) ? mcs->backedge_counter()->count() : 0) +
+((mdo != NULL) ? mdo->backedge_counter()->count() : 0);
 }
 } else {
-return backedge_counter()->count();
+return (mcs == NULL) ? 0 : mcs->backedge_counter()->count();
 }
 }
 int Method::highest_comp_level() const {
-MethodData* mdo = method_data();
+const MethodData* mdo = method_data();
 if (mdo != NULL) {
 return mdo->highest_comp_level();
 } else {
 return CompLevel_none;
 }
 }
 int Method::highest_osr_comp_level() const {
-MethodData* mdo = method_data();
+const MethodData* mdo = method_data();
 if (mdo != NULL) {
 return mdo->highest_osr_comp_level();
 } else {
 return CompLevel_none;
 }
 if (code == Bytecodes::_breakpoint)
 code = method->orig_bytecode_at(_bci);
 assert(orig_bytecode() == code, "original bytecode must be the same");
 }
 #endif
+Thread *thread = Thread::current();
 *method->bcp_from(_bci) = Bytecodes::_breakpoint;
-method->incr_number_of_breakpoints();
+method->incr_number_of_breakpoints(thread);
 SystemDictionary::notice_modification();
 {
 // Deoptimize all dependents on this method
-Thread *thread = Thread::current();
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 Universe::flush_dependents_on_method(mh);
 }
 }
 void BreakpointInfo::clear(Method* method) {
 *method->bcp_from(_bci) = orig_bytecode();
 assert(method->number_of_breakpoints() > 0, "must not go negative");
-method->decr_number_of_breakpoints();
+method->decr_number_of_breakpoints(Thread::current());
 }
 // jmethodID handling
 // This is a block allocating object, sort of like JNIHandleBlock, only a
 md->is_metadata(), "should be metadata");
 guarantee(md == NULL ||
 md->is_methodData(), "should be method data");
 }
-#ifdef GRAAL
-void Method::reset_counters() {
-invocation_counter()->reset();
-backedge_counter()->reset();
-_interpreter_invocation_count = 0;
-_interpreter_throwout_count = 0;
-#ifndef PRODUCT
-_compiled_invocation_count = 0;
 #endif
-}
-#endif

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/method.cpp @ 10408:836a62f43af9