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

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_OPTIMIZING_COMPILER_THREAD_H_
   6 #define V8_OPTIMIZING_COMPILER_THREAD_H_
   7
   8 #include "src/base/atomicops.h"
   9 #include "src/base/platform/condition-variable.h"
  10 #include "src/base/platform/mutex.h"
  11 #include "src/base/platform/platform.h"
  12 #include "src/base/platform/time.h"
  13 #include "src/flags.h"
  14 #include "src/list.h"
  15 #include "src/unbound-queue-inl.h"
  16
  17 namespace v8 {
  18 namespace internal {
  19
  20 class HOptimizedGraphBuilder;
  21 class OptimizedCompileJob;
  22 class SharedFunctionInfo;
  23
  24 class OptimizingCompilerThread : public base::Thread {
  25  public:
  26   explicit OptimizingCompilerThread(Isolate* isolate)
  27       : Thread(Options("OptimizingCompilerThread")),
  28 #ifdef DEBUG
  29         thread_id_(0),
  30 #endif
  31         isolate_(isolate),
  32         stop_semaphore_(0),
  33         input_queue_semaphore_(0),
  34         input_queue_capacity_(FLAG_concurrent_recompilation_queue_length),
  35         input_queue_length_(0),
  36         input_queue_shift_(0),
  37         osr_buffer_capacity_(FLAG_concurrent_recompilation_queue_length + 4),
  38         osr_buffer_cursor_(0),
  39         osr_hits_(0),
  40         osr_attempts_(0),
  41         blocked_jobs_(0),
  42         ref_count_(0),
  43         tracing_enabled_(FLAG_trace_concurrent_recompilation),
  44         job_based_recompilation_(FLAG_job_based_recompilation),
  45         recompilation_delay_(FLAG_concurrent_recompilation_delay) {
  46     base::NoBarrier_Store(&stop_thread_,
  47                           static_cast<base::AtomicWord>(CONTINUE));
  48     input_queue_ = NewArray<OptimizedCompileJob*>(input_queue_capacity_);
  49     if (FLAG_concurrent_osr) {
  50       // Allocate and mark OSR buffer slots as empty.
  51       osr_buffer_ = NewArray<OptimizedCompileJob*>(osr_buffer_capacity_);
  52       for (int i = 0; i < osr_buffer_capacity_; i++) osr_buffer_[i] = NULL;
  53     }
  54   }
  55
  56   ~OptimizingCompilerThread();
  57
  58   void Run();
  59   void Stop();
  60   void Flush();
  61   void QueueForOptimization(OptimizedCompileJob* optimizing_compiler);
  62   void Unblock();
  63   void InstallOptimizedFunctions();
  64   OptimizedCompileJob* FindReadyOSRCandidate(Handle<JSFunction> function,
  65                                              BailoutId osr_ast_id);
  66   bool IsQueuedForOSR(Handle<JSFunction> function, BailoutId osr_ast_id);
  67
  68   bool IsQueuedForOSR(JSFunction* function);
  69
  70   inline bool IsQueueAvailable() {
  71     base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_);
  72     return input_queue_length_ < input_queue_capacity_;
  73   }
  74
  75   inline void AgeBufferedOsrJobs() {
  76     // Advance cursor of the cyclic buffer to next empty slot or stale OSR job.
  77     // Dispose said OSR job in the latter case.  Calling this on every GC
  78     // should make sure that we do not hold onto stale jobs indefinitely.
  79     AddToOsrBuffer(NULL);
  80   }
  81
  82   static bool Enabled(int max_available) {
  83     return (FLAG_concurrent_recompilation && max_available > 1);
  84   }
  85
  86 #ifdef DEBUG
  87   static bool IsOptimizerThread(Isolate* isolate);
  88   bool IsOptimizerThread();
  89 #endif
  90
  91  private:
  92   class CompileTask;
  93
  94   enum StopFlag { CONTINUE, STOP, FLUSH };
  95
  96   void FlushInputQueue(bool restore_function_code);
  97   void FlushOutputQueue(bool restore_function_code);
  98   void FlushOsrBuffer(bool restore_function_code);
  99   void CompileNext(OptimizedCompileJob* job);
 100   OptimizedCompileJob* NextInput(bool check_if_flushing = false);
 101
 102   // Add a recompilation task for OSR to the cyclic buffer, awaiting OSR entry.
 103   // Tasks evicted from the cyclic buffer are discarded.
 104   void AddToOsrBuffer(OptimizedCompileJob* compiler);
 105
 106   inline int InputQueueIndex(int i) {
 107     int result = (i + input_queue_shift_) % input_queue_capacity_;
 108     DCHECK_LE(0, result);
 109     DCHECK_LT(result, input_queue_capacity_);
 110     return result;
 111   }
 112
 113 #ifdef DEBUG
 114   int thread_id_;
 115   base::Mutex thread_id_mutex_;
 116 #endif
 117
 118   Isolate* isolate_;
 119   base::Semaphore stop_semaphore_;
 120   base::Semaphore input_queue_semaphore_;
 121
 122   // Circular queue of incoming recompilation tasks (including OSR).
 123   OptimizedCompileJob** input_queue_;
 124   int input_queue_capacity_;
 125   int input_queue_length_;
 126   int input_queue_shift_;
 127   base::Mutex input_queue_mutex_;
 128
 129   // Queue of recompilation tasks ready to be installed (excluding OSR).
 130   UnboundQueue<OptimizedCompileJob*> output_queue_;
 131   // Used for job based recompilation which has multiple producers on
 132   // different threads.
 133   base::Mutex output_queue_mutex_;
 134
 135   // Cyclic buffer of recompilation tasks for OSR.
 136   OptimizedCompileJob** osr_buffer_;
 137   int osr_buffer_capacity_;
 138   int osr_buffer_cursor_;
 139
 140   volatile base::AtomicWord stop_thread_;
 141   base::TimeDelta time_spent_compiling_;
 142   base::TimeDelta time_spent_total_;
 143
 144   int osr_hits_;
 145   int osr_attempts_;
 146
 147   int blocked_jobs_;
 148
 149   int ref_count_;
 150   base::Mutex ref_count_mutex_;
 151   base::ConditionVariable ref_count_zero_;
 152
 153   // Copies of FLAG_trace_concurrent_recompilation,
 154   // FLAG_concurrent_recompilation_delay and
 155   // FLAG_job_based_recompilation that will be used from the background thread.
 156   //
 157   // Since flags might get modified while the background thread is running, it
 158   // is not safe to access them directly.
 159   bool tracing_enabled_;
 160   bool job_based_recompilation_;
 161   int recompilation_delay_;
 162 };
 163
 164 } }  // namespace v8::internal
 165
 166 #endif  // V8_OPTIMIZING_COMPILER_THREAD_H_