| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 the V8 project authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "src/optimizing-compiler-thread.h" | |
| 6 | |
| 7 #include "src/v8.h" | |
| 8 | |
| 9 #include "src/base/atomicops.h" | |
| 10 #include "src/full-codegen.h" | |
| 11 #include "src/hydrogen.h" | |
| 12 #include "src/isolate.h" | |
| 13 #include "src/v8threads.h" | |
| 14 | |
| 15 namespace v8 { | |
| 16 namespace internal { | |
| 17 | |
| 18 namespace { | |
| 19 | |
| 20 void DisposeOptimizedCompileJob(OptimizedCompileJob* job, | |
| 21 bool restore_function_code) { | |
| 22 // The recompile job is allocated in the CompilationInfo's zone. | |
| 23 CompilationInfo* info = job->info(); | |
| 24 if (restore_function_code) { | |
| 25 if (info->is_osr()) { | |
| 26 if (!job->IsWaitingForInstall()) { | |
| 27 // Remove stack check that guards OSR entry on original code. | |
| 28 Handle<Code> code = info->unoptimized_code(); | |
| 29 uint32_t offset = code->TranslateAstIdToPcOffset(info->osr_ast_id()); | |
| 30 BackEdgeTable::RemoveStackCheck(code, offset); | |
| 31 } | |
| 32 } else { | |
| 33 Handle<JSFunction> function = info->closure(); | |
| 34 function->ReplaceCode(function->shared()->code()); | |
| 35 } | |
| 36 } | |
| 37 delete info; | |
| 38 } | |
| 39 | |
| 40 } // namespace | |
| 41 | |
| 42 | |
| 43 class OptimizingCompilerThread::CompileTask : public v8::Task { | |
| 44 public: | |
| 45 explicit CompileTask(Isolate* isolate) : isolate_(isolate) { | |
| 46 OptimizingCompilerThread* thread = isolate_->optimizing_compiler_thread(); | |
| 47 base::LockGuard<base::Mutex> lock_guard(&thread->ref_count_mutex_); | |
| 48 ++thread->ref_count_; | |
| 49 } | |
| 50 | |
| 51 virtual ~CompileTask() {} | |
| 52 | |
| 53 private: | |
| 54 // v8::Task overrides. | |
| 55 void Run() OVERRIDE { | |
| 56 DisallowHeapAllocation no_allocation; | |
| 57 DisallowHandleAllocation no_handles; | |
| 58 DisallowHandleDereference no_deref; | |
| 59 | |
| 60 OptimizingCompilerThread* thread = isolate_->optimizing_compiler_thread(); | |
| 61 { | |
| 62 TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_); | |
| 63 | |
| 64 if (thread->recompilation_delay_ != 0) { | |
| 65 base::OS::Sleep(thread->recompilation_delay_); | |
| 66 } | |
| 67 | |
| 68 thread->CompileNext(thread->NextInput(true)); | |
| 69 } | |
| 70 { | |
| 71 base::LockGuard<base::Mutex> lock_guard(&thread->ref_count_mutex_); | |
| 72 if (--thread->ref_count_ == 0) { | |
| 73 thread->ref_count_zero_.NotifyOne(); | |
| 74 } | |
| 75 } | |
| 76 } | |
| 77 | |
| 78 Isolate* isolate_; | |
| 79 | |
| 80 DISALLOW_COPY_AND_ASSIGN(CompileTask); | |
| 81 }; | |
| 82 | |
| 83 | |
| 84 OptimizingCompilerThread::~OptimizingCompilerThread() { | |
| 85 #ifdef DEBUG | |
| 86 { | |
| 87 base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_); | |
| 88 DCHECK_EQ(0, ref_count_); | |
| 89 } | |
| 90 #endif | |
| 91 DCHECK_EQ(0, input_queue_length_); | |
| 92 DeleteArray(input_queue_); | |
| 93 if (FLAG_concurrent_osr) { | |
| 94 #ifdef DEBUG | |
| 95 for (int i = 0; i < osr_buffer_capacity_; i++) { | |
| 96 CHECK_NULL(osr_buffer_[i]); | |
| 97 } | |
| 98 #endif | |
| 99 DeleteArray(osr_buffer_); | |
| 100 } | |
| 101 } | |
| 102 | |
| 103 | |
| 104 void OptimizingCompilerThread::Run() { | |
| 105 #ifdef DEBUG | |
| 106 { base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_); | |
| 107 thread_id_ = ThreadId::Current().ToInteger(); | |
| 108 } | |
| 109 #endif | |
| 110 DisallowHeapAllocation no_allocation; | |
| 111 DisallowHandleAllocation no_handles; | |
| 112 DisallowHandleDereference no_deref; | |
| 113 | |
| 114 if (job_based_recompilation_) { | |
| 115 return; | |
| 116 } | |
| 117 | |
| 118 base::ElapsedTimer total_timer; | |
| 119 if (tracing_enabled_) total_timer.Start(); | |
| 120 | |
| 121 while (true) { | |
| 122 input_queue_semaphore_.Wait(); | |
| 123 TimerEventScope<TimerEventRecompileConcurrent> timer(isolate_); | |
| 124 | |
| 125 if (recompilation_delay_ != 0) { | |
| 126 base::OS::Sleep(recompilation_delay_); | |
| 127 } | |
| 128 | |
| 129 switch (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_))) { | |
| 130 case CONTINUE: | |
| 131 break; | |
| 132 case STOP: | |
| 133 if (tracing_enabled_) { | |
| 134 time_spent_total_ = total_timer.Elapsed(); | |
| 135 } | |
| 136 stop_semaphore_.Signal(); | |
| 137 return; | |
| 138 case FLUSH: | |
| 139 // The main thread is blocked, waiting for the stop semaphore. | |
| 140 { AllowHandleDereference allow_handle_dereference; | |
| 141 FlushInputQueue(true); | |
| 142 } | |
| 143 base::Release_Store(&stop_thread_, | |
| 144 static_cast<base::AtomicWord>(CONTINUE)); | |
| 145 stop_semaphore_.Signal(); | |
| 146 // Return to start of consumer loop. | |
| 147 continue; | |
| 148 } | |
| 149 | |
| 150 base::ElapsedTimer compiling_timer; | |
| 151 if (tracing_enabled_) compiling_timer.Start(); | |
| 152 | |
| 153 CompileNext(NextInput()); | |
| 154 | |
| 155 if (tracing_enabled_) { | |
| 156 time_spent_compiling_ += compiling_timer.Elapsed(); | |
| 157 } | |
| 158 } | |
| 159 } | |
| 160 | |
| 161 | |
| 162 OptimizedCompileJob* OptimizingCompilerThread::NextInput( | |
| 163 bool check_if_flushing) { | |
| 164 base::LockGuard<base::Mutex> access_input_queue_(&input_queue_mutex_); | |
| 165 if (input_queue_length_ == 0) return NULL; | |
| 166 OptimizedCompileJob* job = input_queue_[InputQueueIndex(0)]; | |
| 167 DCHECK_NOT_NULL(job); | |
| 168 input_queue_shift_ = InputQueueIndex(1); | |
| 169 input_queue_length_--; | |
| 170 if (check_if_flushing) { | |
| 171 if (static_cast<StopFlag>(base::Acquire_Load(&stop_thread_)) != CONTINUE) { | |
| 172 if (!job->info()->is_osr()) { | |
| 173 AllowHandleDereference allow_handle_dereference; | |
| 174 DisposeOptimizedCompileJob(job, true); | |
| 175 } | |
| 176 return NULL; | |
| 177 } | |
| 178 } | |
| 179 return job; | |
| 180 } | |
| 181 | |
| 182 | |
| 183 void OptimizingCompilerThread::CompileNext(OptimizedCompileJob* job) { | |
| 184 if (!job) return; | |
| 185 | |
| 186 // The function may have already been optimized by OSR. Simply continue. | |
| 187 OptimizedCompileJob::Status status = job->OptimizeGraph(); | |
| 188 USE(status); // Prevent an unused-variable error in release mode. | |
| 189 DCHECK(status != OptimizedCompileJob::FAILED); | |
| 190 | |
| 191 // The function may have already been optimized by OSR. Simply continue. | |
| 192 // Use a mutex to make sure that functions marked for install | |
| 193 // are always also queued. | |
| 194 if (job_based_recompilation_) output_queue_mutex_.Lock(); | |
| 195 output_queue_.Enqueue(job); | |
| 196 if (job_based_recompilation_) output_queue_mutex_.Unlock(); | |
| 197 isolate_->stack_guard()->RequestInstallCode(); | |
| 198 } | |
| 199 | |
| 200 | |
| 201 void OptimizingCompilerThread::FlushInputQueue(bool restore_function_code) { | |
| 202 OptimizedCompileJob* job; | |
| 203 while ((job = NextInput())) { | |
| 204 DCHECK(!job_based_recompilation_); | |
| 205 // This should not block, since we have one signal on the input queue | |
| 206 // semaphore corresponding to each element in the input queue. | |
| 207 input_queue_semaphore_.Wait(); | |
| 208 // OSR jobs are dealt with separately. | |
| 209 if (!job->info()->is_osr()) { | |
| 210 DisposeOptimizedCompileJob(job, restore_function_code); | |
| 211 } | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 | |
| 216 void OptimizingCompilerThread::FlushOutputQueue(bool restore_function_code) { | |
| 217 OptimizedCompileJob* job; | |
| 218 while (output_queue_.Dequeue(&job)) { | |
| 219 // OSR jobs are dealt with separately. | |
| 220 if (!job->info()->is_osr()) { | |
| 221 DisposeOptimizedCompileJob(job, restore_function_code); | |
| 222 } | |
| 223 } | |
| 224 } | |
| 225 | |
| 226 | |
| 227 void OptimizingCompilerThread::FlushOsrBuffer(bool restore_function_code) { | |
| 228 for (int i = 0; i < osr_buffer_capacity_; i++) { | |
| 229 if (osr_buffer_[i] != NULL) { | |
| 230 DisposeOptimizedCompileJob(osr_buffer_[i], restore_function_code); | |
| 231 osr_buffer_[i] = NULL; | |
| 232 } | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 | |
| 237 void OptimizingCompilerThread::Flush() { | |
| 238 DCHECK(!IsOptimizerThread()); | |
| 239 base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(FLUSH)); | |
| 240 if (FLAG_block_concurrent_recompilation) Unblock(); | |
| 241 if (!job_based_recompilation_) { | |
| 242 input_queue_semaphore_.Signal(); | |
| 243 stop_semaphore_.Wait(); | |
| 244 } else { | |
| 245 base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_); | |
| 246 while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_); | |
| 247 base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE)); | |
| 248 } | |
| 249 FlushOutputQueue(true); | |
| 250 if (FLAG_concurrent_osr) FlushOsrBuffer(true); | |
| 251 if (tracing_enabled_) { | |
| 252 PrintF(" ** Flushed concurrent recompilation queues.\n"); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 | |
| 257 void OptimizingCompilerThread::Stop() { | |
| 258 DCHECK(!IsOptimizerThread()); | |
| 259 base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(STOP)); | |
| 260 if (FLAG_block_concurrent_recompilation) Unblock(); | |
| 261 if (!job_based_recompilation_) { | |
| 262 input_queue_semaphore_.Signal(); | |
| 263 stop_semaphore_.Wait(); | |
| 264 } else { | |
| 265 base::LockGuard<base::Mutex> lock_guard(&ref_count_mutex_); | |
| 266 while (ref_count_ > 0) ref_count_zero_.Wait(&ref_count_mutex_); | |
| 267 base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(CONTINUE)); | |
| 268 } | |
| 269 | |
| 270 if (recompilation_delay_ != 0) { | |
| 271 // At this point the optimizing compiler thread's event loop has stopped. | |
| 272 // There is no need for a mutex when reading input_queue_length_. | |
| 273 while (input_queue_length_ > 0) CompileNext(NextInput()); | |
| 274 InstallOptimizedFunctions(); | |
| 275 } else { | |
| 276 FlushInputQueue(false); | |
| 277 FlushOutputQueue(false); | |
| 278 } | |
| 279 | |
| 280 if (FLAG_concurrent_osr) FlushOsrBuffer(false); | |
| 281 | |
| 282 if (tracing_enabled_) { | |
| 283 double percentage = time_spent_compiling_.PercentOf(time_spent_total_); | |
| 284 if (job_based_recompilation_) percentage = 100.0; | |
| 285 PrintF(" ** Compiler thread did %.2f%% useful work\n", percentage); | |
| 286 } | |
| 287 | |
| 288 if ((FLAG_trace_osr || tracing_enabled_) && FLAG_concurrent_osr) { | |
| 289 PrintF("[COSR hit rate %d / %d]\n", osr_hits_, osr_attempts_); | |
| 290 } | |
| 291 | |
| 292 Join(); | |
| 293 } | |
| 294 | |
| 295 | |
| 296 void OptimizingCompilerThread::InstallOptimizedFunctions() { | |
| 297 DCHECK(!IsOptimizerThread()); | |
| 298 HandleScope handle_scope(isolate_); | |
| 299 | |
| 300 OptimizedCompileJob* job; | |
| 301 while (output_queue_.Dequeue(&job)) { | |
| 302 CompilationInfo* info = job->info(); | |
| 303 Handle<JSFunction> function(*info->closure()); | |
| 304 if (info->is_osr()) { | |
| 305 if (FLAG_trace_osr) { | |
| 306 PrintF("[COSR - "); | |
| 307 function->ShortPrint(); | |
| 308 PrintF(" is ready for install and entry at AST id %d]\n", | |
| 309 info->osr_ast_id().ToInt()); | |
| 310 } | |
| 311 job->WaitForInstall(); | |
| 312 // Remove stack check that guards OSR entry on original code. | |
| 313 Handle<Code> code = info->unoptimized_code(); | |
| 314 uint32_t offset = code->TranslateAstIdToPcOffset(info->osr_ast_id()); | |
| 315 BackEdgeTable::RemoveStackCheck(code, offset); | |
| 316 } else { | |
| 317 if (function->IsOptimized()) { | |
| 318 if (tracing_enabled_) { | |
| 319 PrintF(" ** Aborting compilation for "); | |
| 320 function->ShortPrint(); | |
| 321 PrintF(" as it has already been optimized.\n"); | |
| 322 } | |
| 323 DisposeOptimizedCompileJob(job, false); | |
| 324 } else { | |
| 325 Handle<Code> code = Compiler::GetConcurrentlyOptimizedCode(job); | |
| 326 function->ReplaceCode( | |
| 327 code.is_null() ? function->shared()->code() : *code); | |
| 328 } | |
| 329 } | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 | |
| 334 void OptimizingCompilerThread::QueueForOptimization(OptimizedCompileJob* job) { | |
| 335 DCHECK(IsQueueAvailable()); | |
| 336 DCHECK(!IsOptimizerThread()); | |
| 337 CompilationInfo* info = job->info(); | |
| 338 if (info->is_osr()) { | |
| 339 osr_attempts_++; | |
| 340 AddToOsrBuffer(job); | |
| 341 // Add job to the front of the input queue. | |
| 342 base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_); | |
| 343 DCHECK_LT(input_queue_length_, input_queue_capacity_); | |
| 344 // Move shift_ back by one. | |
| 345 input_queue_shift_ = InputQueueIndex(input_queue_capacity_ - 1); | |
| 346 input_queue_[InputQueueIndex(0)] = job; | |
| 347 input_queue_length_++; | |
| 348 } else { | |
| 349 // Add job to the back of the input queue. | |
| 350 base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_); | |
| 351 DCHECK_LT(input_queue_length_, input_queue_capacity_); | |
| 352 input_queue_[InputQueueIndex(input_queue_length_)] = job; | |
| 353 input_queue_length_++; | |
| 354 } | |
| 355 if (FLAG_block_concurrent_recompilation) { | |
| 356 blocked_jobs_++; | |
| 357 } else if (job_based_recompilation_) { | |
| 358 V8::GetCurrentPlatform()->CallOnBackgroundThread( | |
| 359 new CompileTask(isolate_), v8::Platform::kShortRunningTask); | |
| 360 } else { | |
| 361 input_queue_semaphore_.Signal(); | |
| 362 } | |
| 363 } | |
| 364 | |
| 365 | |
| 366 void OptimizingCompilerThread::Unblock() { | |
| 367 DCHECK(!IsOptimizerThread()); | |
| 368 while (blocked_jobs_ > 0) { | |
| 369 if (job_based_recompilation_) { | |
| 370 V8::GetCurrentPlatform()->CallOnBackgroundThread( | |
| 371 new CompileTask(isolate_), v8::Platform::kShortRunningTask); | |
| 372 } else { | |
| 373 input_queue_semaphore_.Signal(); | |
| 374 } | |
| 375 blocked_jobs_--; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 | |
| 380 OptimizedCompileJob* OptimizingCompilerThread::FindReadyOSRCandidate( | |
| 381 Handle<JSFunction> function, BailoutId osr_ast_id) { | |
| 382 DCHECK(!IsOptimizerThread()); | |
| 383 for (int i = 0; i < osr_buffer_capacity_; i++) { | |
| 384 OptimizedCompileJob* current = osr_buffer_[i]; | |
| 385 if (current != NULL && | |
| 386 current->IsWaitingForInstall() && | |
| 387 current->info()->HasSameOsrEntry(function, osr_ast_id)) { | |
| 388 osr_hits_++; | |
| 389 osr_buffer_[i] = NULL; | |
| 390 return current; | |
| 391 } | |
| 392 } | |
| 393 return NULL; | |
| 394 } | |
| 395 | |
| 396 | |
| 397 bool OptimizingCompilerThread::IsQueuedForOSR(Handle<JSFunction> function, | |
| 398 BailoutId osr_ast_id) { | |
| 399 DCHECK(!IsOptimizerThread()); | |
| 400 for (int i = 0; i < osr_buffer_capacity_; i++) { | |
| 401 OptimizedCompileJob* current = osr_buffer_[i]; | |
| 402 if (current != NULL && | |
| 403 current->info()->HasSameOsrEntry(function, osr_ast_id)) { | |
| 404 return !current->IsWaitingForInstall(); | |
| 405 } | |
| 406 } | |
| 407 return false; | |
| 408 } | |
| 409 | |
| 410 | |
| 411 bool OptimizingCompilerThread::IsQueuedForOSR(JSFunction* function) { | |
| 412 DCHECK(!IsOptimizerThread()); | |
| 413 for (int i = 0; i < osr_buffer_capacity_; i++) { | |
| 414 OptimizedCompileJob* current = osr_buffer_[i]; | |
| 415 if (current != NULL && *current->info()->closure() == function) { | |
| 416 return !current->IsWaitingForInstall(); | |
| 417 } | |
| 418 } | |
| 419 return false; | |
| 420 } | |
| 421 | |
| 422 | |
| 423 void OptimizingCompilerThread::AddToOsrBuffer(OptimizedCompileJob* job) { | |
| 424 DCHECK(!IsOptimizerThread()); | |
| 425 // Find the next slot that is empty or has a stale job. | |
| 426 OptimizedCompileJob* stale = NULL; | |
| 427 while (true) { | |
| 428 stale = osr_buffer_[osr_buffer_cursor_]; | |
| 429 if (stale == NULL || stale->IsWaitingForInstall()) break; | |
| 430 osr_buffer_cursor_ = (osr_buffer_cursor_ + 1) % osr_buffer_capacity_; | |
| 431 } | |
| 432 | |
| 433 // Add to found slot and dispose the evicted job. | |
| 434 if (stale != NULL) { | |
| 435 DCHECK(stale->IsWaitingForInstall()); | |
| 436 CompilationInfo* info = stale->info(); | |
| 437 if (FLAG_trace_osr) { | |
| 438 PrintF("[COSR - Discarded "); | |
| 439 info->closure()->PrintName(); | |
| 440 PrintF(", AST id %d]\n", info->osr_ast_id().ToInt()); | |
| 441 } | |
| 442 DisposeOptimizedCompileJob(stale, false); | |
| 443 } | |
| 444 osr_buffer_[osr_buffer_cursor_] = job; | |
| 445 osr_buffer_cursor_ = (osr_buffer_cursor_ + 1) % osr_buffer_capacity_; | |
| 446 } | |
| 447 | |
| 448 | |
| 449 #ifdef DEBUG | |
| 450 bool OptimizingCompilerThread::IsOptimizerThread(Isolate* isolate) { | |
| 451 return isolate->concurrent_recompilation_enabled() && | |
| 452 isolate->optimizing_compiler_thread()->IsOptimizerThread(); | |
| 453 } | |
| 454 | |
| 455 | |
| 456 bool OptimizingCompilerThread::IsOptimizerThread() { | |
| 457 base::LockGuard<base::Mutex> lock_guard(&thread_id_mutex_); | |
| 458 return ThreadId::Current().ToInteger() == thread_id_; | |
| 459 } | |
| 460 #endif | |
| 461 | |
| 462 | |
| 463 } } // namespace v8::internal | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1087763003:
Reland "Remove support for thread-based recompilation" (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master