src/share/vm/compiler/abstractCompiler.cpp
Print this page
*** 23,64 ****
#include "precompiled.hpp"
#include "compiler/abstractCompiler.hpp"
#include "runtime/mutexLocker.hpp"
- void AbstractCompiler::initialize_runtimes(initializer f, volatile int* state) {
- if (*state != initialized) {
! // We are thread in native here...
! CompilerThread* thread = CompilerThread::current();
! bool do_initialization = false;
! {
! ThreadInVMfromNative tv(thread);
! ResetNoHandleMark rnhm;
! MutexLocker only_one(CompileThread_lock, thread);
! if ( *state == uninitialized) {
! do_initialization = true;
! *state = initializing;
} else {
! while (*state == initializing ) {
CompileThread_lock->wait();
}
}
}
! if (do_initialization) {
! // We can not hold any locks here since JVMTI events may call agents
!
! // Compiler(s) run as native
!
! (*f)();
!
! // To in_vm so we can use the lock
! ThreadInVMfromNative tv(thread);
! ResetNoHandleMark rnhm;
! MutexLocker only_one(CompileThread_lock, thread);
! assert(*state == initializing, "wrong state");
! *state = initialized;
CompileThread_lock->notify_all();
- }
- }
}
--- 23,53 ----
#include "precompiled.hpp"
#include "compiler/abstractCompiler.hpp"
#include "runtime/mutexLocker.hpp"
! bool AbstractCompiler::should_perform_init() {
! if (_compiler_state != initialized) {
! MutexLocker only_one(CompileThread_lock);
!
! if (_compiler_state == uninitialized) {
! _compiler_state = initializing;
! return true;
} else {
! while (_compiler_state == initializing ) {
CompileThread_lock->wait();
}
}
}
! return false;
! }
! void AbstractCompiler::set_state(int state) {
! assert((_compiler_state == initializing) || (_compiler_state == failed), "wrong state");
! MutexLocker only_one(CompileThread_lock);
!
! // The state of the compiler could have been changed by another thread if
! // memory allocation of the buffer blob failed.
! _compiler_state = state;
CompileThread_lock->notify_all();
}