Store local copies of flags needed on the background thread

src/optimizing-compiler-thread.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-compiler-thread.h"
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/full-codegen.h"
@@ skipping 64 matching lines @@
 void OptimizingCompilerThread::Run() {
 #ifdef DEBUG
   { base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_);
     thread_id_ = ThreadId::Current().ToInteger();
   }
 #endif
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
 
-  if (FLAG_job_based_recompilation) {
+  if (job_based_recompilation_) {
     return;
   }
 
   base::ElapsedTimer total_timer;
-  if (FLAG_trace_concurrent_recompilation) total_timer.Start();
+  if (tracing_enabled_) total_timer.Start();
 
   while (true) {
     input_queue_semaphore_.Wait();
     TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_);
 
     if (FLAG_concurrent_recompilation_delay != 0) {
       base::OS::Sleep(FLAG_concurrent_recompilation_delay);
     }
 
     switch (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_))) {
       case CONTINUE:
         break;
       case STOP:
-        if (FLAG_trace_concurrent_recompilation) {
+        if (tracing_enabled_) {
           time_spent_total_ = total_timer.Elapsed();
         }
         stop_semaphore_.Signal();
         return;
       case FLUSH:
         // The main thread is blocked, waiting for the stop semaphore.
         { AllowHandleDereference allow_handle_dereference;
           FlushInputQueue(true);
         }
         base::Release_Store(&stop_thread_,
                             static_cast<base::AtomicWord>(CONTINUE));
         stop_semaphore_.Signal();
         // Return to start of consumer loop.
         continue;
     }
 
     base::ElapsedTimer compiling_timer;
-    if (FLAG_trace_concurrent_recompilation) compiling_timer.Start();
+    if (tracing_enabled_) compiling_timer.Start();
 
     CompileNext();
 
-    if (FLAG_trace_concurrent_recompilation) {
+    if (tracing_enabled_) {
       time_spent_compiling_ += compiling_timer.Elapsed();
     }
   }
 }
 
 
 OptimizedCompileJob* OptimizingCompilerThread::NextInput() {
   base::LockGuard<base::Mutex> access_input_queue_(&input_queue_mutex_);
-  DCHECK(!FLAG_job_based_recompilation);
+  DCHECK(!job_based_recompilation_);
   if (input_queue_length_ == 0) return NULL;
   OptimizedCompileJob* job = input_queue_[InputQueueIndex(0)];
   DCHECK_NE(NULL, job);
   input_queue_shift_ = InputQueueIndex(1);
   input_queue_length_--;
   return job;
 }
 
 
 void OptimizingCompilerThread::CompileNext() {
@@ skipping 28 matching lines @@
     } else {
       Handle<JSFunction> function = info->closure();
       function->ReplaceCode(function->shared()->code());
     }
   }
   delete info;
 }
 
 
 void OptimizingCompilerThread::FlushInputQueue(bool restore_function_code) {
-  DCHECK(!FLAG_job_based_recompilation);
+  DCHECK(!job_based_recompilation_);
   OptimizedCompileJob* 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();
     // OSR jobs are dealt with separately.
     if (!job->info()->is_osr()) {
       DisposeOptimizedCompileJob(job, restore_function_code);
     }
   }
@@ skipping 18 matching lines @@
       osr_buffer_[i] = NULL;
     }
   }
 }
 
 
 void OptimizingCompilerThread::Flush() {
   DCHECK(!IsOptimizerThread());
   base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(FLUSH));
   if (FLAG_block_concurrent_recompilation) Unblock();
-  if (!FLAG_job_based_recompilation) {
+  if (!job_based_recompilation_) {
     input_queue_semaphore_.Signal();
     stop_semaphore_.Wait();
   }
   FlushOutputQueue(true);
   if (FLAG_concurrent_osr) FlushOsrBuffer(true);
-  if (FLAG_trace_concurrent_recompilation) {
+  if (tracing_enabled_) {
     PrintF("  ** Flushed concurrent recompilation queues.\n");
   }
 }
 
 
 void OptimizingCompilerThread::Stop() {
   DCHECK(!IsOptimizerThread());
   base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(STOP));
   if (FLAG_block_concurrent_recompilation) Unblock();
-  if (!FLAG_job_based_recompilation) {
+  if (!job_based_recompilation_) {
     input_queue_semaphore_.Signal();
     stop_semaphore_.Wait();
   }
 
-  if (FLAG_job_based_recompilation) {
+  if (job_based_recompilation_) {
     while (true) {
       {
         base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_);
         if (!input_queue_length_) break;
       }
       input_queue_semaphore_.Wait();
     }
   } else if (FLAG_concurrent_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();
     InstallOptimizedFunctions();
   } else {
     FlushInputQueue(false);
     FlushOutputQueue(false);
   }
 
   if (FLAG_concurrent_osr) FlushOsrBuffer(false);
 
-  if (FLAG_trace_concurrent_recompilation) {
+  if (tracing_enabled_) {
     double percentage = time_spent_compiling_.PercentOf(time_spent_total_);
     PrintF("  ** Compiler thread did %.2f%% useful work\n", percentage);
   }
 
-  if ((FLAG_trace_osr || FLAG_trace_concurrent_recompilation) &&
-      FLAG_concurrent_osr) {
+  if ((FLAG_trace_osr || tracing_enabled_) && FLAG_concurrent_osr) {
     PrintF("[COSR hit rate %d / %d]\n", osr_hits_, osr_attempts_);
   }
 
   Join();
 }
 
 
 void OptimizingCompilerThread::InstallOptimizedFunctions() {
   DCHECK(!IsOptimizerThread());
   HandleScope handle_scope(isolate_);
 
   OptimizedCompileJob* job;
   while (output_queue_.Dequeue(&job)) {
     CompilationInfo* info = job->info();
     Handle<JSFunction> function(*info->closure());
     if (info->is_osr()) {
       if (FLAG_trace_osr) {
         PrintF("[COSR - ");
         function->ShortPrint();
         PrintF(" is ready for install and entry at AST id %d]\n",
                info->osr_ast_id().ToInt());
       }
       job->WaitForInstall();
       // Remove stack check that guards OSR entry on original code.
       Handle<Code> code = info->unoptimized_code();
       uint32_t offset = code->TranslateAstIdToPcOffset(info->osr_ast_id());
       BackEdgeTable::RemoveStackCheck(code, offset);
     } else {
       if (function->IsOptimized()) {
-        if (FLAG_trace_concurrent_recompilation) {
+        if (tracing_enabled_) {
           PrintF("  ** Aborting compilation for ");
           function->ShortPrint();
           PrintF(" as it has already been optimized.\n");
         }
         DisposeOptimizedCompileJob(job, false);
       } else {
         Handle<Code> code = Compiler::GetConcurrentlyOptimizedCode(job);
         function->ReplaceCode(
             code.is_null() ? function->shared()->code() : *code);
       }
@@ skipping 16 matching lines @@
     input_queue_shift_ = InputQueueIndex(input_queue_capacity_ - 1);
     input_queue_[InputQueueIndex(0)] = job;
     input_queue_length_++;
   } else {
     // Add job to the back of the input queue.
     base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_);
     DCHECK_LT(input_queue_length_, input_queue_capacity_);
     input_queue_[InputQueueIndex(input_queue_length_)] = job;
     input_queue_length_++;
   }
-  if (FLAG_job_based_recompilation) {
+  if (job_based_recompilation_) {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new CompileTask(isolate_, job), v8::Platform::kShortRunningTask);
   } else if (FLAG_block_concurrent_recompilation) {
     blocked_jobs_++;
   } else {
     input_queue_semaphore_.Signal();
   }
 }
 
 
 void OptimizingCompilerThread::Unblock() {
   DCHECK(!IsOptimizerThread());
-  if (FLAG_job_based_recompilation) {
+  if (job_based_recompilation_) {
     return;
   }
   while (blocked_jobs_ > 0) {
     input_queue_semaphore_.Signal();
     blocked_jobs_--;
   }
 }
 
 
 OptimizedCompileJob* OptimizingCompilerThread::FindReadyOSRCandidate(
@@ skipping 73 matching lines @@
 
 
 bool OptimizingCompilerThread::IsOptimizerThread() {
   base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_);
   return ThreadId::Current().ToInteger() == thread_id_;
 }
 #endif
 
 
 } }  // namespace v8::internal