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

comparison src/share/vm/compiler/compileBroker.cpp @ 15463:a20be10ad437

made Graal work with the HotSpot compiler queue and compiler threads, enabled by -XX:-UseGraalCompilationQueue

author	Doug Simon <doug.simon@oracle.com>
date	Fri, 02 May 2014 00:36:27 +0200
parents	4062efea018b
children	07fac8558d7b

comparison

equal deleted inserted replaced

-:05d3f069cff2
+:a20be10ad437
 }
 #endif // COMPILER1
 #if defined(COMPILERGRAAL)
 _compilers[1] = graal;
-c2_count = 0;
+c2_count = UseGraalCompilationQueue ? 0 : c2_count;
 #endif // COMPILERGRAAL
 #ifdef COMPILER2
 if (c2_count > 0) {
 _compilers[1] = new C2Compiler();
 // by a compiler thread), and compiled method registration.
 if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
 return;
 }
-#if defined(COMPILERGRAAL)
+#ifdef COMPILERGRAAL
-// In tiered mode we want to only handle highest tier compiles and
+if (UseGraalCompilationQueue) {
-// in non-tiered mode the default level should be
+// In tiered mode we want to only handle highest tier compiles and
-// CompLevel_full_optimization which equals CompLevel_highest_tier.
+// in non-tiered mode the default level should be
-assert(TieredCompilation || comp_level == CompLevel_full_optimization, "incorrect compile level");
+// CompLevel_full_optimization which equals CompLevel_highest_tier.
-assert(CompLevel_full_optimization == CompLevel_highest_tier, "incorrect level definition");
+assert(TieredCompilation || comp_level == CompLevel_full_optimization, "incorrect compile level");
-if (comp_level == CompLevel_full_optimization) {
+assert(CompLevel_full_optimization == CompLevel_highest_tier, "incorrect level definition");
-if (!JavaThread::current()->is_graal_compiling()) {
+if (comp_level == CompLevel_full_optimization) {
-bool blockingCompilation = is_compile_blocking(method, osr_bci);
+if (!JavaThread::current()->is_graal_compiling()) {
-GraalCompiler::instance()->compile_method(method, osr_bci, blockingCompilation);
+bool blockingCompilation = is_compile_blocking(method, osr_bci);
-} else {
+GraalCompiler::instance()->compile_method(method, osr_bci, NULL, blockingCompilation);
-// Can't enqueue this request because there would be no one to service it, so simply return.
+} else {
-}
+// Can't enqueue this request because there would be no one to service it, so simply return.
-return;
+}
-}
+return;
-assert(TieredCompilation, "should only reach here in tiered mode");
+}
+assert(TieredCompilation, "should only reach here in tiered mode");
+}
 #endif // COMPILERGRAAL
 // Outputs from the following MutexLocker block:
 CompileTask* task     = NULL;
 bool         blocking = false;
 }
 ttyLocker ttyl;
 tty->print(s.as_string());
 }
+void CompileBroker::post_compile(CompilerThread* thread, CompileTask* task, EventCompilation& event, bool success, ciEnv* ci_env) {
+if (success) {
+task->mark_success();
+if (ci_env != NULL) {
+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);
+}
+}
+}
+// simulate crash during compilation
+assert(task->compile_id() != CICrashAt, "just as planned");
+if (event.should_commit()) {
+event.set_method(task->method());
+event.set_compileID(task->compile_id());
+event.set_compileLevel(task->comp_level());
+event.set_succeded(task->is_success());
+event.set_isOsr(task->osr_bci() != CompileBroker::standard_entry_bci);
+event.set_codeSize((task->code() == NULL) ? 0 : task->code()->total_size());
+event.set_inlinedBytes(task->num_inlined_bytecodes());
+event.commit();
+}
+}
 // ------------------------------------------------------------------
 // CompileBroker::invoke_compiler_on_method
 //
 // Compile a method.
 //
 // Allocate a new set of JNI handles.
 push_jni_handle_block();
 Method* target_handle = task->method();
 int compilable = ciEnv::MethodCompilable;
+AbstractCompiler *comp = compiler(task_level);
+#ifdef COMPILERGRAAL
+if (comp != NULL && comp->is_graal()) {
+assert(!UseGraalCompilationQueue, "should not reach here");
+GraalCompiler* graal = (GraalCompiler*) comp;
+TraceTime t1("compilation", &time);
+EventCompilation event;
+graal->compile_method(target_handle, osr_bci, task, false);
+post_compile(thread, task, event, task->code() != NULL, NULL);
+} else
+#endif // COMPILERGRAAL
 {
 int system_dictionary_modification_counter;
 {
 MutexLocker locker(Compile_lock, thread);
 system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
 ciMethod* target = ci_env.get_method_from_handle(target_handle);
 TraceTime t1("compilation", &time);
 EventCompilation event;
-AbstractCompiler *comp = compiler(task_level);
 if (comp == NULL) {
 ci_env.record_method_not_compilable("no compiler", !TieredCompilation);
 } else {
 comp->compile_method(&ci_env, target, osr_bci);
 }
 FormatBufferResource msg = retry_message != NULL ?
 err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) :
 err_msg_res("COMPILE SKIPPED: %s",      ci_env.failure_reason());
 task->print_compilation(tty, msg);
 }
-} else {
+}
-task->mark_success();
-task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes());
+post_compile(thread, task, event, !ci_env.failing(), &ci_env);
-if (_compilation_log != NULL) {
-nmethod* code = task->code();
-if (code != NULL) {
-_compilation_log->log_nmethod(thread, code);
-}
-}
-}
-// simulate crash during compilation
-assert(task->compile_id() != CICrashAt, "just as planned");
-if (event.should_commit()) {
-event.set_method(target->get_Method());
-event.set_compileID(compile_id);
-event.set_compileLevel(task->comp_level());
-event.set_succeded(task->is_success());
-event.set_isOsr(is_osr);
-event.set_codeSize((task->code() == NULL) ? 0 : task->code()->total_size());
-event.set_inlinedBytes(task->num_inlined_bytecodes());
-event.commit();
-}
 }
 pop_jni_handle_block();
 methodHandle method(thread, task->method());

Mercurial > hg > truffle

comparison src/share/vm/compiler/compileBroker.cpp @ 15463:a20be10ad437