[heap] Introduce explicit marking state and instance for minor MC

BUG=chromium:651354

Change-Id: Idcd7780f53ad07b3d782a66455f9c60addc2418d
Reviewed-on: https://chromium-review.googlesource.com/457317
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Hannes Payer <hpayer@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#43971}

src/flag-definitions.h

@@ -657,6 +657,8 @@ DEFINE_INT(min_progress_during_incremental_marking_finalization, 32,
 DEFINE_INT(max_incremental_marking_finalization_rounds, 3,
            "at most try this many times to finalize incremental marking")
 DEFINE_BOOL(minor_mc, false, "perform young generation mark compact GCs")
+DEFINE_NEG_IMPLICATION(minor_mc, page_promotion)
+DEFINE_NEG_IMPLICATION(minor_mc, flush_code)
 DEFINE_BOOL(black_allocation, true, "use black allocation")
 DEFINE_BOOL(concurrent_store_buffer, true,
             "use concurrent store buffer processing")

src/heap/gc-tracer.h

@@ -82,6 +82,7 @@ enum ScavengeSpeedMode { kForAllObjects, kForSurvivedObjects };
   F(MC_SWEEP_CODE)                            \
   F(MC_SWEEP_MAP)                             \
   F(MC_SWEEP_OLD)                             \
+  F(MC_MINOR_MC)                              \
   F(MINOR_MC_MARK)                            \
   F(MINOR_MC_MARK_CODE_FLUSH_CANDIDATES)      \
   F(MINOR_MC_MARK_GLOBAL_HANDLES)             \

src/heap/heap.cc

@@ -133,6 +133,7 @@ Heap::Heap()
       last_gc_time_(0.0),
       scavenge_collector_(nullptr),
       mark_compact_collector_(nullptr),
+      minor_mark_compact_collector_(nullptr),
       memory_allocator_(nullptr),
       store_buffer_(nullptr),
       incremental_marking_(nullptr),
@@ -1466,7 +1467,21 @@ void Heap::MarkCompact() {
   }
 }
 
-void Heap::MinorMarkCompact() { UNREACHABLE(); }
+void Heap::MinorMarkCompact() {
+  DCHECK(FLAG_minor_mc);
+
+  SetGCState(MINOR_MARK_COMPACT);
+  LOG(isolate_, ResourceEvent("MinorMarkCompact", "begin"));
+
+  TRACE_GC(tracer(), GCTracer::Scope::MC_MINOR_MC);
+  AlwaysAllocateScope always_allocate(isolate());
+  PauseAllocationObserversScope pause_observers(this);
+
+  minor_mark_compact_collector()->CollectGarbage();
+
+  LOG(isolate_, ResourceEvent("MinorMarkCompact", "end"));
+  SetGCState(NOT_IN_GC);
+}
 
 void Heap::MarkCompactEpilogue() {
   TRACE_GC(tracer(), GCTracer::Scope::MC_EPILOGUE);
@@ -5519,6 +5534,8 @@ bool Heap::SetUp() {
   tracer_ = new GCTracer(this);
   scavenge_collector_ = new Scavenger(this);
   mark_compact_collector_ = new MarkCompactCollector(this);
+  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)) {
@@ -5534,6 +5551,9 @@ bool Heap::SetUp() {
   store_buffer()->SetUp();
 
   mark_compact_collector()->SetUp();
+  if (minor_mark_compact_collector() != nullptr) {
+    minor_mark_compact_collector()->SetUp();
+  }
 
   idle_scavenge_observer_ = new IdleScavengeObserver(
       *this, ScavengeJob::kBytesAllocatedBeforeNextIdleTask);
@@ -5655,6 +5675,12 @@ void Heap::TearDown() {
     mark_compact_collector_ = nullptr;
   }
 
+  if (minor_mark_compact_collector_ != nullptr) {
+    minor_mark_compact_collector_->TearDown();
+    delete minor_mark_compact_collector_;
+    minor_mark_compact_collector_ = nullptr;
+  }
+
   delete incremental_marking_;
   incremental_marking_ = nullptr;
 

src/heap/heap.h

@@ -325,6 +325,7 @@ class Isolate;
 class LocalEmbedderHeapTracer;
 class MemoryAllocator;
 class MemoryReducer;
+class MinorMarkCompactCollector;
 class ObjectIterator;
 class ObjectStats;
 class Page;
@@ -559,7 +560,7 @@ class Heap {
 
   enum FindMementoMode { kForRuntime, kForGC };
 
-  enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
+  enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT, MINOR_MARK_COMPACT };
 
   enum UpdateAllocationSiteMode { kGlobal, kCached };
 
@@ -1040,6 +1041,10 @@ class Heap {
     return mark_compact_collector_;
   }
 
+  MinorMarkCompactCollector* minor_mark_compact_collector() {
+    return minor_mark_compact_collector_;
+  }
+
   // ===========================================================================
   // Root set access. ==========================================================
   // ===========================================================================
@@ -2278,6 +2283,7 @@ class Heap {
   Scavenger* scavenge_collector_;
 
   MarkCompactCollector* mark_compact_collector_;
+  MinorMarkCompactCollector* minor_mark_compact_collector_;
 
   MemoryAllocator* memory_allocator_;
 
@@ -2377,6 +2383,7 @@ class Heap {
   friend class IncrementalMarkingJob;
   friend class LargeObjectSpace;
   friend class MarkCompactCollector;
+  friend class MinorMarkCompactCollector;
   friend class MarkCompactMarkingVisitor;
   friend class NewSpace;
   friend class ObjectStatsCollector;

src/heap/mark-compact-inl.h

@@ -12,14 +12,20 @@
 namespace v8 {
 namespace internal {
 
-template <MarkingMode mode>
 void MarkCompactCollector::PushBlack(HeapObject* obj) {
-  DCHECK((ObjectMarking::IsBlack<MarkBit::NON_ATOMIC, mode>(obj)));
-  if (!marking_deque<mode>()->Push(obj)) {
-    ObjectMarking::BlackToGrey<MarkBit::NON_ATOMIC, mode>(obj);
+  DCHECK((ObjectMarking::IsBlack<MarkBit::NON_ATOMIC>(obj)));
+  if (!marking_deque()->Push(obj)) {
+    ObjectMarking::BlackToGrey<MarkBit::NON_ATOMIC>(obj);
   }
 }
 
+void MinorMarkCompactCollector::PushBlack(HeapObject* obj) {
+  DCHECK(
+      (ObjectMarking::IsBlack<MarkBit::NON_ATOMIC>(obj, StateForObject(obj))));
+  if (!marking_deque()->Push(obj)) {
+    ObjectMarking::BlackToGrey<MarkBit::NON_ATOMIC>(obj, StateForObject(obj));
+  }
+}
 
 void MarkCompactCollector::UnshiftBlack(HeapObject* obj) {
   DCHECK(ObjectMarking::IsBlack(obj));
@@ -28,11 +34,17 @@ void MarkCompactCollector::UnshiftBlack(HeapObject* obj) {
   }
 }
 
-template <MarkingMode mode>
 void MarkCompactCollector::MarkObject(HeapObject* obj) {
-  if (ObjectMarking::IsWhite<MarkBit::NON_ATOMIC, mode>(obj)) {
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC, mode>(obj);
-    PushBlack<mode>(obj);
+  if (ObjectMarking::IsWhite<MarkBit::NON_ATOMIC>(obj)) {
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(obj);
+    PushBlack(obj);
+  }
+}
+
+void MinorMarkCompactCollector::MarkObject(HeapObject* obj) {
+  if (ObjectMarking::IsWhite<MarkBit::NON_ATOMIC>(obj, StateForObject(obj))) {
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(obj, StateForObject(obj));
+    PushBlack(obj);
   }
 }
 

src/heap/spaces.h

@@ -526,6 +526,14 @@ class MemoryChunk {
                : young_generation_bitmap_;
   }
 
+  template <MarkingMode mode = MarkingMode::FULL>
+  inline intptr_t* live_bytes_address() {
+    // TODO(mlippautz): Fix type of live_byte_count_.
+    return mode == MarkingMode::FULL
+               ? reinterpret_cast<intptr_t*>(&live_byte_count_)
+               : &young_generation_live_byte_count_;
+  }
+
   inline uint32_t AddressToMarkbitIndex(Address addr) const {
     return static_cast<uint32_t>(addr - this->address()) >> kPointerSizeLog2;
   }

test/cctest/heap/test-mark-compact.cc

@@ -354,7 +354,9 @@ TEST(Regress5829) {
   heap->CreateFillerObjectAt(old_end - kPointerSize, kPointerSize,
                              ClearRecordedSlots::kNo);
   heap->old_space()->EmptyAllocationInfo();
-  LiveObjectIterator<kGreyObjects> it(Page::FromAddress(array->address()));
+  Page* page = Page::FromAddress(array->address());
+  LiveObjectIterator<kGreyObjects> it(page,
+                                      MarkingState::FromPageInternal(page));
   HeapObject* object = nullptr;
   while ((object = it.Next()) != nullptr) {
     CHECK(!object->IsFiller());