[heap] Minor MC: Implement page moving

src/heap/mark-compact.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_MARK_COMPACT_H_
 #define V8_HEAP_MARK_COMPACT_H_
 
 #include <deque>
 
 #include "src/base/bits.h"
@@ skipping 259 matching lines @@
   // for visited objects are cleared for each successfully visited object.
   template <class Visitor>
   bool VisitBlackObjects(MemoryChunk* chunk, const MarkingState& state,
                          Visitor* visitor, IterationMode iteration_mode);
 
  private:
   void RecomputeLiveBytes(MemoryChunk* chunk, const MarkingState& state);
 };
 
 enum PageEvacuationMode { NEW_TO_NEW, NEW_TO_OLD };
+enum FreeSpaceTreatmentMode { IGNORE_FREE_SPACE, ZAP_FREE_SPACE };
+enum MarkingTreatmentMode { KEEP, CLEAR };
 
 // Base class for minor and full MC collectors.
 class MarkCompactCollectorBase {
  public:
   virtual ~MarkCompactCollectorBase() {}
 
   // Note: Make sure to refer to the instances by their concrete collector
   // type to avoid vtable lookups marking state methods when used in hot paths.
   virtual MarkingState marking_state(HeapObject* object) const = 0;
   virtual MarkingState marking_state(MemoryChunk* chunk) const = 0;
@@ skipping 25 matching lines @@
   // The number of parallel compaction tasks, including the main thread.
   int NumberOfParallelCompactionTasks(int pages, intptr_t live_bytes);
 
   template <class Evacuator, class Collector>
   void CreateAndExecuteEvacuationTasks(
       Collector* collector, PageParallelJob<EvacuationJobTraits>* job,
       RecordMigratedSlotVisitor* record_visitor,
       MigrationObserver* migration_observer, const intptr_t live_bytes,
       const int& abandoned_pages);
 
+  // Returns whether this page should be moved according to heuristics.
+  bool ShouldMovePage(Page* p, intptr_t live_bytes);
+
   Heap* heap_;
 };
 
 // Collector for young-generation only.
 class MinorMarkCompactCollector final : public MarkCompactCollectorBase {
  public:
   explicit MinorMarkCompactCollector(Heap* heap)
       : MarkCompactCollectorBase(heap),
         marking_deque_(heap),
         page_parallel_job_semaphore_(0) {}
 
   MarkingState marking_state(HeapObject* object) const override {
     return MarkingState::External(object);
   }
 
   MarkingState marking_state(MemoryChunk* chunk) const override {
     return MarkingState::External(chunk);
   }
 
   void SetUp() override;
   void TearDown() override;
   void CollectGarbage() override;
 
+  void MakeIterable(Page* page, MarkingTreatmentMode marking_mode,
+                    FreeSpaceTreatmentMode free_space_mode);
+  void CleanupSweepToIteratePages();
+
  private:
   class RootMarkingVisitor;
 
   inline MarkingDeque* marking_deque() { return &marking_deque_; }
 
   V8_INLINE void MarkObject(HeapObject* obj);
   V8_INLINE void PushBlack(HeapObject* obj);
 
   SlotCallbackResult CheckAndMarkObject(Heap* heap, Address slot_address);
   void MarkLiveObjects() override;
   void ProcessMarkingDeque() override;
   void EmptyMarkingDeque() override;
   void ClearNonLiveReferences() override;
 
   void EvacuatePrologue() override;
   void EvacuateEpilogue() override;
   void Evacuate() override;
   void EvacuatePagesInParallel() override;
   void UpdatePointersAfterEvacuation() override;
 
   MarkingDeque marking_deque_;
   base::Semaphore page_parallel_job_semaphore_;
   List<Page*> new_space_evacuation_pages_;
+  std::vector<Page*> sweep_to_iterate_pages_;
 
   friend class StaticYoungGenerationMarkingVisitor;
 };
 
 // Collector for young and old generation.
 class MarkCompactCollector final : public MarkCompactCollectorBase {
  public:
   class RootMarkingVisitor;
 
   class Sweeper {
    public:
     class SweeperTask;
 
     enum FreeListRebuildingMode { REBUILD_FREE_LIST, IGNORE_FREE_LIST };
-    enum FreeSpaceTreatmentMode { IGNORE_FREE_SPACE, ZAP_FREE_SPACE };
     enum ClearOldToNewSlotsMode {
       DO_NOT_CLEAR,
       CLEAR_REGULAR_SLOTS,
       CLEAR_TYPED_SLOTS
     };
 
     typedef std::deque<Page*> SweepingList;
     typedef List<Page*> SweptList;
 
     static int RawSweep(Page* p, FreeListRebuildingMode free_list_mode,
@@ skipping 349 matching lines @@
   ~EvacuationScope() { collector_->set_evacuation(false); }
 
  private:
   MarkCompactCollector* collector_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_