[heap] Minor MC: Add evacuation phase

src/heap/spaces.h

 // Copyright 2011 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_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include <list>
 #include <memory>
 #include <unordered_set>
@@ skipping 264 matching lines @@
 
     // |COMPACTION_WAS_ABORTED|: Indicates that the compaction in this page
     //   has been aborted and needs special handling by the sweeper.
     COMPACTION_WAS_ABORTED = 1u << 15,
 
     // |COMPACTION_WAS_ABORTED_FOR_TESTING|: During stress testing evacuation
     // on pages is sometimes aborted. The flag is used to avoid repeatedly
     // triggering on the same page.
     COMPACTION_WAS_ABORTED_FOR_TESTING = 1u << 16,
 
+    // |CANNOT_BE_VERIFIED|: Used for moved pages to indicate that these pages
+    // cannot be verified due to stale pointers in the body. Note that the
+    // objects can still be iterated over, as the size can be correctly
+    // obtained.
+    CANNOT_BE_VERIFIED = 1u << 17,
+
     // |ANCHOR|: Flag is set if page is an anchor.
     ANCHOR = 1u << 17,
   };
   typedef base::Flags<Flag, uintptr_t> Flags;
 
   static const int kPointersToHereAreInterestingMask =
       POINTERS_TO_HERE_ARE_INTERESTING;
 
   static const int kPointersFromHereAreInterestingMask =
       POINTERS_FROM_HERE_ARE_INTERESTING;
@@ skipping 1590 matching lines @@
   iterator end() { return range_.end(); }
 
  private:
   PageRange range_;
 };
 
 class PagedSpace : public Space {
  public:
   typedef PageIterator iterator;
 
+  // Reuse a page for allocation only if it has at least {kPageReuseThreshold}
+  // memory available in its freelist.
+  static const size_t kPageReuseThreshold = 4 * KB;
   static const intptr_t kCompactionMemoryWanted = 500 * KB;
 
   // Creates a space with an id.
   PagedSpace(Heap* heap, AllocationSpace id, Executability executable);
 
   ~PagedSpace() override { TearDown(); }
 
   // Set up the space using the given address range of virtual memory (from
   // the memory allocator's initial chunk) if possible.  If the block of
   // addresses is not big enough to contain a single page-aligned page, a
@@ skipping 192 matching lines @@
 
   iterator begin() { return iterator(anchor_.next_page()); }
   iterator end() { return iterator(&anchor_); }
 
   // Shrink immortal immovable pages of the space to be exactly the size needed
   // using the high water mark.
   void ShrinkImmortalImmovablePages();
 
   std::unique_ptr<ObjectIterator> GetObjectIterator() override;
 
+  // Removes a page from the space.
+  Page* RemovePageSafe();
+  void AddPage(Page* page);
+
  protected:
   // PagedSpaces that should be included in snapshots have different, i.e.,
   // smaller, initial pages.
   virtual bool snapshotable() { return true; }
 
   bool HasPages() { return anchor_.next_page() != &anchor_; }
 
   // Cleans up the space, frees all pages in this space except those belonging
   // to the initial chunk, uncommits addresses in the initial chunk.
   void TearDown();
@@ skipping 799 matching lines @@
   PageIterator old_iterator_;
   PageIterator code_iterator_;
   PageIterator map_iterator_;
   LargePageIterator lo_iterator_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_