src/share/vm/c1/c1_Compiler.cpp

*** 25,87 ****
  #include "incls/_precompiled.incl"
  #include "incls/_c1_Compiler.cpp.incl"
  
  volatile int Compiler::_runtimes = uninitialized;
  
- volatile bool Compiler::_compiling = false;
- 
- 
  Compiler::Compiler() {
  }
  
  
  Compiler::~Compiler() {
    Unimplemented();
  }
  
  
  void Compiler::initialize() {
    if (_runtimes != initialized) {
!     initialize_runtimes( Runtime1::initialize, &_runtimes);
    }
    mark_initialized();
  }
  
  
  void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
  
    if (!is_initialized()) {
      initialize();
    }
    // invoke compilation
- #ifdef TIERED
-   // We are thread in native here...
-   CompilerThread* thread = CompilerThread::current();
-   {
-     ThreadInVMfromNative tv(thread);
-     MutexLocker only_one (C1_lock, thread);
-     while ( _compiling) {
-       C1_lock->wait();
-     }
-     _compiling = true;
-   }
- #endif // TIERED
    {
      // We are nested here because we need for the destructor
      // of Compilation to occur before we release the any
      // competing compiler thread
      ResourceMark rm;
!     Compilation c(this, env, method, entry_bci);
!   }
! #ifdef TIERED
!   {
!     ThreadInVMfromNative tv(thread);
!     MutexLocker only_one (C1_lock, thread);
!     _compiling = false;
!     C1_lock->notify();
    }
- #endif // TIERED
  }
  
  
  void Compiler::print_timers() {
    Compilation::print_timers();
--- 25,100 ----
  #include "incls/_precompiled.incl"
  #include "incls/_c1_Compiler.cpp.incl"
  
  volatile int Compiler::_runtimes = uninitialized;
  
  Compiler::Compiler() {
  }
  
  
  Compiler::~Compiler() {
    Unimplemented();
  }
  
  
+ void Compiler::initialize_all() {
+   BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
+   Arena* arena = new Arena();
+   Runtime1::initialize(buffer_blob);
+   FrameMap::initialize();
+   // initialize data structures
+   ValueType::initialize(arena);
+   // Instruction::initialize();
+   // BlockBegin::initialize();
+   GraphBuilder::initialize();
+   // note: to use more than on instance of LinearScan at a time this function call has to
+   //       be moved somewhere outside of this constructor:
+   Interval::initialize(arena);
+ }
+ 
+ 
  void Compiler::initialize() {
    if (_runtimes != initialized) {
!     ciEnv* env = ciEnv::current();
!     initialize_runtimes( initialize_all, &_runtimes);
    }
    mark_initialized();
  }
  
  
+ BufferBlob* Compiler::build_buffer_blob() {
+   // setup CodeBuffer.  Preallocate a BufferBlob of size
+   // NMethodSizeLimit plus some extra space for constants.
+   int code_buffer_size = Compilation::desired_max_code_buffer_size() +
+     Compilation::desired_max_constant_size();
+   BufferBlob* blob = BufferBlob::create("Compiler1 temporary CodeBuffer",
+                                         code_buffer_size);
+   guarantee(blob != NULL, "must create initial code buffer");
+   return blob;
+ }
+ 
+ 
  void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
+   // Allocate buffer blob once at startup since allocation for each
+   // compilation seems to be too expensive (at least on Intel win32).
+   BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
+   if (buffer_blob == NULL) {
+     buffer_blob = build_buffer_blob();
+     CompilerThread::current()->set_buffer_blob(buffer_blob);
+   }
  
    if (!is_initialized()) {
      initialize();
    }
    // invoke compilation
    {
      // We are nested here because we need for the destructor
      // of Compilation to occur before we release the any
      // competing compiler thread
      ResourceMark rm;
!     Compilation c(this, env, method, entry_bci, buffer_blob);
    }
  }
  
  
  void Compiler::print_timers() {
    Compilation::print_timers();