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

comparison src/share/vm/compiler/compileBroker.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	3eed8712d410 f73af4455d7d
children	2a69cbe850a8

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;
 // The installed compiler(s)
 AbstractCompiler* CompileBroker::_compilers[2];
-// These counters are used for assigning id's to each compilation
+// These counters are used to assign an unique ID to each compilation.
-uint CompileBroker::_compilation_id        = 0;
+volatile jint CompileBroker::_compilation_id     = 0;
-uint CompileBroker::_osr_compilation_id    = 0;
+volatile jint CompileBroker::_osr_compilation_id = 0;
 // Debugging information
 int  CompileBroker::_last_compile_type     = no_compile;
 int  CompileBroker::_last_compile_level    = CompLevel_none;
 char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];
 }
 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());
+p2i(nm), p2i(nm->code_begin()), p2i(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);
 }
 // We now know that this compilation is not pending, complete,
 // or prohibited.  Assign a compile_id to this compilation
 // and check to see if it is in our [Start..Stop) range.
-uint compile_id = assign_compile_id(method, osr_bci);
+int compile_id = assign_compile_id(method, osr_bci);
 if (compile_id == 0) {
 // The compilation falls outside the allowed range.
 return;
 }
 }
 // do the compilation
 if (method->is_native()) {
 if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {
-// Acquire our lock.
-int compile_id;
-{
-MutexLocker locker(MethodCompileQueue_lock, THREAD);
-compile_id = assign_compile_id(method, standard_entry_bci);
-}
 // To properly handle the appendix argument for out-of-line calls we are using a small trampoline that
 // pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime).
 //
 // Since normal compiled-to-compiled calls are not able to handle such a thing we MUST generate an adapter
 // in this case.  If we can't generate one and use it we can not execute the out-of-line method handle calls.
-(void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id);
+AdapterHandlerLibrary::create_native_wrapper(method);
 } else {
 return NULL;
 }
 } else {
 // If the compiler is shut off due to code cache getting full
 }
 return false;
 }
+/**
-// ------------------------------------------------------------------
+* Generate serialized IDs for compilation requests. If certain debugging flags are used
-// CompileBroker::assign_compile_id
+* and the ID is not within the specified range, the method is not compiled and 0 is returned.
-//
+* The function also allows to generate separate compilation IDs for OSR compilations.
-// Assign a serialized id number to this compilation request.  If the
+*/
-// number falls out of the allowed range, return a 0.  OSR
+int CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
-// compilations may be numbered separately from regular compilations
+#ifdef ASSERT
-// if certain debugging flags are used.
-uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
-assert(MethodCompileQueue_lock->owner() == Thread::current(),
-"must hold the compilation queue lock");
 bool is_osr = (osr_bci != standard_entry_bci);
-uint id;
+int id;
-if (CICountOSR && is_osr) {
+if (method->is_native()) {
-id = ++_osr_compilation_id;
+assert(!is_osr, "can't be osr");
-if ((uint)CIStartOSR <= id && id < (uint)CIStopOSR) {
+// Adapters, native wrappers and method handle intrinsics
+// should be generated always.
+return Atomic::add(1, &_compilation_id);
+} else if (CICountOSR && is_osr) {
+id = Atomic::add(1, &_osr_compilation_id);
+if (CIStartOSR <= id && id < CIStopOSR) {
 return id;
 }
 } else {
-id = ++_compilation_id;
+id = Atomic::add(1, &_compilation_id);
-if ((uint)CIStart <= id && id < (uint)CIStop) {
+if (CIStart <= id && id < CIStop) {
 return id;
 }
 }
 // Method was not in the appropriate compilation range.
 method->set_not_compilable_quietly();
 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);
+#endif
 }
 // ------------------------------------------------------------------
 // CompileBroker::assign_compile_id_unlocked
 thread->init_log(log);
 if (xtty != NULL) {
 ttyLocker ttyl;
 // Record any per thread log files
-xtty->elem("thread_logfile thread='%d' filename='%s'", thread_id, file_name);
+xtty->elem("thread_logfile thread='" INTX_FORMAT "' filename='%s'", thread_id, file_name);
 }
 return;
 }
 }
 warning("Cannot open log file: %s", file_name);
 // Call this from the compiler at convenient points, to poll for _should_block.
 void CompileBroker::maybe_block() {
 if (_should_block) {
 #ifndef PRODUCT
 if (PrintCompilation && (Verbose || WizardMode))
-tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", Thread::current());
+tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", p2i(Thread::current()));
 #endif
 ThreadInVMfromNative tivfn(JavaThread::current());
 }
 }
 {
 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 CodeCache::print_summary(&s, detailed);
 }
 ttyLocker ttyl;
-tty->print(s.as_string());
+tty->print("%s", s.as_string());
 }
 void CompileBroker::post_compile(CompilerThread* thread, CompileTask* task, EventCompilation& event, bool success, ciEnv* ci_env) {
 if (success) {
 // because log_state() will use locks causing lock conflicts.
 CodeCache::log_state(&s);
 // Lock to prevent tearing
 ttyLocker ttyl;
 xtty->begin_elem("code_cache_full");
-xtty->print(s.as_string());
+xtty->print("%s", s.as_string());
 xtty->stamp();
 xtty->end_elem();
 }
 CodeCache::report_codemem_full();

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/compiler/compileBroker.cpp @ 18041:52b4284cb496