src/share/vm/compiler/compileBroker.cpp
Print this page
@@ -184,11 +184,11 @@
CompileQueue* CompileBroker::_c2_method_queue = NULL;
CompileQueue* CompileBroker::_c1_method_queue = NULL;
CompileTask* CompileBroker::_task_free_list = NULL;
-GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;
+GrowableArray<CompilerThread*>* CompileBroker::_compiler_threads = NULL;
class CompilationLog : public StringEventLog {
public:
CompilationLog() : StringEventLog("Compilation events") {
@@ -585,13 +585,10 @@
log->mark_file_end();
}
-// ------------------------------------------------------------------
-// CompileQueue::add
-//
// Add a CompileTask to a CompileQueue
void CompileQueue::add(CompileTask* task) {
assert(lock()->owned_by_self(), "must own lock");
task->set_next(NULL);
@@ -624,10 +621,20 @@
// Notify CompilerThreads that a task is available.
lock()->notify_all();
}
+void CompileQueue::delete_all() {
+ assert(lock()->owned_by_self(), "must own lock");
+ if (_first != NULL) {
+ for (CompileTask* task = _first; task != NULL; task = task->next()) {
+ delete task;
+ }
+ _first = NULL;
+ }
+}
+
// ------------------------------------------------------------------
// CompileQueue::get
//
// Get the next CompileTask from a CompileQueue
CompileTask* CompileQueue::get() {
@@ -889,14 +896,12 @@
_initialized = true;
}
-
-// ------------------------------------------------------------------
-// CompileBroker::make_compiler_thread
-CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
+CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters,
+ AbstractCompiler* comp, TRAPS) {
CompilerThread* compiler_thread = NULL;
Klass* k =
SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(),
true, CHECK_0);
@@ -959,10 +964,11 @@
os::set_native_priority(compiler_thread, native_prio);
java_lang_Thread::set_daemon(thread_oop());
compiler_thread->set_threadObj(thread_oop());
+ compiler_thread->set_compiler(comp);
Threads::add(compiler_thread);
Thread::start(compiler_thread);
}
// Let go of Threads_lock before yielding
@@ -970,51 +976,51 @@
return compiler_thread;
}
-// ------------------------------------------------------------------
-// CompileBroker::init_compiler_threads
-//
-// Initialize the compilation queue
void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {
EXCEPTION_MARK;
#if !defined(ZERO) && !defined(SHARK)
assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
#endif // !ZERO && !SHARK
+ // Initialize the compilation queue
if (c2_compiler_count > 0) {
_c2_method_queue = new CompileQueue("C2MethodQueue", MethodCompileQueue_lock);
+ _compilers[1]->set_num_compiler_threads(c2_compiler_count);
}
if (c1_compiler_count > 0) {
_c1_method_queue = new CompileQueue("C1MethodQueue", MethodCompileQueue_lock);
+ _compilers[0]->set_num_compiler_threads(c1_compiler_count);
}
int compiler_count = c1_compiler_count + c2_compiler_count;
- _method_threads =
+ _compiler_threads =
new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true);
char name_buffer[256];
for (int i = 0; i < c2_compiler_count; i++) {
// Create a name for our thread.
sprintf(name_buffer, "C2 CompilerThread%d", i);
CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
- CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK);
- _method_threads->append(new_thread);
+ // Shark and C2
+ CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, _compilers[1], CHECK);
+ _compiler_threads->append(new_thread);
}
for (int i = c2_compiler_count; i < compiler_count; i++) {
// Create a name for our thread.
sprintf(name_buffer, "C1 CompilerThread%d", i);
CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
- CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK);
- _method_threads->append(new_thread);
+ // C1
+ CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, _compilers[0], CHECK);
+ _compiler_threads->append(new_thread);
}
if (UsePerfData) {
- PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
- compiler_count, CHECK);
+ 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
@@ -1027,31 +1033,10 @@
_c1_method_queue->mark_on_stack();
}
}
// ------------------------------------------------------------------
-// CompileBroker::is_idle
-bool CompileBroker::is_idle() {
- if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) {
- return false;
- } else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) {
- return false;
- } else {
- int num_threads = _method_threads->length();
- for (int i=0; i<num_threads; i++) {
- if (_method_threads->at(i)->task() != NULL) {
- return false;
- }
- }
-
- // No pending or active compilations.
- return true;
- }
-}
-
-
-// ------------------------------------------------------------------
// CompileBroker::compile_method
//
// Request compilation of a method.
void CompileBroker::compile_method_base(methodHandle method,
int osr_bci,
@@ -1549,18 +1534,109 @@
// waiting on a CompileTask, we know that no one else will
// be using this CompileTask; we can free it.
free_task(task);
}
+// Initialize compiler thread(s) + compiler object(s).
+bool CompileBroker::init_compiler_runtime() {
+ 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);
+ // Cache Jvmti state
+ ci_env.cache_jvmti_state();
+ // Cache DTrace flags
+ ci_env.cache_dtrace_flags();
+
+ // Switch back to VM state to to compiler initialization
+ ThreadInVMfromNative tv(thread);
+ ResetNoHandleMark rnhm;
+
+ if (!comp->is_shark()) {
+ // Perform per-thread and global initializations
+ comp->initialize();
+ }
+ }
+
+ if (comp->is_state_failed()) {
+ disable_compilation_forever();
+ // If compiler initialization failed, no compiler thread that is specific to a
+ // particular compiler runtime will ever start to compile methods.
+
+ // Tiered: If C1 and/or C2 initialization failed, we shut down all compilation.
+ // We do this to keep things simple. This can be changed if it ever turns out to be
+ // a problem.
+
+ if (comp->should_perform_shutdown()) {
+ MutexLocker mu(MethodCompileQueue_lock, thread);
+ CompileQueue* queue;
+ if (_c1_method_queue != NULL) {
+ _c1_method_queue->delete_all();
+ queue = _c1_method_queue;
+ _c1_method_queue = NULL;
+ delete _c1_method_queue;
+ }
+
+ if (_c2_method_queue != NULL) {
+ _c2_method_queue->delete_all();
+ queue = _c2_method_queue;
+ _c2_method_queue = NULL;
+ delete _c2_method_queue;
+ }
+ }
+ warning("Initialization of %s failed -- shutting down compiler(s)", comp->name());
+
+ // Free buffer blob, if allocated
+ if (thread->get_buffer_blob() != NULL) {
+ CodeCache::free(thread->get_buffer_blob());
+ }
+
+ // Set state to shut down
+ comp->set_shut_down();
+
+ // Delete compiler runtimes
+ MutexLocker mu(MethodCompileQueue_lock, thread);
+ if ((comp->is_c1()) && (_compilers[0] != NULL)) {
+ delete _compilers[0];
+ _compilers[0] = NULL;
+ }
+
+ if ((comp->is_c2()) && (_compilers[1] != NULL)) {
+ delete _compilers[1];
+ _compilers[1] = NULL;
+ }
+
+ return false;
+ }
+
+ // C1 specific check
+ if ((comp->is_c1()) && (thread->get_buffer_blob() == NULL)) {
+ warning("Initialization of %s thread failed", comp->name());
+ return false;
+ }
+
+ return true;
+}
+
// ------------------------------------------------------------------
// CompileBroker::compiler_thread_loop
//
// The main loop run by a CompilerThread.
void CompileBroker::compiler_thread_loop() {
CompilerThread* thread = CompilerThread::current();
CompileQueue* queue = thread->queue();
-
// For the thread that initializes the ciObjectFactory
// this resource mark holds all the shared objects
ResourceMark rm;
// First thread to get here will initialize the compiler interface
@@ -1585,12 +1661,21 @@
os::current_process_id());
log->stamp();
log->end_elem();
}
- while (true) {
- {
+ // If compiler thread/runtime initialization fails, exit the compiler thread
+ if (!init_compiler_runtime()) {
+ return;
+ }
+
+ // Poll for new compilation tasks as long as the JVM runs. Compilation
+ // should only be disabled if something went wrong while initializing the
+ // compiler runtimes. This, in turn, should not happen. The only known case
+ // when compiler runtime initialization fails is if there is not enough free
+ // space in the code cache to generate the necessary stubs, etc.
+ while (!is_compilation_disabled_forever()) {
// We need this HandleMark to avoid leaking VM handles.
HandleMark hm(thread);
if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
// the code cache is really full
@@ -1640,14 +1725,12 @@
// After compilation is disabled, remove remaining methods from queue
method->clear_queued_for_compilation();
}
}
}
- }
}
-
// ------------------------------------------------------------------
// CompileBroker::init_compiler_thread_log
//
// Set up state required by +LogCompilation.
void CompileBroker::init_compiler_thread_log() {