/deps/v8/src/optimizing-compiler-thread.cc - Diff - CSE2410 Fall 2014 Bounce - CS Projects

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

     #include "v8.h"
     #include "full-codegen.h"
     #include "hydrogen.h"
     #include "isolate.h"
     #include "v8threads.h"
-...
     namespace v8 {
     namespace internal {
     OptimizingCompilerThread::~OptimizingCompilerThread() {
       ASSERT_EQ(0, input_queue_length_);
       DeleteArray(input_queue_);
       if (FLAG_concurrent_osr) {
     #ifdef DEBUG
         for (int i = 0; i < osr_buffer_capacity_; i++) {
           CHECK_EQ(NULL, osr_buffer_[i]);
+        }
     #endif
         DeleteArray(osr_buffer_);
+      }
+    }
     void OptimizingCompilerThread::Run() {
     #ifdef DEBUG
-...
             { AllowHandleDereference allow_handle_dereference;
               FlushInputQueue(true);
+            }
             Release_Store(&queue_length_, static_cast<AtomicWord>(0));
             Release_Store(&stop_thread_, static_cast<AtomicWord>(CONTINUE));
             stop_semaphore_.Signal();
             // Return to start of consumer loop.
-...
+    }
     RecompileJob* OptimizingCompilerThread::NextInput() {
       LockGuard<Mutex> access_input_queue_(&input_queue_mutex_);
       if (input_queue_length_ == 0) return NULL;
       RecompileJob* job = input_queue_[InputQueueIndex(0)];
       ASSERT_NE(NULL, job);
       input_queue_shift_ = InputQueueIndex(1);
       input_queue_length_--;
       return job;
+    }
     void OptimizingCompilerThread::CompileNext() {
       OptimizingCompiler* optimizing_compiler = NULL;
       bool result = input_queue_.Dequeue(&optimizing_compiler);
       USE(result);
       ASSERT(result);
       Barrier_AtomicIncrement(&queue_length_, static_cast<Atomic32>(-1));
       RecompileJob* job = NextInput();
       ASSERT_NE(NULL, job);
       // The function may have already been optimized by OSR.  Simply continue.
       OptimizingCompiler::Status status = optimizing_compiler->OptimizeGraph();
       RecompileJob::Status status = job->OptimizeGraph();
       USE(status);   // Prevent an unused-variable error in release mode.
       ASSERT(status != OptimizingCompiler::FAILED);
       ASSERT(status != RecompileJob::FAILED);
       // 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.
       if (!optimizing_compiler->info()->osr_ast_id().IsNone()) {
         ASSERT(FLAG_concurrent_osr);
         LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
         osr_candidates_.RemoveElement(optimizing_compiler);
         ready_for_osr_.Add(optimizing_compiler);
       } else {
         output_queue_.Enqueue(optimizing_compiler);
         isolate_->stack_guard()->RequestInstallCode();
       output_queue_.Enqueue(job);
       isolate_->stack_guard()->RequestInstallCode();
+    }
     static void DisposeRecompileJob(RecompileJob* job,
                                     bool restore_function_code) {
       // The recompile job is allocated in the CompilationInfo's zone.
       CompilationInfo* info = job->info();
       if (restore_function_code) {
         if (info->is_osr()) {
           if (!job->IsWaitingForInstall()) BackEdgeTable::RemoveStackCheck(info);
         } else {
           Handle<JSFunction> function = info->closure();
           function->ReplaceCode(function->shared()->code());
+        }
+      }
       delete info;
+    }
     void OptimizingCompilerThread::FlushInputQueue(bool restore_function_code) {
       OptimizingCompiler* optimizing_compiler;
       // The optimizing compiler is allocated in the CompilationInfo's zone.
       while (input_queue_.Dequeue(&optimizing_compiler)) {
       RecompileJob* job;
       while ((job = NextInput())) {
         // This should not block, since we have one signal on the input queue
         // semaphore corresponding to each element in the input queue.
         input_queue_semaphore_.Wait();
         CompilationInfo* info = optimizing_compiler->info();
         if (restore_function_code) {
           Handle<JSFunction> function = info->closure();
           function->ReplaceCode(function->shared()->code());
         // OSR jobs are dealt with separately.
         if (!job->info()->is_osr()) {
           DisposeRecompileJob(job, restore_function_code);
+        }
         delete info;
+      }
+    }
     void OptimizingCompilerThread::FlushOutputQueue(bool restore_function_code) {
       OptimizingCompiler* optimizing_compiler;
       // The optimizing compiler is allocated in the CompilationInfo's zone.
       while (output_queue_.Dequeue(&optimizing_compiler)) {
         CompilationInfo* info = optimizing_compiler->info();
         if (restore_function_code) {
           Handle<JSFunction> function = info->closure();
           function->ReplaceCode(function->shared()->code());
       RecompileJob* job;
       while (output_queue_.Dequeue(&job)) {
         // OSR jobs are dealt with separately.
         if (!job->info()->is_osr()) {
           DisposeRecompileJob(job, restore_function_code);
+        }
         delete info;
+      }
+    }
       osr_candidates_.Clear();
       RemoveStaleOSRCandidates(0);
     void OptimizingCompilerThread::FlushOsrBuffer(bool restore_function_code) {
       for (int i = 0; i < osr_buffer_capacity_; i++) {
         if (osr_buffer_[i] != NULL) {
           DisposeRecompileJob(osr_buffer_[i], restore_function_code);
           osr_buffer_[i] = NULL;
+        }
+      }
+    }
     void OptimizingCompilerThread::Flush() {
       ASSERT(!IsOptimizerThread());
       Release_Store(&stop_thread_, static_cast<AtomicWord>(FLUSH));
       if (FLAG_block_concurrent_recompilation) Unblock();
       input_queue_semaphore_.Signal();
       stop_semaphore_.Wait();
       FlushOutputQueue(true);
       if (FLAG_concurrent_osr) FlushOsrBuffer(true);
       if (FLAG_trace_concurrent_recompilation) {
         PrintF("  ** Flushed concurrent recompilation queues.\n");
+      }
+    }
     void OptimizingCompilerThread::Stop() {
       ASSERT(!IsOptimizerThread());
       Release_Store(&stop_thread_, static_cast<AtomicWord>(STOP));
       if (FLAG_block_concurrent_recompilation) Unblock();
       input_queue_semaphore_.Signal();
       stop_semaphore_.Wait();
       if (FLAG_concurrent_recompilation_delay != 0) {
         // Barrier when loading queue length is not necessary since the write
         // happens in CompileNext on the same thread.
         // This is used only for testing.
         while (NoBarrier_Load(&queue_length_) > 0) CompileNext();
         // 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();
         InstallOptimizedFunctions();
       } else {
         FlushInputQueue(false);
         FlushOutputQueue(false);
+      }
       if (FLAG_concurrent_osr) FlushOsrBuffer(false);
       if (FLAG_trace_concurrent_recompilation) {
         double percentage = time_spent_compiling_.PercentOf(time_spent_total_);
         PrintF("  ** Compiler thread did %.2f%% useful work\n", percentage);
+      }
       if (FLAG_trace_osr && FLAG_concurrent_osr) {
       if ((FLAG_trace_osr || FLAG_trace_concurrent_recompilation) &&
           FLAG_concurrent_osr) {
         PrintF("[COSR hit rate %d / %d]\n", osr_hits_, osr_attempts_);
+      }
-...
     void OptimizingCompilerThread::InstallOptimizedFunctions() {
       ASSERT(!IsOptimizerThread());
       HandleScope handle_scope(isolate_);
       OptimizingCompiler* compiler;
       while (true) {
         if (!output_queue_.Dequeue(&compiler)) return;
         Compiler::InstallOptimizedCode(compiler);
+      }
       // Remove the oldest OSR candidates that are ready so that we
       // only have limited number of them waiting.
       if (FLAG_concurrent_osr) RemoveStaleOSRCandidates();
       RecompileJob* job;
       while (output_queue_.Dequeue(&job)) {
         CompilationInfo* info = job->info();
         if (info->is_osr()) {
           if (FLAG_trace_osr) {
             PrintF("[COSR - ");
             info->closure()->PrintName();
             PrintF(" is ready for install and entry at AST id %d]\n",
                    info->osr_ast_id().ToInt());
+          }
           job->WaitForInstall();
           BackEdgeTable::RemoveStackCheck(info);
         } else {
           Compiler::InstallOptimizedCode(job);
+        }
+      }
+    }
     void OptimizingCompilerThread::QueueForOptimization(
         OptimizingCompiler* optimizing_compiler) {
     void OptimizingCompilerThread::QueueForOptimization(RecompileJob* job) {
       ASSERT(IsQueueAvailable());
       ASSERT(!IsOptimizerThread());
       Barrier_AtomicIncrement(&queue_length_, static_cast<Atomic32>(1));
       if (optimizing_compiler->info()->osr_ast_id().IsNone()) {
         optimizing_compiler->info()->closure()->MarkInRecompileQueue();
       } else {
         LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
         osr_candidates_.Add(optimizing_compiler);
       CompilationInfo* info = job->info();
       if (info->is_osr()) {
         if (FLAG_trace_concurrent_recompilation) {
           PrintF("  ** Queueing ");
           info->closure()->PrintName();
           PrintF(" for concurrent on-stack replacement.\n");
+        }
         osr_attempts_++;
         BackEdgeTable::AddStackCheck(info);
         AddToOsrBuffer(job);
         // Add job to the front of the input queue.
         LockGuard<Mutex> access_input_queue(&input_queue_mutex_);
         ASSERT_LT(input_queue_length_, input_queue_capacity_);
         // Move shift_ back by one.
         input_queue_shift_ = InputQueueIndex(input_queue_capacity_ - 1);
         input_queue_[InputQueueIndex(0)] = job;
         input_queue_length_++;
       } else {
         info->closure()->MarkInRecompileQueue();
         // Add job to the back of the input queue.
         LockGuard<Mutex> access_input_queue(&input_queue_mutex_);
         ASSERT_LT(input_queue_length_, input_queue_capacity_);
         input_queue_[InputQueueIndex(input_queue_length_)] = job;
         input_queue_length_++;
+      }
       if (FLAG_block_concurrent_recompilation) {
         blocked_jobs_++;
       } else {
         input_queue_semaphore_.Signal();
+      }
+    }
     void OptimizingCompilerThread::Unblock() {
       ASSERT(!IsOptimizerThread());
       while (blocked_jobs_ > 0) {
         input_queue_semaphore_.Signal();
         blocked_jobs_--;
+      }
       input_queue_.Enqueue(optimizing_compiler);
       input_queue_semaphore_.Signal();
+    }
     OptimizingCompiler* OptimizingCompilerThread::FindReadyOSRCandidate(
     RecompileJob* OptimizingCompilerThread::FindReadyOSRCandidate(
         Handle<JSFunction> function, uint32_t osr_pc_offset) {
       ASSERT(!IsOptimizerThread());
       OptimizingCompiler* result = NULL;
       { LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
         for (int i = 0; i < ready_for_osr_.length(); i++) {
           if (ready_for_osr_[i]->info()->HasSameOsrEntry(function, osr_pc_offset)) {
             osr_hits_++;
             result = ready_for_osr_.Remove(i);
             break;
+          }
       for (int i = 0; i < osr_buffer_capacity_; i++) {
         RecompileJob* current = osr_buffer_[i];
         if (current != NULL &&
             current->IsWaitingForInstall() &&
             current->info()->HasSameOsrEntry(function, osr_pc_offset)) {
           osr_hits_++;
           osr_buffer_[i] = NULL;
           return current;
+        }
+      }
       RemoveStaleOSRCandidates();
       return result;
       return NULL;
+    }
     bool OptimizingCompilerThread::IsQueuedForOSR(Handle<JSFunction> function,
                                                   uint32_t osr_pc_offset) {
       ASSERT(!IsOptimizerThread());
       LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
       for (int i = 0; i < osr_candidates_.length(); i++) {
         if (osr_candidates_[i]->info()->HasSameOsrEntry(function, osr_pc_offset)) {
           return true;
       for (int i = 0; i < osr_buffer_capacity_; i++) {
         RecompileJob* current = osr_buffer_[i];
         if (current != NULL &&
             current->info()->HasSameOsrEntry(function, osr_pc_offset)) {
           return !current->IsWaitingForInstall();
+        }
+      }
       return false;
-...
     bool OptimizingCompilerThread::IsQueuedForOSR(JSFunction* function) {
       ASSERT(!IsOptimizerThread());
       LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
       for (int i = 0; i < osr_candidates_.length(); i++) {
         if (*osr_candidates_[i]->info()->closure() == function) {
           return true;
       for (int i = 0; i < osr_buffer_capacity_; i++) {
         RecompileJob* current = osr_buffer_[i];
         if (current != NULL && *current->info()->closure() == function) {
           return !current->IsWaitingForInstall();
+        }
+      }
       return false;
+    }
     void OptimizingCompilerThread::RemoveStaleOSRCandidates(int limit) {
     void OptimizingCompilerThread::AddToOsrBuffer(RecompileJob* job) {
       ASSERT(!IsOptimizerThread());
       LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
       while (ready_for_osr_.length() > limit) {
         OptimizingCompiler* compiler = ready_for_osr_.Remove(0);
         CompilationInfo* throw_away = compiler->info();
       // Find the next slot that is empty or has a stale job.
       while (true) {
         RecompileJob* stale = osr_buffer_[osr_buffer_cursor_];
         if (stale == NULL || stale->IsWaitingForInstall()) break;
         osr_buffer_cursor_ = (osr_buffer_cursor_ + 1) % osr_buffer_capacity_;
+      }
       // Add to found slot and dispose the evicted job.
       RecompileJob* evicted = osr_buffer_[osr_buffer_cursor_];
       if (evicted != NULL) {
         ASSERT(evicted->IsWaitingForInstall());
         CompilationInfo* info = evicted->info();
         if (FLAG_trace_osr) {
           PrintF("[COSR - Discarded ");
           throw_away->closure()->PrintName();
           PrintF(", AST id %d]\n",
                  throw_away->osr_ast_id().ToInt());
           info->closure()->PrintName();
           PrintF(", AST id %d]\n", info->osr_ast_id().ToInt());
+        }
         delete throw_away;
         DisposeRecompileJob(evicted, false);
+      }
       osr_buffer_[osr_buffer_cursor_] = job;
       osr_buffer_cursor_ = (osr_buffer_cursor_ + 1) % osr_buffer_capacity_;
+    }

Also available in: Unified diff