graal-compiler: src/share/vm/compiler/compileBroker.cpp comparison

comparison src/share/vm/compiler/compileBroker.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	957c266d8bc5 18fb7da42534
children	1baf7f1e3f23

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerOracle.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/allocation.inline.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/compilationPolicy.hpp"
 #include "runtime/init.hpp"
 CompilationLog() : StringEventLog("Compilation events") {
 }
 void log_compile(JavaThread* thread, CompileTask* task) {
 StringLogMessage lm;
-stringStream msg = lm.stream();
+stringStream sstr = lm.stream();
 // msg.time_stamp().update_to(tty->time_stamp().ticks());
-task->print_compilation(&msg, true);
+task->print_compilation(&sstr, NULL, true);
 log(thread, "%s", (const char*)lm);
 }
 void log_nmethod(JavaThread* thread, nmethod* nm) {
 log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]",
 CompileTask* task = thread->task();
 CompileLog*  log  = thread->log();
 if (log != NULL)  task->log_task_done(log);
 thread->set_task(NULL);
 task->set_code_handle(NULL);
-DEBUG_ONLY(thread->set_env((ciEnv*)badAddress));
+thread->set_env(NULL);
 if (task->is_blocking()) {
 MutexLocker notifier(task->lock(), thread);
 task->mark_complete();
 // Notify the waiting thread that the compilation has completed.
 task->lock()->notify_all();
 const char* comment,
 bool is_blocking) {
 assert(!_lock->is_locked(), "bad locking");
 _compile_id = compile_id;
-_method = JNIHandles::make_global(method);
+_method = method();
+_method_loader = JNIHandles::make_global(_method->method_holder()->class_loader());
 _osr_bci = osr_bci;
 _is_blocking = is_blocking;
 _comp_level = comp_level;
 _num_inlined_bytecodes = 0;
 _is_complete = false;
 _is_success = false;
 _code_handle = NULL;
 _hot_method = NULL;
+_hot_method_loader = NULL;
 _hot_count = hot_count;
 _time_queued = 0;  // tidy
 _comment = comment;
 if (LogCompilation) {
 _time_queued = os::elapsed_counter();
 if (hot_method.not_null()) {
 if (hot_method == method) {
 _hot_method = _method;
 } else {
-_hot_method = JNIHandles::make_global(hot_method);
+_hot_method = hot_method();
 }
+_hot_method_loader = JNIHandles::make_global(_hot_method->method_holder()->class_loader());
 }
 }
 _next = NULL;
 }
 // ------------------------------------------------------------------
 // CompileTask::free
 void CompileTask::free() {
 set_code(NULL);
 assert(!_lock->is_locked(), "Should not be locked when freed");
-if (_hot_method != NULL && _hot_method != _method) {
+JNIHandles::destroy_global(_method_loader);
-JNIHandles::destroy_global(_hot_method);
+JNIHandles::destroy_global(_hot_method_loader);
 }
-JNIHandles::destroy_global(_method);
-}
+void CompileTask::mark_on_stack() {
+// Mark these methods as something redefine classes cannot remove.
+_method->set_on_stack(true);
+if (_hot_method != NULL) {
+_hot_method->set_on_stack(true);
+}
+}
 // ------------------------------------------------------------------
 // CompileTask::print
 void CompileTask::print() {
 tty->print("<CompileTask compile_id=%d ", _compile_id);
 tty->print("method=");
-((methodOop)JNIHandles::resolve(_method))->print_name(tty);
+_method->print_name(tty);
 tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>",
 _osr_bci, bool_to_str(_is_blocking),
 bool_to_str(_is_complete), bool_to_str(_is_success));
 }
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation_impl
-void CompileTask::print_compilation_impl(outputStream* st, methodOop method, int compile_id, int comp_level,
+void CompileTask::print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level,
 bool is_osr_method, int osr_bci, bool is_blocking,
 const char* msg, bool short_form) {
 if (!short_form) {
 st->print("%7d ", (int) st->time_stamp().milliseconds());  // print timestamp
 }
 for (int i = 0; i < inline_level; i++)  st->print("  ");
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation
-void CompileTask::print_compilation(outputStream* st, bool short_form) {
+void CompileTask::print_compilation(outputStream* st, const char* msg, bool short_form) {
-oop rem = JNIHandles::resolve(method_handle());
-assert(rem != NULL && rem->is_method(), "must be");
-methodOop method = (methodOop) rem;
 bool is_osr_method = osr_bci() != InvocationEntryBci;
-print_compilation_impl(st, method, compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), NULL, short_form);
+print_compilation_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), msg, short_form);
 }
 // ------------------------------------------------------------------
 // CompileTask::log_task
 void CompileTask::log_task(xmlStream* log) {
 Thread* thread = Thread::current();
-methodHandle method(thread,
+methodHandle method(thread, this->method());
-(methodOop)JNIHandles::resolve(method_handle()));
 ResourceMark rm(thread);
 // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'>
 if (_compile_id != 0)   log->print(" compile_id='%d'", _compile_id);
 if (_osr_bci != CompileBroker::standard_entry_bci) {
 log_task(xtty);
 if (_comment != NULL) {
 xtty->print(" comment='%s'", _comment);
 }
 if (_hot_method != NULL) {
-methodHandle hot(thread,
+methodHandle hot(thread, _hot_method);
-(methodOop)JNIHandles::resolve(_hot_method));
+methodHandle method(thread, _method);
-methodHandle method(thread,
-(methodOop)JNIHandles::resolve(_method));
 if (hot() != method()) {
 xtty->method(hot);
 }
 }
 if (_hot_count != 0) {
 // ------------------------------------------------------------------
 // CompileTask::log_task_done
 void CompileTask::log_task_done(CompileLog* log) {
 Thread* thread = Thread::current();
-methodHandle method(thread,
+methodHandle method(thread, this->method());
-(methodOop)JNIHandles::resolve(method_handle()));
 ResourceMark rm(thread);
 // <task_done ... stamp='1.234'>  </task>
 nmethod* nm = code();
 log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",
 _last = task;
 }
 ++_size;
 // Mark the method as being in the compile queue.
-((methodOop)JNIHandles::resolve(task->method_handle()))->set_queued_for_compilation();
+task->method()->set_queued_for_compilation();
 if (CIPrintCompileQueue) {
 print();
 }
 _last = task->prev();
 }
 --_size;
 }
+// methods in the compile queue need to be marked as used on the stack
+// so that they don't get reclaimed by Redefine Classes
+void CompileQueue::mark_on_stack() {
+CompileTask* task = _first;
+while (task != NULL) {
+task->mark_on_stack();
+task = task->next();
+}
+}
 // ------------------------------------------------------------------
 // CompileQueue::print
 void CompileQueue::print() {
 tty->print_cr("Contents of %s", name());
 tty->print_cr("----------------------");
 // ------------------------------------------------------------------
 // CompileBroker::make_compiler_thread
 CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
 CompilerThread* compiler_thread = NULL;
-klassOop k =
+Klass* k =
 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(),
 true, CHECK_0);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_0);
 Handle string = java_lang_String::create_from_str(name, CHECK_0);
 }
 if (UsePerfData) {
 PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
 compiler_count, CHECK);
+}
+}
+// Set the methods on the stack as on_stack so that redefine classes doesn't
+// reclaim them
+void CompileBroker::mark_on_stack() {
+if (_c2_method_queue != NULL) {
+_c2_method_queue->mark_on_stack();
+}
+if (_c1_method_queue != NULL) {
+_c1_method_queue->mark_on_stack();
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::is_idle
 if (!_initialized ) {
 return;
 }
 guarantee(!method->is_abstract(), "cannot compile abstract methods");
-assert(method->method_holder()->klass_part()->oop_is_instance(),
+assert(method->method_holder()->oop_is_instance(),
 "sanity check");
-assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(),
+assert(!method->method_holder()->is_not_initialized(),
 "method holder must be initialized");
 assert(!method->is_method_handle_intrinsic(), "do not enqueue these guys");
 if (CIPrintRequests) {
 tty->print("request: ");
 // If the requesting thread is holding the pending list lock
 // then we just return. We can't risk blocking while holding
 // the pending list lock or a 3-way deadlock may occur
 // between the reference handler thread, a GC (instigated
 // by a compiler thread), and compiled method registration.
-if (instanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
+if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
 return;
 }
 #ifdef GRAAL
 if (!JavaThread::current()->is_compiling()) {
 method->set_queued_for_compilation();
 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,
 int comp_level,
 methodHandle hot_method, int hot_count,
 const char* comment, Thread* THREAD) {
 // make sure arguments make sense
-assert(method->method_holder()->klass_part()->oop_is_instance(), "not an instance method");
+assert(method->method_holder()->oop_is_instance(), "not an instance method");
 assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range");
 assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods");
-assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized");
+assert(!method->method_holder()->is_not_initialized(), "method holder must be initialized");
 if (!TieredCompilation) {
 comp_level = CompLevel_highest_tier;
 }
 "all OSR compiles are assumed to be at a single compilation lavel");
 #endif // TIERED
 // We accept a higher level osr method
 nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
 if (nm != NULL) return nm;
-if (method->is_not_osr_compilable()) return NULL;
+if (method->is_not_osr_compilable(comp_level)) return NULL;
 }
 assert(!HAS_PENDING_EXCEPTION, "No exception should be present");
 // some prerequisites that are compiler specific
 if (compiler(comp_level)->is_c2() || compiler(comp_level)->is_shark()) {
 method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL);
 // Resolve all classes seen in the signature of the method
 // we are compiling.
-methodOopDesc::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
+Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
 }
 // If the method is native, do the lookup in the thread requesting
 // the compilation. Native lookups can load code, which is not
 // permitted during compilation.
 bool CompileBroker::compilation_is_complete(methodHandle method,
 int          osr_bci,
 int          comp_level) {
 bool is_osr = (osr_bci != standard_entry_bci);
 if (is_osr) {
-if (method->is_not_osr_compilable()) {
+if (method->is_not_osr_compilable(comp_level)) {
 return true;
 } else {
 nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true);
 return (result != NULL);
 }
 bool is_osr = (osr_bci != standard_entry_bci);
 // Some compilers may not support on stack replacement.
 if (is_osr &&
 (!CICompileOSR || !compiler(comp_level)->supports_osr())) {
-method->set_not_osr_compilable();
+method->set_not_osr_compilable(comp_level);
 return true;
 }
 // The method may be explicitly excluded by the user.
 bool quietly;
 // CompileBroker::is_compile_blocking
 //
 // Should the current thread be blocked until this compilation request
 // has been fulfilled?
 bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) {
-assert(!instanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
+assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
 return !BackgroundCompilation;
 }
 // ------------------------------------------------------------------
 assert(task->is_blocking(), "can only wait on blocking task");
 JavaThread *thread = JavaThread::current();
 thread->set_blocked_on_compilation(true);
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 {
 MutexLocker waiter(task->lock(), thread);
 while (!task->is_complete())
 task->lock()->wait();
 if (LogCompilation) {
 init_compiler_thread_log();
 }
 CompileLog* log = thread->log();
 if (log != NULL) {
-log->begin_elem("start_compile_thread thread='" UINTX_FORMAT "' process='%d'",
+log->begin_elem("start_compile_thread name='%s' thread='" UINTX_FORMAT "' process='%d'",
+thread->name(),
 os::current_thread_id(),
 os::current_process_id());
 log->stamp();
 log->end_elem();
 }
 // Assign the task to the current thread.  Mark this compilation
 // thread as active for the profiler.
 CompileTaskWrapper ctw(task);
 nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
 task->set_code_handle(&result_handle);
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 // Never compile a method if breakpoints are present in it
 if (method()->number_of_breakpoints() == 0) {
 // Compile the method.
 if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
 #endif
 ThreadInVMfromNative tivfn(JavaThread::current());
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::invoke_compiler_on_method
 //
 // Compile a method.
 //
 {
 // create the handle inside it's own block so it can't
 // accidentally be referenced once the thread transitions to
 // native.  The NoHandleMark before the transition should catch
 // any cases where this occurs in the future.
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 should_break = check_break_at(method, compile_id, is_osr);
 if (should_log && !CompilerOracle::should_log(method)) {
 should_log = false;
 }
 assert(!method->is_native(), "no longer compile natives");
 DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler(task->comp_level()), method);
 }
 // Allocate a new set of JNI handles.
 push_jni_handle_block();
-jobject target_handle = JNIHandles::make_local(thread, JNIHandles::resolve(task->method_handle()));
+Method* target_handle = task->method();
 int compilable = ciEnv::MethodCompilable;
 {
 int system_dictionary_modification_counter;
 {
 MutexLocker locker(Compile_lock, thread);
 const char* retry_message = ci_env.retry_message();
 if (_compilation_log != NULL) {
 _compilation_log->log_failure(thread, task, ci_env.failure_reason(), retry_message);
 }
 if (PrintCompilation) {
-tty->print("%4d   COMPILE SKIPPED: %s", compile_id, ci_env.failure_reason());
+FormatBufferResource msg = retry_message != NULL ?
-if (retry_message != NULL) {
+err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) :
-tty->print(" (%s)", retry_message);
+err_msg_res("COMPILE SKIPPED: %s",      ci_env.failure_reason());
-}
+task->print_compilation(tty, msg);
-tty->cr();
 }
 } else {
 task->mark_success();
 task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes());
 if (_compilation_log != NULL) {
 }
 }
 }
 pop_jni_handle_block();
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 DTRACE_METHOD_COMPILE_END_PROBE(compiler(task->comp_level()), method, task->is_success());
 collect_statistics(thread, time, task);
 tty->print("%s ", (is_osr ? "%" : " "));
 int code_size = (task->code() == NULL) ? 0 : task->code()->total_size();
 tty->print_cr("size: %d time: %d inlined: %d bytes", code_size, (int)time.milliseconds(), task->num_inlined_bytecodes());
 }
-if (compilable == ciEnv::MethodCompilable_never) {
+// Disable compilation, if required.
-if (is_osr) {
+switch (compilable) {
-method->set_not_osr_compilable();
+case ciEnv::MethodCompilable_never:
-} else {
+if (is_osr)
+method->set_not_osr_compilable_quietly();
+else
 method->set_not_compilable_quietly();
-}
+break;
-} else if (compilable == ciEnv::MethodCompilable_not_at_tier) {
+case ciEnv::MethodCompilable_not_at_tier:
-method->set_not_compilable_quietly(task->comp_level());
+if (is_osr)
+method->set_not_osr_compilable_quietly(task->comp_level());
+else
+method->set_not_compilable_quietly(task->comp_level());
+break;
 }
 // Note that the queued_for_compilation bits are cleared without
 // protection of a mutex. [They were set by the requester thread,
 // when adding the task to the complie queue -- at which time the
 strncpy(_last_method_compiled, method_name, CompileBroker::name_buffer_length);
 char current_method[CompilerCounters::cmname_buffer_length];
 size_t maxLen = CompilerCounters::cmname_buffer_length;
 if (UsePerfData) {
-const char* class_name = method->method_holder()->klass_part()->name()->as_C_string();
+const char* class_name = method->method_holder()->name()->as_C_string();
 size_t s1len = strlen(class_name);
 size_t s2len = strlen(method_name);
 // check if we need to truncate the string
 //
 // Collect statistics about the compilation.
 void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) {
 bool success = task->is_success();
-methodHandle method (thread, (methodOop)JNIHandles::resolve(task->method_handle()));
+methodHandle method (thread, task->method());
 uint compile_id = task->compile_id();
 bool is_osr = (task->osr_bci() != standard_entry_bci);
 nmethod* code = task->code();
 CompilerCounters* counters = thread->counters();

Mercurial > hg > graal-compiler

comparison src/share/vm/compiler/compileBroker.cpp @ 6948:e522a00b91aa