[heap] Prepare IncrementalMarking::VisitObject for concurrent marking.

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/heap/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/concurrent-marking.h"
@@ skipping 779 matching lines @@
              (MemoryChunk::FromAddress(obj->address())
                   ->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
               ObjectMarking::IsBlack<kAtomicity>(obj, marking_state(obj))));
       // Skip one word filler objects that appear on the
       // stack when we perform in place array shift.
       return (obj->map() == filler_map) ? nullptr : obj;
     }
   });
 }
 
+bool IncrementalMarking::IsFixedArrayWithProgressBar(HeapObject* obj) {
+  if (!obj->IsFixedArray()) return false;
+  MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
+  return chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR);
+}
 
 void IncrementalMarking::VisitObject(Map* map, HeapObject* obj, int size) {
-  WhiteToGreyAndPush(map);
-
-  IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
-
 #if ENABLE_SLOW_DCHECKS
   MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj, marking_state(obj));
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
   SLOW_DCHECK(Marking::IsGrey<kAtomicity>(mark_bit) ||
               (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                Marking::IsBlack<kAtomicity>(mark_bit)));
 #endif
-  ObjectMarking::GreyToBlack<kAtomicity>(obj, marking_state(obj));
+  if (ObjectMarking::GreyToBlack<kAtomicity>(obj, marking_state(obj))) {

[Michael Lippautz, 2017/05/03 07:51:49]

GreyToWhite?

Otherwise WhiteToGreyAndPush will be a noop?

[ulan, 2017/05/03 09:03:54]

WhiteToGreyAndPush applies to the map.
The object is grey or black at this point. If we succeed in transitioning it to
black then we iterate its map and body.

[Michael Lippautz, 2017/05/03 10:05:39]

Thanks :)

+    WhiteToGreyAndPush(map);
+    IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
+  } else if (IsFixedArrayWithProgressBar(obj)) {
+    DCHECK(ObjectMarking::IsBlack<kAtomicity>(obj, marking_state(obj)));
+    IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental(map, obj);
+  }
 }
 
 intptr_t IncrementalMarking::ProcessMarkingDeque(
     intptr_t bytes_to_process, ForceCompletionAction completion) {
   intptr_t bytes_processed = 0;
   while (!marking_deque()->IsEmpty() && (bytes_processed < bytes_to_process ||
                                          completion == FORCE_COMPLETION)) {
     HeapObject* obj = marking_deque()->Pop();
 
     // Left trimming may result in white, grey, or black filler objects on the
@@ skipping 330 matching lines @@
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8