Fix logic for doing incremental marking steps on tenured allocation.

src/heap/incremental-marking.h

 // 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.
 
 #ifndef V8_HEAP_INCREMENTAL_MARKING_H_
 #define V8_HEAP_INCREMENTAL_MARKING_H_
 
 
 #include "src/execution.h"
 #include "src/heap/mark-compact.h"
@@ skipping 32 matching lines @@
   }
 
   void SetWeakClosureWasOverApproximatedForTesting(bool val) {
     weak_closure_was_overapproximated_ = val;
   }
 
   inline bool IsStopped() { return state() == STOPPED; }
 
   INLINE(bool IsMarking()) { return state() >= MARKING; }
 
-  inline bool IsMarkingIncomplete() { return state() == MARKING; }
+  inline bool CanDoSteps() {
+    return FLAG_incremental_marking_steps &&
+           (state() == MARKING || state() == SWEEPING);
+  }
 
   inline bool IsComplete() { return state() == COMPLETE; }
 
   inline bool IsReadyToOverApproximateWeakClosure() const {
     return request_type_ == OVERAPPROXIMATION &&
            !weak_closure_was_overapproximated_;
   }
 
   GCRequestType request_type() const { return request_type_; }
 
@@ skipping 33 matching lines @@
   // incremental marker until it completes.
   // Do some marking every time this much memory has been allocated or that many
   // heavy (color-checking) write barriers have been invoked.
   static const intptr_t kAllocatedThreshold = 65536;
   static const intptr_t kWriteBarriersInvokedThreshold = 32768;
   // Start off by marking this many times more memory than has been allocated.
   static const intptr_t kInitialMarkingSpeed = 1;
   // But if we are promoting a lot of data we need to mark faster to keep up
   // with the data that is entering the old space through promotion.
   static const intptr_t kFastMarking = 3;
+  static const intptr_t kOldSpaceAllocationMarkingFactor =
+      kFastMarking / kInitialMarkingSpeed;
   // After this many steps we increase the marking/allocating factor.
   static const intptr_t kMarkingSpeedAccellerationInterval = 1024;
   // This is how much we increase the marking/allocating factor by.
   static const intptr_t kMarkingSpeedAccelleration = 2;
   static const intptr_t kMaxMarkingSpeed = 1000;
 
   // This is the upper bound for how many times we allow finalization of
   // incremental marking to be postponed.
   static const size_t kMaxIdleMarkingDelayCounter = 3;
 
@@ skipping 141 matching lines @@
   int weak_closure_approximation_rounds_;
 
   GCRequestType request_type_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalMarking);
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_INCREMENTAL_MARKING_H_