*** old/src/share/vm/compiler/abstractCompiler.cpp	Wed Oct  9 06:56:39 2013
--- new/src/share/vm/compiler/abstractCompiler.cpp	Wed Oct  9 06:56:39 2013

*** 23,64 ****
--- 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;
+ 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 (*state == initializing ) {
!       while (_compiler_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)();
+   return false;
+ }
  
        // To in_vm so we can use the lock
+ bool AbstractCompiler::should_perform_shutdown() {
+   // Since this method can be called by multiple threads, the lock ensures atomicity of
+   // decrementing '_num_compiler_threads' and the following operations.
+   MutexLocker only_one(CompileThread_lock);
+   _num_compiler_threads--;
+   assert (CompileBroker::is_compilation_disabled_forever(), "Must be set, otherwise thread waits forever");
+ 
+   // Only the last thread will perform shutdown operations
+   if (_num_compiler_threads == 0) {
+     return true;
+   }
+   return false;
+ }
  
        ThreadInVMfromNative tv(thread);
        ResetNoHandleMark rnhm;
!       MutexLocker only_one(CompileThread_lock, thread);
!       assert(*state == initializing, "wrong state");
        *state = initialized;
+ void AbstractCompiler::set_state(int state) {
+   // Ensure that ste is only set by one thread at a time
!   _compiler_state =  state;
    CompileThread_lock->notify_all();
      }
    }
  }