[heap] Cleanup: Untangle marking state and deque in incremental marking

src/heap/heap.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/heap.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/assembler-inl.h"
 #include "src/ast/context-slot-cache.h"
@@ skipping 3184 matching lines @@
   // Calculate location of new array start.
   Address old_start = object->address();
   Address new_start = old_start + bytes_to_trim;
 
   // Transfer the mark bits to their new location if the object is not within
   // a black area.
   if (!incremental_marking()->black_allocation() ||
       !Marking::IsBlack(ObjectMarking::MarkBitFrom(
           HeapObject::FromAddress(new_start),
           MarkingState::Internal(HeapObject::FromAddress(new_start))))) {
-    IncrementalMarking::TransferMark(this, object,
-                                     HeapObject::FromAddress(new_start));
+    incremental_marking()->TransferMark(this, object,
+                                        HeapObject::FromAddress(new_start));
   }
 
   // Technically in new space this write might be omitted (except for
   // debug mode which iterates through the heap), but to play safer
   // we still do it.
   CreateFillerObjectAt(old_start, bytes_to_trim, ClearRecordedSlots::kYes);
 
   // Initialize header of the trimmed array. Since left trimming is only
   // performed on pages which are not concurrently swept creating a filler
   // object does not require synchronization.
@@ skipping 1064 matching lines @@
           addr += obj->Size();
         }
       }
     }
   }
 }
 
 void Heap::NotifyObjectLayoutChange(HeapObject* object,
                                     const DisallowHeapAllocation&) {
   if (FLAG_incremental_marking && incremental_marking()->IsMarking()) {
-    incremental_marking()->MarkGrey(this, object);
+    incremental_marking()->MarkGrey(object);
   }
 #ifdef VERIFY_HEAP
   DCHECK(pending_layout_change_object_ == nullptr);
   pending_layout_change_object_ = object;
 #endif
 }
 
 #ifdef VERIFY_HEAP
 void Heap::VerifyObjectLayoutChange(HeapObject* object, Map* new_map) {
   if (pending_layout_change_object_ == nullptr) {
@@ skipping 546 matching lines @@
       slot_address += kPointerSize;
     }
   }
 
   inline void VisitCodeEntry(JSFunction* host,
                              Address code_entry_slot) override {
     // Black allocation requires us to process objects referenced by
     // promoted objects.
     if (heap_->incremental_marking()->black_allocation()) {
       Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
-      IncrementalMarking::MarkGrey(heap_, code);
+      heap_->incremental_marking()->MarkGrey(code);
     }
   }
 
  private:
   Heap* heap_;
   HeapObject* target_;
   bool record_slots_;
 };
 
 void Heap::IterateAndScavengePromotedObject(HeapObject* target, int size,
@@ skipping 21 matching lines @@
     target->IterateBody(target->map()->instance_type(), size, &visitor);
   }
 
   // When black allocations is on, we have to visit not already marked black
   // objects (in new space) promoted to black pages to keep their references
   // alive.
   // TODO(hpayer): Implement a special promotion visitor that incorporates
   // regular visiting and IteratePromotedObjectPointers.
   if (!was_marked_black) {
     if (incremental_marking()->black_allocation()) {
-      IncrementalMarking::MarkGrey(this, target->map());
+      incremental_marking()->MarkGrey(target->map());
       incremental_marking()->IterateBlackObject(target);
     }
   }
 }
 
 void Heap::IterateRoots(RootVisitor* v, VisitMode mode) {
   IterateStrongRoots(v, mode);
   IterateWeakRoots(v, mode);
 }
 
@@ skipping 599 matching lines @@
 
   // Set up memory allocator.
   memory_allocator_ = new MemoryAllocator(isolate_);
   if (!memory_allocator_->SetUp(MaxReserved(), MaxExecutableSize(),
                                 code_range_size_))
     return false;
 
   store_buffer_ = new StoreBuffer(this);
 
   incremental_marking_ = new IncrementalMarking(this);
-
   concurrent_marking_ = new ConcurrentMarking(this);
 
   for (int i = 0; i <= LAST_SPACE; i++) {
     space_[i] = nullptr;
   }
 
   space_[NEW_SPACE] = new_space_ = new NewSpace(this);
   if (!new_space_->SetUp(initial_semispace_size_, max_semi_space_size_)) {
     return false;
   }
@@ skipping 27 matching lines @@
   }
 
   for (int i = 0; i < static_cast<int>(v8::Isolate::kUseCounterFeatureCount);
        i++) {
     deferred_counters_[i] = 0;
   }
 
   tracer_ = new GCTracer(this);
   scavenge_collector_ = new Scavenger(this);
   mark_compact_collector_ = new MarkCompactCollector(this);
+  incremental_marking_->set_marking_deque(
+      mark_compact_collector_->marking_deque());
   if (FLAG_minor_mc)
     minor_mark_compact_collector_ = new MinorMarkCompactCollector(this);
   gc_idle_time_handler_ = new GCIdleTimeHandler();
   memory_reducer_ = new MemoryReducer(this);
   if (V8_UNLIKELY(FLAG_gc_stats)) {
     live_object_stats_ = new ObjectStats(this);
     dead_object_stats_ = new ObjectStats(this);
   }
   scavenge_job_ = new ScavengeJob();
   local_embedder_heap_tracer_ = new LocalEmbedderHeapTracer();
@@ skipping 91 matching lines @@
   }
 }
 
 void Heap::RegisterExternallyReferencedObject(Object** object) {
   // The embedder is not aware of whether numbers are materialized as heap
   // objects are just passed around as Smis.
   if (!(*object)->IsHeapObject()) return;
   HeapObject* heap_object = HeapObject::cast(*object);
   DCHECK(Contains(heap_object));
   if (FLAG_incremental_marking_wrappers && incremental_marking()->IsMarking()) {
-    IncrementalMarking::MarkGrey(this, heap_object);
+    incremental_marking()->MarkGrey(heap_object);
   } else {
     DCHECK(mark_compact_collector()->in_use());
     mark_compact_collector()->MarkObject(heap_object);
   }
 }
 
 void Heap::TearDown() {
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
@@ skipping 747 matching lines @@
     case LO_SPACE:
       return "LO_SPACE";
     default:
       UNREACHABLE();
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace v8