Check if there is still time before finalizing an incremental collection.

src/heap/incremental-marking.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/v8.h"
 
 #include "src/heap/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/objects-visiting.h"
 #include "src/heap/objects-visiting-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 IncrementalMarking::IncrementalMarking(Heap* heap)
     : heap_(heap),
       state_(STOPPED),
       marking_deque_memory_(NULL),
       marking_deque_memory_committed_(false),
       steps_count_(0),
       old_generation_space_available_at_start_of_incremental_(0),
       old_generation_space_used_at_start_of_incremental_(0),
       should_hurry_(false),
       marking_speed_(0),
       allocated_(0),
+      idle_marking_delay_counter_(0),
       no_marking_scope_depth_(0),
       unscanned_bytes_of_large_object_(0) {}
 
 
 void IncrementalMarking::TearDown() { delete marking_deque_memory_; }
 
 
 void IncrementalMarking::RecordWriteSlow(HeapObject* obj, Object** slot,
                                          Object* value) {
   if (BaseRecordWrite(obj, slot, value) && slot != NULL) {
@@ skipping 846 matching lines @@
           Min(kMaxMarkingSpeed, static_cast<intptr_t>(marking_speed_ * 1.3)));
       if (FLAG_trace_gc) {
         PrintPID("Marking speed increased to %d\n", marking_speed_);
       }
     }
   }
 }
 
 
 void IncrementalMarking::Step(intptr_t allocated_bytes, CompletionAction action,
-                              bool force_marking) {
+                              bool force_marking, bool force_completion) {
   if (heap_->gc_state() != Heap::NOT_IN_GC || !FLAG_incremental_marking ||
       !FLAG_incremental_marking_steps ||
       (state_ != SWEEPING && state_ != MARKING)) {
     return;
   }
 
   allocated_ += allocated_bytes;
 
   if (!force_marking && allocated_ < kAllocatedThreshold &&
       write_barriers_invoked_since_last_step_ <
@@ skipping 29 matching lines @@
       if (heap_->mark_compact_collector()->sweeping_in_progress() &&
           heap_->mark_compact_collector()->IsSweepingCompleted()) {
         heap_->mark_compact_collector()->EnsureSweepingCompleted();
       }
       if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
         bytes_scanned_ = 0;
         StartMarking(PREVENT_COMPACTION);
       }
     } else if (state_ == MARKING) {
       bytes_processed = ProcessMarkingDeque(bytes_to_process);
-      if (marking_deque_.IsEmpty()) MarkingComplete(action);
+      IncrementIdleMarkingDelayCounter();

[Erik Corry Chromium.org, 2014/10/06 14:56:47]

If we increment this every time we do a step, then I think it will always be
above 3 when we check it.  What am I missing?

[Hannes Payer (out of office), 2014/10/07 13:41:11]

Uff, good catch. We should just increment the counter when we finish marking but
do not complete. Done.

+      if (marking_deque_.IsEmpty() &&
+          (force_completion || IsIdleMarkingDelayCounterLimitReached())) {
+        MarkingComplete(action);
+      }
     }
 
     steps_count_++;
 
     // Speed up marking if we are marking too slow or if we are almost done
     // with marking.
     SpeedUp();
 
     double end = base::OS::TimeCurrentMillis();
     double duration = (end - start);
@@ skipping 14 matching lines @@
   bytes_rescanned_ = 0;
   marking_speed_ = kInitialMarkingSpeed;
   bytes_scanned_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
+
+
+bool IncrementalMarking::IsIdleMarkingDelayCounterLimitReached() {
+  return idle_marking_delay_counter_ >= kMaxIdleMarkingDelayCounter;
+}
+
+
+void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
+  idle_marking_delay_counter_++;
+}
+
+
+void IncrementalMarking::ClearIdleMarkingDelayCounter() {
+  idle_marking_delay_counter_ = 0;
+}
 }
 }  // namespace v8::internal