[heap] Separate scavenger functionality into own file.

src/heap/heap.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_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/atomic-utils.h"
 #include "src/globals.h"
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/incremental-marking.h"
 #include "src/heap/mark-compact.h"
-#include "src/heap/objects-visiting.h"
 #include "src/heap/spaces.h"
 #include "src/heap/store-buffer.h"
 #include "src/list.h"
 
 namespace v8 {
 namespace internal {
 
 // Defines all the roots in Heap.
 #define STRONG_ROOT_LIST(V)                                                    \
   V(Map, byte_array_map, ByteArrayMap)                                         \
@@ skipping 391 matching lines @@
   V(empty_string)                       \
   PRIVATE_SYMBOL_LIST(V)
 
 // Forward declarations.
 class ArrayBufferTracker;
 class HeapObjectsFilter;
 class HeapStats;
 class Isolate;
 class MemoryReducer;
 class ObjectStats;
+class Scavenger;
 class WeakObjectRetainer;
 
 
 // A queue of objects promoted during scavenge. Each object is accompanied
 // by it's size to avoid dereferencing a map pointer for scanning.
 // The last page in to-space is used for the promotion queue. On conflict
 // during scavenge, the promotion queue is allocated externally and all
 // entries are copied to the external queue.
 class PromotionQueue {
  public:
@@ skipping 88 matching lines @@
   List<Entry>* emergency_stack_;
 
   Heap* heap_;
 
   void RelocateQueueHead();
 
   DISALLOW_COPY_AND_ASSIGN(PromotionQueue);
 };
 
 
-typedef void (*ScavengingCallback)(Map* map, HeapObject** slot,
-                                   HeapObject* object);
-
-
 enum ArrayStorageAllocationMode {
   DONT_INITIALIZE_ARRAY_ELEMENTS,
   INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE
 };
 
 
 class Heap {
  public:
   // Declare all the root indices.  This defines the root list order.
   enum RootListIndex {
@@ skipping 160 matching lines @@
   // Calculates the maximum amount of filler that could be required by the
   // given alignment.
   static int GetMaximumFillToAlign(AllocationAlignment alignment);
   // Calculates the actual amount of filler required for a given address at the
   // given alignment.
   static int GetFillToAlign(Address address, AllocationAlignment alignment);
 
   template <typename T>
   static inline bool IsOneByte(T t, int chars);
 
-  // Callback function passed to Heap::Iterate etc.  Copies an object if
-  // necessary, the object might be promoted to an old space.  The caller must
-  // ensure the precondition that the object is (a) a heap object and (b) in
-  // the heap's from space.
-  static inline void ScavengePointer(HeapObject** p);
-  static inline void ScavengeObject(HeapObject** p, HeapObject* object);
-
-  // Slow part of scavenge object.
-  static void ScavengeObjectSlow(HeapObject** p, HeapObject* object);
-
   static void FatalProcessOutOfMemory(const char* location,
                                       bool take_snapshot = false);
 
   static bool RootIsImmortalImmovable(int root_index);
 
   // Checks whether the space is valid.
   static bool IsValidAllocationSpace(AllocationSpace space);
 
   // An object may have an AllocationSite associated with it through a trailing
   // AllocationMemento. Its feedback should be updated when objects are found
@@ skipping 1027 matching lines @@
   // Adds an allocation site to the scratchpad if there is space left.
   void AddAllocationSiteToScratchpad(AllocationSite* site,
                                      ScratchpadSlotMode mode);
 
   // TODO(hpayer): Allocation site pretenuring may make this method obsolete.
   // Re-visit incremental marking heuristics.
   bool IsHighSurvivalRate() { return high_survival_rate_period_length_ > 0; }
 
   void ConfigureInitialOldGenerationSize();
 
-  void SelectScavengingVisitorsTable();
-
   bool HasLowYoungGenerationAllocationRate();
   bool HasLowOldGenerationAllocationRate();
   double YoungGenerationMutatorUtilization();
   double OldGenerationMutatorUtilization();
 
   void ReduceNewSpaceSize();
 
   bool TryFinalizeIdleIncrementalMarking(
       double idle_time_in_ms, size_t size_of_objects,
       size_t mark_compact_speed_in_bytes_per_ms);
@@ skipping 461 matching lines @@
 
   // Cumulative GC time spent in sweeping.
   double sweeping_time_;
 
   // Last time an idle notification happened.
   double last_idle_notification_time_;
 
   // Last time a garbage collection happened.
   double last_gc_time_;
 
+  Scavenger* scavenge_collector_;
+
   MarkCompactCollector mark_compact_collector_;
 
   StoreBuffer store_buffer_;
 
   IncrementalMarking incremental_marking_;
 
   GCIdleTimeHandler gc_idle_time_handler_;
 
   MemoryReducer* memory_reducer_;
 
@@ skipping 39 matching lines @@
 
   // Currently set GC flags that are respected by all GC components.
   int current_gc_flags_;
 
   // Currently set GC callback flags that are used to pass information between
   // the embedder and V8's GC.
   GCCallbackFlags current_gc_callback_flags_;
 
   ExternalStringTable external_string_table_;
 
-  VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
-
   MemoryChunk* chunks_queued_for_free_;
 
   size_t concurrent_unmapping_tasks_active_;
 
   base::Semaphore pending_unmapping_tasks_semaphore_;
 
   base::Mutex relocation_mutex_;
 
   int gc_callbacks_depth_;
 
   bool deserialization_complete_;
 
   bool concurrent_sweeping_enabled_;
 
   StrongRootsList* strong_roots_list_;
 
   ArrayBufferTracker* array_buffer_tracker_;
 
   // Classes in "heap" can be friends.
   friend class AlwaysAllocateScope;
   friend class GCCallbacksScope;
   friend class GCTracer;
   friend class HeapIterator;
   friend class IncrementalMarking;
   friend class MarkCompactCollector;
   friend class MarkCompactMarkingVisitor;
   friend class ObjectStatsVisitor;
   friend class Page;
+  friend class Scavenger;
   friend class StoreBuffer;
 
   // The allocator interface.
   friend class Factory;
 
   // The Isolate constructs us.
   friend class Isolate;
 
   // Used in cctest.
   friend class HeapTester;
@@ skipping 345 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_