Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(648)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/optimizing-compiler-thread.cc

Issue 966653002: Remove support for thread-based recompilation (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« src/isolate.cc ('K') | « src/optimizing-compiler-thread.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/optimizing-compiler-thread.cc
diff --git a/src/optimizing-compiler-thread.cc b/src/optimizing-compiler-thread.cc
index eda4f5ca9d9cb868a6c5df4cbc4b2675ff31f662..59d200e48471b5b9db3ee3bacd8025730d81067a 100644
--- a/src/optimizing-compiler-thread.cc
+++ b/src/optimizing-compiler-thread.cc
@@ -10,7 +10,6 @@
#include "src/full-codegen.h"
#include "src/hydrogen.h"
#include "src/isolate.h"
-#include "src/v8threads.h"
namespace v8 {
namespace internal {
@@ -101,64 +100,6 @@ OptimizingCompilerThread::~OptimizingCompilerThread() {
}
-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 (job_based_recompilation_) {
- return;
- }
-
- base::ElapsedTimer total_timer;
- if (tracing_enabled_) total_timer.Start();
-
- while (true) {
- input_queue_semaphore_.Wait();
- TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_);
-
- if (recompilation_delay_ != 0) {
- base::OS::Sleep(recompilation_delay_);
- }
-
- switch (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_))) {
- case CONTINUE:
- break;
- case STOP:
- 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 (tracing_enabled_) compiling_timer.Start();
-
- CompileNext(NextInput());
-
- if (tracing_enabled_) {
- time_spent_compiling_ += compiling_timer.Elapsed();
- }
- }
-}
-
-
OptimizedCompileJob* OptimizingCompilerThread::NextInput(
bool check_if_flushing) {
base::LockGuard<base::Mutex> access_input_queue_(&input_queue_mutex_);
@@ -168,7 +109,7 @@ OptimizedCompileJob* OptimizingCompilerThread::NextInput(
input_queue_shift_ = InputQueueIndex(1);
input_queue_length_--;
if (check_if_flushing) {
- if (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_)) != CONTINUE) {
+ if (static_cast<ModeFlag>(base::Acquire_Load(&mode_)) == FLUSH) {
if (!job->info()->is_osr()) {
AllowHandleDereference allow_handle_dereference;
DisposeOptimizedCompileJob(job, true);
@@ -191,31 +132,18 @@ void OptimizingCompilerThread::CompileNext(OptimizedCompileJob* job) {
// 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 (job_based_recompilation_) output_queue_mutex_.Lock();
- output_queue_.Enqueue(job);
- if (job_based_recompilation_) output_queue_mutex_.Unlock();
+ base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
+ output_queue_.push(job);
isolate_->stack_guard()->RequestInstallCode();
}
-void OptimizingCompilerThread::FlushInputQueue(bool restore_function_code) {
- OptimizedCompileJob* job;
- while ((job = NextInput())) {
- DCHECK(!job_based_recompilation_);
- // 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);
- }
- }
-}
-
-
void OptimizingCompilerThread::FlushOutputQueue(bool restore_function_code) {
- OptimizedCompileJob* job;
- while (output_queue_.Dequeue(&job)) {
+ base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
+ while (!output_queue_.empty()) {
+ OptimizedCompileJob* job = output_queue_.front();
+ output_queue_.pop();
+
// OSR jobs are dealt with separately.
if (!job->info()->is_osr()) {
DisposeOptimizedCompileJob(job, restore_function_code);
@@ -235,36 +163,28 @@ void OptimizingCompilerThread::FlushOsrBuffer(bool restore_function_code) {
void OptimizingCompilerThread::Flush() {
- DCHECK(!IsOptimizerThread());
- base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(FLUSH));
+ base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
if (FLAG_block_concurrent_recompilation) Unblock();
- if (!job_based_recompilation_) {
- input_queue_semaphore_.Signal();
- stop_semaphore_.Wait();
- } else {
+ {
base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_);
- base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE));
+ base::Release_Store(&mode_, static_cast<base::AtomicWord>(COMPILE));
}
FlushOutputQueue(true);
if (FLAG_concurrent_osr) FlushOsrBuffer(true);
- if (tracing_enabled_) {
+ if (FLAG_trace_concurrent_recompilation) {
PrintF(" ** Flushed concurrent recompilation queues.\n");
}
}
void OptimizingCompilerThread::Stop() {
- DCHECK(!IsOptimizerThread());
- base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(STOP));
+ base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
if (FLAG_block_concurrent_recompilation) Unblock();
- if (!job_based_recompilation_) {
- input_queue_semaphore_.Signal();
- stop_semaphore_.Wait();
- } else {
+ {
base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_);
- base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE));
+ base::Release_Store(&mode_, static_cast<base::AtomicWord>(COMPILE));
}
if (recompilation_delay_ != 0) {
@@ -273,32 +193,25 @@ void OptimizingCompilerThread::Stop() {
while (input_queue_length_ > 0) CompileNext(NextInput());
InstallOptimizedFunctions();
} else {
- FlushInputQueue(false);
FlushOutputQueue(false);
}
if (FLAG_concurrent_osr) FlushOsrBuffer(false);
- if (tracing_enabled_) {
- double percentage = time_spent_compiling_.PercentOf(time_spent_total_);
- if (job_based_recompilation_) percentage = 100.0;
- PrintF(" ** Compiler thread did %.2f%% useful work\n", percentage);
- }
-
- if ((FLAG_trace_osr || tracing_enabled_) && 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_);
}
-
- Join();
}
void OptimizingCompilerThread::InstallOptimizedFunctions() {
- DCHECK(!IsOptimizerThread());
HandleScope handle_scope(isolate_);
- OptimizedCompileJob* job;
- while (output_queue_.Dequeue(&job)) {
+ base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
+ while (!output_queue_.empty()) {
+ OptimizedCompileJob* job = output_queue_.front();
+ output_queue_.pop();
CompilationInfo* info = job->info();
Handle<JSFunction> function(*info->closure());
if (info->is_osr()) {
@@ -315,7 +228,7 @@ void OptimizingCompilerThread::InstallOptimizedFunctions() {
BackEdgeTable::RemoveStackCheck(code, offset);
} else {
if (function->IsOptimized()) {
- if (tracing_enabled_) {
+ if (FLAG_trace_concurrent_recompilation) {
PrintF(" ** Aborting compilation for ");
function->ShortPrint();
PrintF(" as it has already been optimized.\n");
@@ -333,7 +246,6 @@ void OptimizingCompilerThread::InstallOptimizedFunctions() {
void OptimizingCompilerThread::QueueForOptimization(OptimizedCompileJob* job) {
DCHECK(IsQueueAvailable());
- DCHECK(!IsOptimizerThread());
CompilationInfo* info = job->info();
if (info->is_osr()) {
osr_attempts_++;
@@ -354,24 +266,17 @@ void OptimizingCompilerThread::QueueForOptimization(OptimizedCompileJob* job) {
}
if (FLAG_block_concurrent_recompilation) {
blocked_jobs_++;
- } else if (job_based_recompilation_) {
+ } else {
V8::GetCurrentPlatform()->CallOnBackgroundThread(
new CompileTask(isolate_), v8::Platform::kShortRunningTask);
- } else {
- input_queue_semaphore_.Signal();
}
}
void OptimizingCompilerThread::Unblock() {
- DCHECK(!IsOptimizerThread());
while (blocked_jobs_ > 0) {
- if (job_based_recompilation_) {
- V8::GetCurrentPlatform()->CallOnBackgroundThread(
- new CompileTask(isolate_), v8::Platform::kShortRunningTask);
- } else {
- input_queue_semaphore_.Signal();
- }
+ V8::GetCurrentPlatform()->CallOnBackgroundThread(
+ new CompileTask(isolate_), v8::Platform::kShortRunningTask);
blocked_jobs_--;
}
}
@@ -379,7 +284,6 @@ void OptimizingCompilerThread::Unblock() {
OptimizedCompileJob* OptimizingCompilerThread::FindReadyOSRCandidate(
Handle<JSFunction> function, BailoutId osr_ast_id) {
- DCHECK(!IsOptimizerThread());
for (int i = 0; i < osr_buffer_capacity_; i++) {
OptimizedCompileJob* current = osr_buffer_[i];
if (current != NULL &&
@@ -396,7 +300,6 @@ OptimizedCompileJob* OptimizingCompilerThread::FindReadyOSRCandidate(
bool OptimizingCompilerThread::IsQueuedForOSR(Handle<JSFunction> function,
BailoutId osr_ast_id) {
- DCHECK(!IsOptimizerThread());
for (int i = 0; i < osr_buffer_capacity_; i++) {
OptimizedCompileJob* current = osr_buffer_[i];
if (current != NULL &&
@@ -409,7 +312,6 @@ bool OptimizingCompilerThread::IsQueuedForOSR(Handle<JSFunction> function,
bool OptimizingCompilerThread::IsQueuedForOSR(JSFunction* function) {
- DCHECK(!IsOptimizerThread());
for (int i = 0; i < osr_buffer_capacity_; i++) {
OptimizedCompileJob* current = osr_buffer_[i];
if (current != NULL && *current->info()->closure() == function) {
@@ -421,7 +323,6 @@ bool OptimizingCompilerThread::IsQueuedForOSR(JSFunction* function) {
void OptimizingCompilerThread::AddToOsrBuffer(OptimizedCompileJob* job) {
- DCHECK(!IsOptimizerThread());
// Find the next slot that is empty or has a stale job.
OptimizedCompileJob* stale = NULL;
while (true) {
@@ -446,18 +347,4 @@ void OptimizingCompilerThread::AddToOsrBuffer(OptimizedCompileJob* job) {
}
-#ifdef DEBUG
-bool OptimizingCompilerThread::IsOptimizerThread(Isolate* isolate) {
- return isolate->concurrent_recompilation_enabled() &&
- isolate->optimizing_compiler_thread()->IsOptimizerThread();
-}
-
-
-bool OptimizingCompilerThread::IsOptimizerThread() {
- base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_);
- return ThreadId::Current().ToInteger() == thread_id_;
-}
-#endif
-
-
} } // namespace v8::internal
« src/isolate.cc ('K') | « src/optimizing-compiler-thread.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698