[heap] Evacuation for young generation

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"
 #include "src/base/platform/condition-variable.h"
 #include "src/cancelable-task.h"
 #include "src/heap/marking.h"
 #include "src/heap/spaces.h"
 #include "src/heap/store-buffer.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class CodeFlusher;
+class EvacuationJobTraits;
 class HeapObjectVisitor;
 class MarkCompactCollector;
 class MinorMarkCompactCollector;
 class MarkingVisitor;
+class MigrationObserver;
+template <typename JobTraits>
+class PageParallelJob;
+class RecordMigratedSlotVisitor;
 class ThreadLocalTop;
 
 class ObjectMarking : public AllStatic {
  public:
   V8_INLINE static MarkBit MarkBitFrom(HeapObject* obj,
                                        const MarkingState& state) {
     const Address address = obj->address();
     const MemoryChunk* p = MemoryChunk::FromAddress(address);
     return state.bitmap()->MarkBitFromIndex(p->AddressToMarkbitIndex(address));
   }
@@ skipping 392 matching lines @@
   virtual void TearDown() = 0;
   virtual void CollectGarbage() = 0;
 
   inline Heap* heap() const { return heap_; }
   inline Isolate* isolate() { return heap()->isolate(); }
 
  protected:
   explicit MarkCompactCollectorBase(Heap* heap) : heap_(heap) {}
 
   virtual void MarkLiveObjects() = 0;
+  virtual void UpdatePointersAfterEvacuation() = 0;
 
   // 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* observer,
+      const intptr_t live_bytes, const int& abandoned_pages);
+
   Heap* heap_;
 };
 
 // Collector for young-generation only.
 class MinorMarkCompactCollector final : public MarkCompactCollectorBase {
  public:
   explicit MinorMarkCompactCollector(Heap* heap)
-      : MarkCompactCollectorBase(heap), marking_deque_(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;
 
  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();
   void EmptyMarkingDeque();
+  void ClearNonLiveReferences();
+
+  void EvacuatePrologue();
+  void EvacuateEpilogue();
+  void EvacuateNewSpace(std::vector<HeapObject*>* black_allocation_objects);
+  void EvacuatePagesInParallel(
+      std::vector<HeapObject*>* black_allocation_objects);
+  void UpdatePointersAfterEvacuation() override;
 
   MarkingDeque marking_deque_;
+  base::Semaphore page_parallel_job_semaphore_;
+  List<Page*> new_space_evacuation_pages_;
 
   friend class StaticYoungGenerationMarkingVisitor;
 };
 
 // Collector for young and old generation.
 class MarkCompactCollector final : public MarkCompactCollectorBase {
  public:
   class RootMarkingVisitor;
 
   class Sweeper {
@@ skipping 298 matching lines @@
   // up other pages for sweeping. Does not start sweeper tasks.
   void StartSweepSpaces();
   void StartSweepSpace(PagedSpace* space);
 
   void EvacuatePrologue();
   void EvacuateEpilogue();
   void EvacuatePagesInParallel();
 
   void EvacuateNewSpaceAndCandidates();
 
-  void UpdatePointersAfterEvacuation();
+  void UpdatePointersAfterEvacuation() override;
 
   void ReleaseEvacuationCandidates();
 
   base::Semaphore page_parallel_job_semaphore_;
 
 #ifdef DEBUG
   enum CollectorState {
     IDLE,
     PREPARE_GC,
     MARK_LIVE_OBJECTS,
@@ skipping 52 matching lines @@
   ~EvacuationScope() { collector_->set_evacuation(false); }
 
  private:
   MarkCompactCollector* collector_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_