Only flush not yet started and finished compile jobs from gc

src/compiler-dispatcher/optimizing-compile-dispatcher.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/compiler-dispatcher/optimizing-compile-dispatcher.h"
 
 #include "src/base/atomicops.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 116 matching lines @@
       base::LockGuard<base::Mutex> access_output_queue_(&output_queue_mutex_);
       if (output_queue_.empty()) return;
       job = output_queue_.front();
       output_queue_.pop();
     }
 
     DisposeCompilationJob(job, restore_function_code);
   }
 }
 
-void OptimizingCompileDispatcher::Flush() {
+void OptimizingCompileDispatcher::Flush(BlockingBehavior blocking_behavior) {
+  if (FLAG_block_concurrent_recompilation) Unblock();
+  if (blocking_behavior == BlockingBehavior::kDontBlock) {
+    base::LockGuard<base::Mutex> access_input_queue_(&input_queue_mutex_);
+    while (input_queue_length_ > 0) {
+      CompilationJob* job = input_queue_[InputQueueIndex(0)];
+      DCHECK_NOT_NULL(job);
+      input_queue_shift_ = InputQueueIndex(1);
+      input_queue_length_--;
+      DisposeCompilationJob(job, true);
+    }
+    FlushOutputQueue(true);
+    if (FLAG_trace_concurrent_recompilation) {
+      PrintF("  ** Flushed concurrent recompilation queues (not blocking).\n");
+    }
+    return;
+  }
   base::Release_Store(&mode_, static_cast<base::AtomicWord>(FLUSH));
   if (FLAG_block_concurrent_recompilation) Unblock();
   {
     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));
   }
   FlushOutputQueue(true);
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Flushed concurrent recompilation queues.\n");
@@ skipping 65 matching lines @@
 void OptimizingCompileDispatcher::Unblock() {
   while (blocked_jobs_ > 0) {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new CompileTask(isolate_), v8::Platform::kShortRunningTask);
     blocked_jobs_--;
   }
 }
 
 }  // namespace internal
 }  // namespace v8