jdk-sandbox: comparison src/hotspot/share/compiler/compileBroker.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "code/codeCache.hpp"
 #include "code/codeHeapState.hpp"
 #include "code/dependencyContext.hpp"
+#include "compiler/compilationPolicy.hpp"
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerOracle.hpp"
 #include "compiler/directivesParser.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/nativeLookup.hpp"
 #include "prims/whitebox.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/atomic.hpp"
-#include "runtime/compilationPolicy.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/init.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/jniHandles.inline.hpp"
 class CompilationLog : public StringEventLog {
 public:
-CompilationLog() : StringEventLog("Compilation events") {
+CompilationLog() : StringEventLog("Compilation events", "jit") {
 }
 void log_compile(JavaThread* thread, CompileTask* task) {
 StringLogMessage lm;
 stringStream sstr(lm.buffer(), lm.size());
 if (ct->idle_time_millis() < (c1 ? 500 : 100)) return false;
 // We only allow the last compiler thread of each type to get removed.
 jobject last_compiler = c1 ? CompileBroker::compiler1_object(compiler_count - 1)
 : CompileBroker::compiler2_object(compiler_count - 1);
-if (oopDesc::equals(ct->threadObj(), JNIHandles::resolve_non_null(last_compiler))) {
+if (ct->threadObj() == JNIHandles::resolve_non_null(last_compiler)) {
 if (do_it) {
 assert_locked_or_safepoint(CompileThread_lock); // Update must be consistent.
 compiler->set_num_compiler_threads(compiler_count - 1);
 }
 return true;
 }
 st->cr();
 }
 void CompileQueue::print_tty() {
-ttyLocker ttyl;
+ResourceMark rm;
-print(tty);
+stringStream ss;
+// Dump the compile queue into a buffer before locking the tty
+print(&ss);
+{
+ttyLocker ttyl;
+tty->print("%s", ss.as_string());
+}
 }
 CompilerCounters::CompilerCounters() {
 _current_method[0] = '\0';
 _compile_type = CompileBroker::no_compile;
 bool in_base_library;
 address adr = NativeLookup::lookup(method, in_base_library, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 // In case of an exception looking up the method, we just forget
 // about it. The interpreter will kick-in and throw the exception.
-method->set_not_compilable(); // implies is_not_osr_compilable()
+method->set_not_compilable("NativeLookup::lookup failed"); // implies is_not_osr_compilable()
 CLEAR_PENDING_EXCEPTION;
 return NULL;
 }
 assert(method->has_native_function(), "must have native code by now");
 }
 bool is_native = method->is_native();
 // Some compilers may not support the compilation of natives.
 AbstractCompiler *comp = compiler(comp_level);
 if (is_native &&
 (!CICompileNatives || comp == NULL || !comp->supports_native())) {
-method->set_not_compilable_quietly(comp_level);
+method->set_not_compilable_quietly("native methods not supported", comp_level);
 return true;
 }
 bool is_osr = (osr_bci != standard_entry_bci);
 // Some compilers may not support on stack replacement.
 if (is_osr &&
 (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
-method->set_not_osr_compilable(comp_level);
+method->set_not_osr_compilable("OSR not supported", comp_level);
 return true;
 }
 // The method may be explicitly excluded by the user.
 double scale;
 method->is_native() ? "generation of native wrapper" : "compile",
 (method->is_static() ? " static" : ""));
 method->print_short_name(tty);
 tty->cr();
 }
-method->set_not_compilable(comp_level, !quietly, "excluded by CompileCommand");
+method->set_not_compilable("excluded by CompileCommand", comp_level, !quietly);
 }
 return false;
 }
 return id;
 }
 }
 // Method was not in the appropriate compilation range.
-method->set_not_compilable_quietly();
+method->set_not_compilable_quietly("Not in requested compile id range");
 return 0;
 #else
 // CICountOSR is a develop flag and set to 'false' by default. In a product built,
 // only _compilation_id is incremented.
 return Atomic::add(1, &_compilation_id);
 }
 assert(task->is_blocking(), "can only wait on blocking task");
 JavaThread* thread = JavaThread::current();
-thread->set_blocked_on_compilation(true);
 methodHandle method(thread, task->method());
 bool free_task;
 #if INCLUDE_JVMCI
 AbstractCompiler* comp = compiler(task->comp_level());
 while (!task->is_complete() && !is_compilation_disabled_forever()) {
 ml.wait();
 }
 }
-thread->set_blocked_on_compilation(false);
 if (free_task) {
 if (is_compilation_disabled_forever()) {
 CompileTask::free(task);
 return;
 }
 CompilerThread* thread = CompilerThread::current();
 AbstractCompiler* comp = thread->compiler();
 // Final sanity check - the compiler object must exist
 guarantee(comp != NULL, "Compiler object must exist");
-int system_dictionary_modification_counter;
-{
-MutexLocker locker(Compile_lock, thread);
-system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
-}
 {
 // Must switch to native to allocate ci_env
 ThreadToNativeFromVM ttn(thread);
-ciEnv ci_env(NULL, system_dictionary_modification_counter);
+ciEnv ci_env((CompileTask*)NULL);
 // Cache Jvmti state
 ci_env.cache_jvmti_state();
 // Cache DTrace flags
 ci_env.cache_dtrace_flags();
 // Find Compiler number by its threadObj.
 oop compiler_obj = ct->threadObj();
 int compiler_number = 0;
 bool found = false;
 for (; compiler_number < count; compiler_number++) {
-if (oopDesc::equals(JNIHandles::resolve_non_null(compiler_objects[compiler_number]), compiler_obj)) {
+if (JNIHandles::resolve_non_null(compiler_objects[compiler_number]) == compiler_obj) {
 found = true;
 break;
 }
 }
 assert(found, "Compiler must exist at this point");
 int compilable = ciEnv::MethodCompilable;
 const char* failure_reason = NULL;
 bool failure_reason_on_C_heap = false;
 const char* retry_message = NULL;
-int system_dictionary_modification_counter;
-{
-MutexLocker locker(Compile_lock, thread);
-system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
-}
 #if INCLUDE_JVMCI
 if (UseJVMCICompiler && comp != NULL && comp->is_jvmci()) {
 JVMCICompiler* jvmci = (JVMCICompiler*) comp;
 TraceTime t1("compilation", &time);
 if (target_handle->is_old()) {
 failure_reason = "redefined method";
 retry_message = "not retryable";
 compilable = ciEnv::MethodCompilable_never;
 } else {
-JVMCICompileState compile_state(task, system_dictionary_modification_counter);
+JVMCICompileState compile_state(task);
 JVMCIEnv env(thread, &compile_state, __FILE__, __LINE__);
 methodHandle method(thread, target_handle);
 env.runtime()->compile_method(&env, jvmci, method, osr_bci);
 failure_reason = compile_state.failure_reason();
 #endif // INCLUDE_JVMCI
 {
 NoHandleMark  nhm;
 ThreadToNativeFromVM ttn(thread);
-ciEnv ci_env(task, system_dictionary_modification_counter);
+ciEnv ci_env(task);
 if (should_break) {
 ci_env.set_break_at_compile(true);
 }
 if (should_log) {
 ci_env.set_log(thread->log());
 }
 // Disable compilation, if required.
 switch (compilable) {
 case ciEnv::MethodCompilable_never:
 if (is_osr)
-method->set_not_osr_compilable_quietly();
+method->set_not_osr_compilable_quietly("MethodCompilable_never");
 else
-method->set_not_compilable_quietly();
+method->set_not_compilable_quietly("MethodCompilable_never");
 break;
 case ciEnv::MethodCompilable_not_at_tier:
 if (is_osr)
-method->set_not_osr_compilable_quietly(task_level);
+method->set_not_osr_compilable_quietly("MethodCompilable_not_at_tier", task_level);
 else
-method->set_not_compilable_quietly(task_level);
+method->set_not_compilable_quietly("MethodCompilable_not_at_tier", task_level);
 break;
 }
 // Note that the queued_for_compilation bits are cleared without
 // protection of a mutex. [They were set by the requester thread,
 // Note: tty_lock must not be held upon entry to this function.
 //       Print functions called from herein do "micro-locking" on tty_lock.
 //       That's a tradeoff which keeps together important blocks of output.
 //       At the same time, continuous tty_lock hold time is kept in check,
 //       preventing concurrently printing threads from stalling a long time.
-void CompileBroker::print_heapinfo(outputStream* out, const char* function, const char* granularity) {
+void CompileBroker::print_heapinfo(outputStream* out, const char* function, size_t granularity) {
 TimeStamp ts_total;
 TimeStamp ts_global;
 TimeStamp ts;
 bool allFun = !strcmp(function, "all");
 // If we serve an "allFun" call, it is beneficial to hold the CodeCache_lock
 // for the entire duration of aggregation and printing. That makes sure
 // we see a consistent picture and do not run into issues caused by
 // the CodeHeap being altered concurrently.
-Monitor* global_lock   = allFun ? CodeCache_lock : NULL;
+Mutex* global_lock   = allFun ? CodeCache_lock : NULL;
-Monitor* function_lock = allFun ? NULL : CodeCache_lock;
+Mutex* function_lock = allFun ? NULL : CodeCache_lock;
 ts_global.update(); // record starting point
 MutexLocker mu2(global_lock, Mutex::_no_safepoint_check_flag);
 if (global_lock != NULL) {
 out->print_cr("\n__ CodeCache (global) lock wait took %10.3f seconds _________\n", ts_global.seconds());
 ts_global.update(); // record starting point

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54973	0927d8c7296f
child 58679	9c3209ff7550