[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"
@@ skipping 422 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 ClearNonLiveReferences() = 0;
+  virtual void EvacuatePrologue() = 0;
+  virtual void EvacuateEpilogue() = 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, const intptr_t live_bytes,
+      RecordMigratedSlotVisitor* record_visitor,
+      MigrationObserver* migration_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();

[Hannes Payer (out of office), 2017/05/02 16:17:26]

ProcessMarkingDeque and EmtyMarkingDeque could also virtual.

[Michael Lippautz, 2017/05/02 16:56:17]

Done.

   void EmptyMarkingDeque();
+  void ClearNonLiveReferences() override;
+
+  void EvacuatePrologue() override;
+  void EvacuateEpilogue() override;
+  void EvacuateNewSpace(std::vector<HeapObject*>* black_allocation_objects);

[Hannes Payer (out of office), 2017/05/02 16:17:26]

Evacuate* could be virtual if we do not expose black allocation and handle it
within evacuation, c.f. comment in the implementation.

[Michael Lippautz, 2017/05/02 16:56:17]

See above.

+  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 253 matching lines @@
   void DiscoverGreyObjectsOnPage(MemoryChunk* p);
   void DiscoverGreyObjectsInSpace(PagedSpace* space);
   void DiscoverGreyObjectsInNewSpace();
 
   // Callback function for telling whether the object *p is an unmarked
   // heap object.
   static bool IsUnmarkedHeapObject(Object** p);
 
   // Clear non-live references in weak cells, transition and descriptor arrays,
   // and deoptimize dependent code of non-live maps.
-  void ClearNonLiveReferences();
+  void ClearNonLiveReferences() override;
   void MarkDependentCodeForDeoptimization(DependentCode* list);
   // Find non-live targets of simple transitions in the given list. Clear
   // transitions to non-live targets and if needed trim descriptors arrays.
   void ClearSimpleMapTransitions(Object* non_live_map_list);
   void ClearSimpleMapTransition(Map* map, Map* dead_transition);
   // Compact every array in the global list of transition arrays and
   // trim the corresponding descriptor array if a transition target is non-live.
   void ClearFullMapTransitions();
   bool CompactTransitionArray(Map* map, TransitionArray* transitions,
                               DescriptorArray* descriptors);
@@ skipping 18 matching lines @@
                       DependentCode** dependent_code_list);
   void AbortWeakCells();
 
   void AbortTransitionArrays();
 
   // Starts sweeping of spaces by contributing on the main thread and setting
   // up other pages for sweeping. Does not start sweeper tasks.
   void StartSweepSpaces();
   void StartSweepSpace(PagedSpace* space);
 
-  void EvacuatePrologue();
-  void EvacuateEpilogue();
+  void EvacuatePrologue() override;
+  void EvacuateEpilogue() override;
   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_