truffle: src/share/vm/compiler/compileBroker.cpp comparison

comparison src/share/vm/compiler/compileBroker.cpp @ 4970:33df1aeaebbf

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

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 27 Feb 2012 13:10:13 +0100
parents	723df37192d6 09d00c18e323
children	532be189cf09

comparison

equal deleted inserted replaced

-:2cfb7fb2dce7
+:33df1aeaebbf
 /*
-* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2012, 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.
 #include "runtime/sweeper.hpp"
 #include "utilities/dtrace.hpp"
 #ifdef GRAAL
 #include "graal/graalCompiler.hpp"
 #endif
+#include "utilities/events.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Compiler.hpp"
 #endif
 #ifdef COMPILER2
 #include "opto/c2compiler.hpp"
 CompileQueue* CompileBroker::_c1_method_queue   = NULL;
 CompileTask*  CompileBroker::_task_free_list = NULL;
 GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;
+class CompilationLog : public StringEventLog {
+public:
+CompilationLog() : StringEventLog("Compilation events") {
+}
+void log_compile(JavaThread* thread, CompileTask* task) {
+StringLogMessage lm;
+stringStream msg = lm.stream();
+// msg.time_stamp().update_to(tty->time_stamp().ticks());
+task->print_compilation(&msg, 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 "]",
+nm->compile_id(), nm->is_osr_method() ? "%" : "",
+nm, nm->code_begin(), nm->code_end());
+}
+void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {
+StringLogMessage lm;
+lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);
+if (retry_message != NULL) {
+lm.append(" (%s)", retry_message);
+}
+lm.print("\n");
+log(thread, "%s", (const char*)lm);
+}
+};
+static CompilationLog* _compilation_log = NULL;
+void compileBroker_init() {
+if (LogEvents) {
+_compilation_log = new CompilationLog();
+}
+}
 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {
 CompilerThread* thread = CompilerThread::current();
 thread->set_task(task);
 CompileLog*     log  = thread->log();
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation_impl
-void CompileTask::print_compilation_impl(outputStream* st, methodOop method, int compile_id, int comp_level, bool is_osr_method, int osr_bci, bool is_blocking, const char* msg) {
+void CompileTask::print_compilation_impl(outputStream* st, methodOop method, int compile_id, int comp_level,
-st->print("%7d ", (int) st->time_stamp().milliseconds());  // print timestamp
+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
+}
 st->print("%4d ", compile_id);    // print compilation number
 // For unloaded methods the transition to zombie occurs after the
 // method is cleared so it's impossible to report accurate
 // information for that case.
 }
 if (msg != NULL) {
 st->print("   %s", msg);
 }
-st->cr();
+if (!short_form) {
+st->cr();
+}
 }
 // ------------------------------------------------------------------
 // CompileTask::print_inlining
 void CompileTask::print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) {
 for (int i = 0; i < inline_level; i++)  st->print("  ");
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation
-void CompileTask::print_compilation(outputStream* st) {
+void CompileTask::print_compilation(outputStream* st, 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());
+print_compilation_impl(st, method, compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), NULL, short_form);
 }
 // ------------------------------------------------------------------
 // CompileTask::log_task
 void CompileTask::log_task(xmlStream* log) {
 java_lang_Thread::set_thread(thread_oop(), compiler_thread);
 // Note that this only sets the JavaThread _priority field, which by
 // definition is limited to Java priorities and not OS priorities.
 // The os-priority is set in the CompilerThread startup code itself
 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);
-// CLEANUP PRIORITIES: This -if- statement hids a bug whereby the compiler
-// threads never have their OS priority set.  The assumption here is to
+// Note that we cannot call os::set_priority because it expects Java
-// enable the Performance group to do flag tuning, figure out a suitable
+// priorities and we are *explicitly* using OS priorities so that it's
-// CompilerThreadPriority, and then remove this 'if' statement (and
+// possible to set the compiler thread priority higher than any Java
-// comment) and unconditionally set the priority.
+// thread.
-// Compiler Threads should be at the highest Priority
+int native_prio = CompilerThreadPriority;
-if ( CompilerThreadPriority != -1 )
+if (native_prio == -1) {
-os::set_native_priority( compiler_thread, CompilerThreadPriority );
+if (UseCriticalCompilerThreadPriority) {
-else
+native_prio = os::java_to_os_priority[CriticalPriority];
-os::set_native_priority( compiler_thread, os::java_to_os_priority[NearMaxPriority]);
+} else {
+native_prio = os::java_to_os_priority[NearMaxPriority];
-// Note that I cannot call os::set_priority because it expects Java
+}
-// priorities and I am *explicitly* using OS priorities so that it's
+}
-// possible to set the compiler thread priority higher than any Java
+os::set_native_priority(compiler_thread, native_prio);
-// thread.
 java_lang_Thread::set_daemon(thread_oop());
 compiler_thread->set_threadObj(thread_oop());
 Threads::add(compiler_thread);
 Thread::start(compiler_thread);
 }
 // Let go of Threads_lock before yielding
 os::yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS)
 return compiler_thread;
 }
 int osr_bci,
 int comp_level,
 methodHandle hot_method,
 int hot_count,
 const char* comment,
-TRAPS) {
+Thread* thread) {
 // do nothing if compiler thread(s) is not available
 if (!_initialized ) {
 return;
 }
 bool         blocking = false;
 CompileQueue* queue  = compile_queue(comp_level);
 // Acquire our lock.
 {
-MutexLocker locker(queue->lock(), THREAD);
+MutexLocker locker(queue->lock(), thread);
 if (JavaThread::current()->is_compiling() && !BackgroundCompilation) {
 #ifdef GRAAL
 TRACE_graal_1("Recursive compile %s!", method->name_and_sig_as_C_string());
 #endif
 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,
 int comp_level,
 methodHandle hot_method, int hot_count,
-const char* comment, TRAPS) {
+const char* comment, Thread* THREAD) {
 // make sure arguments make sense
 assert(method->method_holder()->klass_part()->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(!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_0);
+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_0);
+methodOopDesc::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.
 (void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id);
 } else {
 return NULL;
 }
 } else {
-compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, CHECK_0);
+compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, THREAD);
 }
 // return requested nmethod
 // We accept a higher level osr method
 return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
 elapsedTimer time;
 CompilerThread* thread = CompilerThread::current();
 ResourceMark rm(thread);
+if (LogEvents) {
+_compilation_log->log_compile(thread, task);
+}
 // Common flags.
 uint compile_id = task->compile_id();
 int osr_bci = task->osr_bci();
 bool is_osr = (osr_bci != standard_entry_bci);
 bool should_log = (thread->log() != NULL);
 // The compiler elected, without comment, not to register a result.
 // Do not attempt further compilations of this method.
 ci_env.record_method_not_compilable("compile failed", !TieredCompilation);
 }
+// Copy this bit to the enclosing block:
+compilable = ci_env.compilable();
 if (ci_env.failing()) {
-// Copy this bit to the enclosing block:
+const char* retry_message = ci_env.retry_message();
-compilable = ci_env.compilable();
+if (_compilation_log != NULL) {
+_compilation_log->log_failure(thread, task, ci_env.failure_reason(), retry_message);
+}
 if (PrintCompilation) {
-const char* reason = ci_env.failure_reason();
+tty->print("%4d   COMPILE SKIPPED: %s", compile_id, ci_env.failure_reason());
-if (compilable == ciEnv::MethodCompilable_not_at_tier) {
+if (retry_message != NULL) {
-tty->print_cr("%4d   COMPILE SKIPPED: %s (retry at different tier)", compile_id, reason);
+tty->print(" (%s)", retry_message);
-} else if (compilable == ciEnv::MethodCompilable_never) {
-tty->print_cr("%4d   COMPILE SKIPPED: %s (not retryable)", compile_id, reason);
-} else if (compilable == ciEnv::MethodCompilable) {
-tty->print_cr("%4d   COMPILE SKIPPED: %s", compile_id, reason);
 }
+tty->cr();
 }
 } else {
 task->mark_success();
 task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes());
+if (_compilation_log != NULL) {
+nmethod* code = task->code();
+if (code != NULL) {
+_compilation_log->log_nmethod(thread, code);
+}
+}
 }
 }
 pop_jni_handle_block();
 methodHandle method(thread,

Mercurial > hg > truffle

comparison src/share/vm/compiler/compileBroker.cpp @ 4970:33df1aeaebbf