Create compiler-scheduler subdir and move existing scheduler there

src/compiler-dispatcher/optimizing-compile-dispatcher.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/optimizing-compile-dispatcher.h"
+#include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
 
 #include "src/base/atomicops.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/isolate.h"
 #include "src/tracing/trace-event.h"
 #include "src/v8.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 void DisposeCompilationJob(CompilationJob* job, bool restore_function_code) {
   if (restore_function_code) {
     Handle<JSFunction> function = job->info()->closure();
     function->ReplaceCode(function->shared()->code());
     // TODO(mvstanton): We can't call ensureliterals here due to allocation,
     // but we probably shouldn't call ReplaceCode either, as this
     // sometimes runs on the worker thread!
     // JSFunction::EnsureLiterals(function);
   }
   delete job;
 }
 
 }  // namespace
 
-
 class OptimizingCompileDispatcher::CompileTask : public v8::Task {
  public:
   explicit CompileTask(Isolate* isolate) : isolate_(isolate) {
     OptimizingCompileDispatcher* dispatcher =
         isolate_->optimizing_compile_dispatcher();
     base::LockGuard<base::Mutex> lock_guard(&dispatcher->ref_count_mutex_);
     ++dispatcher->ref_count_;
   }
 
   virtual ~CompileTask() {}
@@ skipping 26 matching lines @@
         dispatcher->ref_count_zero_.NotifyOne();
       }
     }
   }
 
   Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(CompileTask);
 };
 
-
 OptimizingCompileDispatcher::~OptimizingCompileDispatcher() {
 #ifdef DEBUG
   {
     base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
     DCHECK_EQ(0, ref_count_);
   }
 #endif
   DCHECK_EQ(0, input_queue_length_);
   DeleteArray(input_queue_);
 }
@@ skipping 23 matching lines @@
   USE(status);  // Prevent an unused-variable error.
 
   // The function may have already been optimized by OSR.  Simply continue.
   // Use a mutex to make sure that functions marked for install
   // are always also queued.
   base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
   output_queue_.push(job);
   isolate_->stack_guard()->RequestInstallCode();
 }
 
-
 void OptimizingCompileDispatcher::FlushOutputQueue(bool restore_function_code) {
   for (;;) {
     CompilationJob* job = NULL;
     {
       base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
       if (output_queue_.empty()) return;
       job = output_queue_.front();
       output_queue_.pop();
     }
 
     DisposeCompilationJob(job, restore_function_code);
   }
 }
 
-
 void OptimizingCompileDispatcher::Flush() {
   base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
   if (FLAG_block_concurrent_recompilation) Unblock();
   {
     base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
     while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_);
     base::Release_Store(&mode_, static_cast<base::AtomicWord>(COMPILE));
   }
   FlushOutputQueue(true);
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Flushed concurrent recompilation queues.\n");
   }
 }
 
-
 void OptimizingCompileDispatcher::Stop() {
   base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
   if (FLAG_block_concurrent_recompilation) Unblock();
   {
     base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
     while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_);
     base::Release_Store(&mode_, static_cast<base::AtomicWord>(COMPILE));
   }
 
   if (recompilation_delay_ != 0) {
     // At this point the optimizing compiler thread's event loop has stopped.
     // There is no need for a mutex when reading input_queue_length_.
     while (input_queue_length_ > 0) CompileNext(NextInput());
     InstallOptimizedFunctions();
   } else {
     FlushOutputQueue(false);
   }
 }
 
-
 void OptimizingCompileDispatcher::InstallOptimizedFunctions() {
   HandleScope handle_scope(isolate_);
 
   for (;;) {
     CompilationJob* job = NULL;
     {
       base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
       if (output_queue_.empty()) return;
       job = output_queue_.front();
       output_queue_.pop();
@@ skipping 23 matching lines @@
     input_queue_length_++;
   }
   if (FLAG_block_concurrent_recompilation) {
     blocked_jobs_++;
   } else {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new CompileTask(isolate_), v8::Platform::kShortRunningTask);
   }
 }
 
-
 void OptimizingCompileDispatcher::Unblock() {
   while (blocked_jobs_ > 0) {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new CompileTask(isolate_), v8::Platform::kShortRunningTask);
     blocked_jobs_--;
   }
 }
 
-
 }  // namespace internal
 }  // namespace v8