[heap] Minor MC: Add evacuation phase

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 418 matching lines @@
   void CollectEvacuationCandidates(PagedSpace* space);
 
   void AddEvacuationCandidate(Page* p);
 
   // Prepares for GC by resetting relocation info in old and map spaces and
   // choosing spaces to compact.
   void Prepare();
 
   // Performs a global garbage collection.
   void CollectGarbage();
+  // Performs a garbage collection in the young generation.
+  void CollectGarbageInYoungGeneration();
 
   bool StartCompaction();
 
   void AbortCompaction();
 
   // Determine type of object and emit deletion log event.
   static void ReportDeleteIfNeeded(HeapObject* obj, Isolate* isolate);
 
   // Distinguishable invalid map encodings (for single word and multiple words)
   // that indicate free regions.
@@ skipping 203 matching lines @@
   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 ClearNonLiveReferencesInYoungGeneration();
   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 20 matching lines @@
 
   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 EvacuateNewSpacePrologue();
 
+  template <MarkCompactMode mode>
   void EvacuatePagesInParallel();
 
   // The number of parallel compaction tasks, including the main thread.
   int NumberOfParallelCompactionTasks(int pages, intptr_t live_bytes);
 
+  template <MarkCompactMode mode>
   void EvacuateNewSpaceAndCandidates();
 
+  template <MarkCompactMode mode>
   void UpdatePointersAfterEvacuation();
 
   // Iterates through all live objects on a page using marking information.
   // Returns whether all objects have successfully been visited.
   template <class Visitor>
   bool VisitLiveObjects(MemoryChunk* page, Visitor* visitor,
                         IterationMode mode);
 
   void RecomputeLiveBytes(MemoryChunk* page);
 
@@ skipping 66 matching lines @@
 
  private:
   MarkCompactCollector* collector_;
 };
 
 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_