// 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/optimizing-compiler-thread.h"
#include "src/v8.h"
#include "src/full-codegen.h"
#include "src/hydrogen.h"
#include "src/isolate.h"
+#include "src/v8threads.h"
namespace v8 {
namespace internal {
} // namespace
-class OptimizingCompileDispatcher::CompileTask : public v8::Task {
+class OptimizingCompilerThread::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_;
+ OptimizingCompilerThread* thread = isolate_->optimizing_compiler_thread();
+ base::LockGuard<base::Mutex> lock_guard(&thread->ref_count_mutex_);
+ ++thread->ref_count_;
}
virtual ~CompileTask() {}
DisallowHandleAllocation no_handles;
DisallowHandleDereference no_deref;
- OptimizingCompileDispatcher* dispatcher =
- isolate_->optimizing_compile_dispatcher();
+ OptimizingCompilerThread* thread = isolate_->optimizing_compiler_thread();
{
TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_);
- if (dispatcher->recompilation_delay_ != 0) {
- base::OS::Sleep(dispatcher->recompilation_delay_);
+ if (thread->recompilation_delay_ != 0) {
+ base::OS::Sleep(thread->recompilation_delay_);
}
- dispatcher->CompileNext(dispatcher->NextInput(true));
+ thread->CompileNext(thread->NextInput(true));
}
{
- base::LockGuard<base::Mutex> lock_guard(&dispatcher->ref_count_mutex_);
- if (--dispatcher->ref_count_ == 0) {
- dispatcher->ref_count_zero_.NotifyOne();
+ base::LockGuard<base::Mutex> lock_guard(&thread->ref_count_mutex_);
+ if (--thread->ref_count_ == 0) {
+ thread->ref_count_zero_.NotifyOne();
}
}
}
};
-OptimizingCompileDispatcher::~OptimizingCompileDispatcher() {
+OptimizingCompilerThread::~OptimizingCompilerThread() {
#ifdef DEBUG
{
base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_);
}
-OptimizedCompileJob* OptimizingCompileDispatcher::NextInput(
+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_);
if (input_queue_length_ == 0) return NULL;
input_queue_shift_ = InputQueueIndex(1);
input_queue_length_--;
if (check_if_flushing) {
- if (static_cast<ModeFlag>(base::Acquire_Load(&mode_)) == FLUSH) {
+ if (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_)) != CONTINUE) {
if (!job->info()->is_osr()) {
AllowHandleDereference allow_handle_dereference;
DisposeOptimizedCompileJob(job, true);
}
-void OptimizingCompileDispatcher::CompileNext(OptimizedCompileJob* job) {
+void OptimizingCompilerThread::CompileNext(OptimizedCompileJob* job) {
if (!job) return;
// The function may have already been optimized by OSR. Simply continue.
OptimizedCompileJob::Status status = job->OptimizeGraph();
- USE(status); // Prevent an unused-variable error in release mode.
+ USE(status); // Prevent an unused-variable error in release mode.
DCHECK(status != OptimizedCompileJob::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.
- base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
- output_queue_.push(job);
+ if (job_based_recompilation_) output_queue_mutex_.Lock();
+ output_queue_.Enqueue(job);
+ if (job_based_recompilation_) output_queue_mutex_.Unlock();
isolate_->stack_guard()->RequestInstallCode();
}
-void OptimizingCompileDispatcher::FlushOutputQueue(bool restore_function_code) {
- base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
- while (!output_queue_.empty()) {
- OptimizedCompileJob* job = output_queue_.front();
- output_queue_.pop();
+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)) {
// OSR jobs are dealt with separately.
if (!job->info()->is_osr()) {
DisposeOptimizedCompileJob(job, restore_function_code);
}
-void OptimizingCompileDispatcher::FlushOsrBuffer(bool restore_function_code) {
+void OptimizingCompilerThread::FlushOsrBuffer(bool restore_function_code) {
for (int i = 0; i < osr_buffer_capacity_; i++) {
if (osr_buffer_[i] != NULL) {
DisposeOptimizedCompileJob(osr_buffer_[i], restore_function_code);
}
-void OptimizingCompileDispatcher::Flush() {
- base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
+void OptimizingCompilerThread::Flush() {
+ DCHECK(!IsOptimizerThread());
+ base::Release_Store(&stop_thread_, 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(&mode_, static_cast<base::AtomicWord>(COMPILE));
+ base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE));
}
FlushOutputQueue(true);
if (FLAG_concurrent_osr) FlushOsrBuffer(true);
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
PrintF(" ** Flushed concurrent recompilation queues.\n");
}
}
-void OptimizingCompileDispatcher::Stop() {
- base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
+void OptimizingCompilerThread::Stop() {
+ DCHECK(!IsOptimizerThread());
+ base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(STOP));
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(&mode_, static_cast<base::AtomicWord>(COMPILE));
+ base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE));
}
if (recompilation_delay_ != 0) {
while (input_queue_length_ > 0) CompileNext(NextInput());
InstallOptimizedFunctions();
} else {
+ FlushInputQueue(false);
FlushOutputQueue(false);
}
if (FLAG_concurrent_osr) FlushOsrBuffer(false);
- if ((FLAG_trace_osr || FLAG_trace_concurrent_recompilation) &&
- FLAG_concurrent_osr) {
+ 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) {
PrintF("[COSR hit rate %d / %d]\n", osr_hits_, osr_attempts_);
}
+
+ Join();
}
-void OptimizingCompileDispatcher::InstallOptimizedFunctions() {
+void OptimizingCompilerThread::InstallOptimizedFunctions() {
+ DCHECK(!IsOptimizerThread());
HandleScope handle_scope(isolate_);
- base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
- while (!output_queue_.empty()) {
- OptimizedCompileJob* job = output_queue_.front();
- output_queue_.pop();
+ OptimizedCompileJob* job;
+ while (output_queue_.Dequeue(&job)) {
CompilationInfo* info = job->info();
Handle<JSFunction> function(*info->closure());
if (info->is_osr()) {
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);
+ function->ReplaceCode(
+ code.is_null() ? function->shared()->code() : *code);
}
}
}
}
-void OptimizingCompileDispatcher::QueueForOptimization(
- OptimizedCompileJob* job) {
+void OptimizingCompilerThread::QueueForOptimization(OptimizedCompileJob* job) {
DCHECK(IsQueueAvailable());
+ DCHECK(!IsOptimizerThread());
CompilationInfo* info = job->info();
if (info->is_osr()) {
osr_attempts_++;
}
if (FLAG_block_concurrent_recompilation) {
blocked_jobs_++;
- } else {
+ } else if (job_based_recompilation_) {
V8::GetCurrentPlatform()->CallOnBackgroundThread(
new CompileTask(isolate_), v8::Platform::kShortRunningTask);
+ } else {
+ input_queue_semaphore_.Signal();
}
}
-void OptimizingCompileDispatcher::Unblock() {
+void OptimizingCompilerThread::Unblock() {
+ DCHECK(!IsOptimizerThread());
while (blocked_jobs_ > 0) {
- V8::GetCurrentPlatform()->CallOnBackgroundThread(
- new CompileTask(isolate_), v8::Platform::kShortRunningTask);
+ if (job_based_recompilation_) {
+ V8::GetCurrentPlatform()->CallOnBackgroundThread(
+ new CompileTask(isolate_), v8::Platform::kShortRunningTask);
+ } else {
+ input_queue_semaphore_.Signal();
+ }
blocked_jobs_--;
}
}
-OptimizedCompileJob* OptimizingCompileDispatcher::FindReadyOSRCandidate(
+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 && current->IsWaitingForInstall() &&
+ if (current != NULL &&
+ current->IsWaitingForInstall() &&
current->info()->HasSameOsrEntry(function, osr_ast_id)) {
osr_hits_++;
osr_buffer_[i] = NULL;
}
-bool OptimizingCompileDispatcher::IsQueuedForOSR(Handle<JSFunction> function,
- BailoutId osr_ast_id) {
+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 &&
}
-bool OptimizingCompileDispatcher::IsQueuedForOSR(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) {
}
-void OptimizingCompileDispatcher::AddToOsrBuffer(OptimizedCompileJob* job) {
+void OptimizingCompilerThread::AddToOsrBuffer(OptimizedCompileJob* job) {
+ DCHECK(!IsOptimizerThread());
// Find the next slot that is empty or has a stale job.
OptimizedCompileJob* stale = NULL;
while (true) {
osr_buffer_[osr_buffer_cursor_] = job;
osr_buffer_cursor_ = (osr_buffer_cursor_ + 1) % osr_buffer_capacity_;
}
+
+
+#ifdef DEBUG
+bool OptimizingCompilerThread::IsOptimizerThread(Isolate* isolate) {
+ return isolate->concurrent_recompilation_enabled() &&
+ isolate->optimizing_compiler_thread()->IsOptimizerThread();
}
-} // namespace v8::internal
+
+
+bool OptimizingCompilerThread::IsOptimizerThread() {
+ base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_);
+ return ThreadId::Current().ToInteger() == thread_id_;
+}
+#endif
+
+
+} } // namespace v8::internal
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_OPTIMIZING_COMPILE_DISPATCHER_H_
-#define V8_OPTIMIZING_COMPILE_DISPATCHER_H_
-
-#include <queue>
+#ifndef V8_OPTIMIZING_COMPILER_THREAD_H_
+#define V8_OPTIMIZING_COMPILER_THREAD_H_
#include "src/base/atomicops.h"
#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"
#include "src/base/platform/platform.h"
+#include "src/base/platform/time.h"
#include "src/flags.h"
#include "src/list.h"
+#include "src/unbound-queue-inl.h"
namespace v8 {
namespace internal {
class OptimizedCompileJob;
class SharedFunctionInfo;
-class OptimizingCompileDispatcher {
+class OptimizingCompilerThread : public base::Thread {
public:
- explicit OptimizingCompileDispatcher(Isolate* isolate)
- : isolate_(isolate),
+ explicit OptimizingCompilerThread(Isolate* isolate)
+ : Thread(Options("OptimizingCompilerThread")),
+#ifdef DEBUG
+ thread_id_(0),
+#endif
+ isolate_(isolate),
+ stop_semaphore_(0),
+ input_queue_semaphore_(0),
input_queue_capacity_(FLAG_concurrent_recompilation_queue_length),
input_queue_length_(0),
input_queue_shift_(0),
osr_attempts_(0),
blocked_jobs_(0),
ref_count_(0),
+ tracing_enabled_(FLAG_trace_concurrent_recompilation),
+ job_based_recompilation_(FLAG_job_based_recompilation),
recompilation_delay_(FLAG_concurrent_recompilation_delay) {
- base::NoBarrier_Store(&mode_, static_cast<base::AtomicWord>(COMPILE));
+ base::NoBarrier_Store(&stop_thread_,
+ static_cast<base::AtomicWord>(CONTINUE));
input_queue_ = NewArray<OptimizedCompileJob*>(input_queue_capacity_);
if (FLAG_concurrent_osr) {
// Allocate and mark OSR buffer slots as empty.
}
}
- ~OptimizingCompileDispatcher();
+ ~OptimizingCompilerThread();
void Run();
void Stop();
return (FLAG_concurrent_recompilation && max_available > 1);
}
+#ifdef DEBUG
+ static bool IsOptimizerThread(Isolate* isolate);
+ bool IsOptimizerThread();
+#endif
+
private:
class CompileTask;
- enum ModeFlag { COMPILE, FLUSH };
+ enum StopFlag { CONTINUE, STOP, FLUSH };
+ void FlushInputQueue(bool restore_function_code);
void FlushOutputQueue(bool restore_function_code);
void FlushOsrBuffer(bool restore_function_code);
void CompileNext(OptimizedCompileJob* job);
return result;
}
+#ifdef DEBUG
+ int thread_id_;
+ base::Mutex thread_id_mutex_;
+#endif
+
Isolate* isolate_;
+ base::Semaphore stop_semaphore_;
+ base::Semaphore input_queue_semaphore_;
// Circular queue of incoming recompilation tasks (including OSR).
OptimizedCompileJob** input_queue_;
base::Mutex input_queue_mutex_;
// Queue of recompilation tasks ready to be installed (excluding OSR).
- std::queue<OptimizedCompileJob*> output_queue_;
+ UnboundQueue<OptimizedCompileJob*> output_queue_;
// Used for job based recompilation which has multiple producers on
// different threads.
base::Mutex output_queue_mutex_;
int osr_buffer_capacity_;
int osr_buffer_cursor_;
- volatile base::AtomicWord mode_;
+ volatile base::AtomicWord stop_thread_;
+ base::TimeDelta time_spent_compiling_;
+ base::TimeDelta time_spent_total_;
int osr_hits_;
int osr_attempts_;
base::Mutex ref_count_mutex_;
base::ConditionVariable ref_count_zero_;
- // Copy of FLAG_concurrent_recompilation_delay that will be used from the
- // background thread.
+ // Copies of FLAG_trace_concurrent_recompilation,
+ // FLAG_concurrent_recompilation_delay and
+ // FLAG_job_based_recompilation that will be used from the background thread.
//
// Since flags might get modified while the background thread is running, it
// is not safe to access them directly.
+ bool tracing_enabled_;
+ bool job_based_recompilation_;
int recompilation_delay_;
};
-}
-} // namespace v8::internal
-#endif // V8_OPTIMIZING_COMPILE_DISPATCHER_H_
+} } // namespace v8::internal
+
+#endif // V8_OPTIMIZING_COMPILER_THREAD_H_
projects / platform / upstream / v8.git / commitdiff