Revert of [heap] Remove border page

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 216 matching lines @@
 // It is divided into the header and the body. Chunk start is always
 // 1MB aligned. Start of the body is aligned so it can accommodate
 // any heap object.
 class MemoryChunk {
  public:
   enum Flag {
     NO_FLAGS = 0u,
     IS_EXECUTABLE = 1u << 0,
     POINTERS_TO_HERE_ARE_INTERESTING = 1u << 1,
     POINTERS_FROM_HERE_ARE_INTERESTING = 1u << 2,
-
     // A page in new space has one of the next to flags set.
     IN_FROM_SPACE = 1u << 3,
     IN_TO_SPACE = 1u << 4,
-    // |IN_INTERMEDIATE_GENERATION|: Flag indicates whether this page contains
-    // objects that have already been copied once.
-    IN_INTERMEDIATE_GENERATION = 1u << 5,
-
+    NEW_SPACE_BELOW_AGE_MARK = 1u << 5,
     EVACUATION_CANDIDATE = 1u << 6,
     NEVER_EVACUATE = 1u << 7,
 
     // Large objects can have a progress bar in their page header. These object
     // are scanned in increments and will be kept black while being scanned.
     // Even if the mutator writes to them they will be kept black and a white
     // to grey transition is performed in the value.
     HAS_PROGRESS_BAR = 1u << 8,
 
     // |PAGE_NEW_OLD_PROMOTION|: A page tagged with this flag has been promoted
@@ skipping 301 matching lines @@
   Executability executable() {
     return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
   }
 
   bool InNewSpace() { return (flags_ & kIsInNewSpaceMask) != 0; }
 
   bool InToSpace() { return IsFlagSet(IN_TO_SPACE); }
 
   bool InFromSpace() { return IsFlagSet(IN_FROM_SPACE); }
 
-  bool InIntermediateGeneration() {
-    return IsFlagSet(IN_INTERMEDIATE_GENERATION);
-  }
-
   MemoryChunk* next_chunk() { return next_chunk_.Value(); }
 
   MemoryChunk* prev_chunk() { return prev_chunk_.Value(); }
 
   void set_next_chunk(MemoryChunk* next) { next_chunk_.SetValue(next); }
 
   void set_prev_chunk(MemoryChunk* prev) { prev_chunk_.SetValue(prev); }
 
   Space* owner() const {
     if ((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
@@ skipping 1645 matching lines @@
  public:
   typedef PageIterator iterator;
 
   static void Swap(SemiSpace* from, SemiSpace* to);
 
   SemiSpace(Heap* heap, SemiSpaceId semispace)
       : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
         current_capacity_(0),
         maximum_capacity_(0),
         minimum_capacity_(0),
+        age_mark_(nullptr),
         committed_(false),
         id_(semispace),
         anchor_(this),
         current_page_(nullptr),
         pages_used_(0) {}
 
   inline bool Contains(HeapObject* o);
   inline bool Contains(Object* o);
   inline bool ContainsSlow(Address a);
 
@@ skipping 48 matching lines @@
     pages_used_++;
     return true;
   }
 
   // Resets the space to using the first page.
   void Reset();
 
   void RemovePage(Page* page);
   void PrependPage(Page* page);
 
+  // Age mark accessors.
+  Address age_mark() { return age_mark_; }
+  void set_age_mark(Address mark);
+
   // Returns the current capacity of the semispace.
   int current_capacity() { return current_capacity_; }
 
   // Returns the maximum capacity of the semispace.
   int maximum_capacity() { return maximum_capacity_; }
 
   // Returns the initial capacity of the semispace.
   int minimum_capacity() { return minimum_capacity_; }
 
   SemiSpaceId id() { return id_; }
@@ skipping 46 matching lines @@
   // The currently committed space capacity.
   int current_capacity_;
 
   // The maximum capacity that can be used by this space. A space cannot grow
   // beyond that size.
   int maximum_capacity_;
 
   // The minimum capacity for the space. A space cannot shrink below this size.
   int minimum_capacity_;
 
+  // Used to govern object promotion during mark-compact collection.
+  Address age_mark_;
+
   bool committed_;
   SemiSpaceId id_;
 
   Page anchor_;
   Page* current_page_;
   int pages_used_;
 
   friend class NewSpace;
   friend class SemiSpaceIterator;
 };
@@ skipping 30 matching lines @@
  public:
   typedef PageIterator iterator;
 
   explicit NewSpace(Heap* heap)
       : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
         to_space_(heap, kToSpace),
         from_space_(heap, kFromSpace),
         reservation_(),
         top_on_previous_step_(0),
         allocated_histogram_(nullptr),
-        promoted_histogram_(nullptr),
-        fragmentation_in_intermediate_generation_(0) {}
+        promoted_histogram_(nullptr) {}
 
   inline bool Contains(HeapObject* o);
   inline bool ContainsSlow(Address a);
   inline bool Contains(Object* o);
 
   bool SetUp(int initial_semispace_capacity, int max_semispace_capacity);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
@@ skipping 12 matching lines @@
 
   // Shrink the capacity of the semispaces.
   void Shrink();
 
   // Return the allocated bytes in the active semispace.
   intptr_t Size() override {
     return to_space_.pages_used() * Page::kAllocatableMemory +
            static_cast<int>(top() - to_space_.page_low());
   }
 
-  intptr_t SizeOfObjects() override {
-    return Size() -
-           static_cast<intptr_t>(fragmentation_in_intermediate_generation_);
-  }
-
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the allocatable capacity of a semispace.
   intptr_t Capacity() {
     SLOW_DCHECK(to_space_.current_capacity() == from_space_.current_capacity());
     return (to_space_.current_capacity() / Page::kPageSize) *
            Page::kAllocatableMemory;
@@ skipping 16 matching lines @@
     return from_space_.MaximumCommittedMemory() +
            to_space_.MaximumCommittedMemory();
   }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory() override;
 
   // Return the available bytes without growing.
   intptr_t Available() override { return Capacity() - Size(); }
 
-  inline size_t AllocatedSinceLastGC();
+  size_t AllocatedSinceLastGC() {
+    bool seen_age_mark = false;
+    Address age_mark = to_space_.age_mark();
+    Page* current_page = to_space_.first_page();
+    Page* age_mark_page = Page::FromAddress(age_mark);
+    Page* last_page = Page::FromAddress(top() - kPointerSize);
+    if (age_mark_page == last_page) {
+      if (top() - age_mark >= 0) {
+        return top() - age_mark;
+      }
+      // Top was reset at some point, invalidating this metric.
+      return 0;
+    }
+    while (current_page != last_page) {
+      if (current_page == age_mark_page) {
+        seen_age_mark = true;
+        break;
+      }
+      current_page = current_page->next_page();
+    }
+    if (!seen_age_mark) {
+      // Top was reset at some point, invalidating this metric.
+      return 0;
+    }
+    intptr_t allocated = age_mark_page->area_end() - age_mark;
+    DCHECK_EQ(current_page, age_mark_page);
+    current_page = age_mark_page->next_page();
+    while (current_page != last_page) {
+      allocated += Page::kAllocatableMemory;
+      current_page = current_page->next_page();
+    }
+    allocated += top() - current_page->area_start();
+    DCHECK_LE(0, allocated);
+    DCHECK_LE(allocated, Size());
+    return static_cast<size_t>(allocated);
+  }
 
   void MovePageFromSpaceToSpace(Page* page) {
     DCHECK(page->InFromSpace());
     from_space_.RemovePage(page);
     to_space_.PrependPage(page);
   }
 
   bool Rebalance();
 
   // Return the maximum capacity of a semispace.
@@ skipping 18 matching lines @@
 
   // Return the address of the allocation pointer limit in the active semispace.
   Address limit() {
     DCHECK(to_space_.current_page()->ContainsLimit(allocation_info_.limit()));
     return allocation_info_.limit();
   }
 
   // Return the address of the first object in the active semispace.
   Address bottom() { return to_space_.space_start(); }
 
-  // Seal the intermediate generation of the active semispace.
-  void SealIntermediateGeneration();
+  // Get the age mark of the inactive semispace.
+  Address age_mark() { return from_space_.age_mark(); }
+  // Set the age mark in the active semispace.
+  void set_age_mark(Address mark) { to_space_.set_age_mark(mark); }
 
   // The allocation top and limit address.
   Address* allocation_top_address() { return allocation_info_.top_address(); }
 
   // The allocation limit address.
   Address* allocation_limit_address() {
     return allocation_info_.limit_address();
   }
 
   MUST_USE_RESULT INLINE(AllocationResult AllocateRawAligned(
       int size_in_bytes, AllocationAlignment alignment));
 
   MUST_USE_RESULT INLINE(
       AllocationResult AllocateRawUnaligned(int size_in_bytes));
 
   MUST_USE_RESULT INLINE(AllocationResult AllocateRaw(
       int size_in_bytes, AllocationAlignment alignment));
 
   MUST_USE_RESULT inline AllocationResult AllocateRawSynchronized(
       int size_in_bytes, AllocationAlignment alignment);
 
   // Reset the allocation pointer to the beginning of the active semispace.
   void ResetAllocationInfo();
 
-  void SetAllocationInfo(Address top, Address limit) {
-    allocation_info_.Reset(top, limit);
-  }
-
   // When inline allocation stepping is active, either because of incremental
   // marking, idle scavenge, or allocation statistics gathering, we 'interrupt'
   // inline allocation every once in a while. This is done by setting
   // allocation_info_.limit to be lower than the actual limit and and increasing
   // it in steps to guarantee that the observers are notified periodically.
   void UpdateInlineAllocationLimit(int size_in_bytes);
 
   void DisableInlineAllocationSteps() {
     top_on_previous_step_ = 0;
     UpdateInlineAllocationLimit(0);
@@ skipping 88 matching lines @@
 
   // Allocation pointer and limit for normal allocation and allocation during
   // mark-compact collection.
   AllocationInfo allocation_info_;
 
   Address top_on_previous_step_;
 
   HistogramInfo* allocated_histogram_;
   HistogramInfo* promoted_histogram_;
 
-  size_t fragmentation_in_intermediate_generation_;
-
   bool EnsureAllocation(int size_in_bytes, AllocationAlignment alignment);
 
   // If we are doing inline allocation in steps, this method performs the 'step'
   // operation. top is the memory address of the bump pointer at the last
   // inline allocation (i.e. it determines the numbers of bytes actually
   // allocated since the last step.) new_top is the address of the bump pointer
   // where the next byte is going to be allocated from. top and new_top may be
   // different when we cross a page boundary or reset the space.
   void InlineAllocationStep(Address top, Address new_top, Address soon_object,
                             size_t size);
@@ skipping 234 matching lines @@
   PageIterator old_iterator_;
   PageIterator code_iterator_;
   PageIterator map_iterator_;
   LargePageIterator lo_iterator_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_