deps/v8/src/optimizing-compiler-thread.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "optimizing-compiler-thread.h"
  29
  30 #include "v8.h"
  31
  32 #include "hydrogen.h"
  33 #include "isolate.h"
  34 #include "v8threads.h"
  35
  36 namespace v8 {
  37 namespace internal {
  38
  39
  40 void OptimizingCompilerThread::Run() {
  41 #ifdef DEBUG
  42   thread_id_ = ThreadId::Current().ToInteger();
  43 #endif
  44   Isolate::SetIsolateThreadLocals(isolate_, NULL);
  45
  46   int64_t epoch = 0;
  47   if (FLAG_trace_parallel_recompilation) epoch = OS::Ticks();
  48
  49   while (true) {
  50     input_queue_semaphore_->Wait();
  51     if (Acquire_Load(&stop_thread_)) {
  52       stop_semaphore_->Signal();
  53       if (FLAG_trace_parallel_recompilation) {
  54         time_spent_total_ = OS::Ticks() - epoch;
  55       }
  56       return;
  57     }
  58
  59     int64_t compiling_start = 0;
  60     if (FLAG_trace_parallel_recompilation) compiling_start = OS::Ticks();
  61
  62     Heap::RelocationLock relocation_lock(isolate_->heap());
  63     OptimizingCompiler* optimizing_compiler = NULL;
  64     input_queue_.Dequeue(&optimizing_compiler);
  65     Barrier_AtomicIncrement(&queue_length_, static_cast<Atomic32>(-1));
  66
  67     ASSERT(!optimizing_compiler->info()->closure()->IsOptimized());
  68
  69     OptimizingCompiler::Status status = optimizing_compiler->OptimizeGraph();
  70     ASSERT(status != OptimizingCompiler::FAILED);
  71     // Prevent an unused-variable error in release mode.
  72     USE(status);
  73
  74     output_queue_.Enqueue(optimizing_compiler);
  75     isolate_->stack_guard()->RequestCodeReadyEvent();
  76
  77     if (FLAG_trace_parallel_recompilation) {
  78       time_spent_compiling_ += OS::Ticks() - compiling_start;
  79     }
  80   }
  81 }
  82
  83
  84 void OptimizingCompilerThread::Stop() {
  85   Release_Store(&stop_thread_, static_cast<AtomicWord>(true));
  86   input_queue_semaphore_->Signal();
  87   stop_semaphore_->Wait();
  88
  89   if (FLAG_trace_parallel_recompilation) {
  90     double compile_time = static_cast<double>(time_spent_compiling_);
  91     double total_time = static_cast<double>(time_spent_total_);
  92     double percentage = (compile_time * 100) / total_time;
  93     PrintF("  ** Compiler thread did %.2f%% useful work\n", percentage);
  94   }
  95 }
  96
  97
  98 void OptimizingCompilerThread::InstallOptimizedFunctions() {
  99   HandleScope handle_scope(isolate_);
 100   int functions_installed = 0;
 101   while (!output_queue_.IsEmpty()) {
 102     OptimizingCompiler* compiler = NULL;
 103     output_queue_.Dequeue(&compiler);
 104     Compiler::InstallOptimizedCode(compiler);
 105     functions_installed++;
 106   }
 107   if (FLAG_trace_parallel_recompilation && functions_installed != 0) {
 108     PrintF("  ** Installed %d function(s).\n", functions_installed);
 109   }
 110 }
 111
 112
 113 void OptimizingCompilerThread::QueueForOptimization(
 114     OptimizingCompiler* optimizing_compiler) {
 115   input_queue_.Enqueue(optimizing_compiler);
 116   input_queue_semaphore_->Signal();
 117 }
 118
 119 #ifdef DEBUG
 120 bool OptimizingCompilerThread::IsOptimizerThread() {
 121   if (!FLAG_parallel_recompilation) return false;
 122   return ThreadId::Current().ToInteger() == thread_id_;
 123 }
 124 #endif
 125
 126
 127 } }  // namespace v8::internal