Revert of [heap] Remove border page

src/heap/spaces.cc

 // 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.
 
 #include "src/heap/spaces.h"
 
 #include <utility>
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
@@ skipping 1466 matching lines @@
   }
   CHECK(allocation_pointer_found_in_space);
 }
 #endif  // VERIFY_HEAP
 
 // -----------------------------------------------------------------------------
 // NewSpace implementation
 
 bool NewSpace::SetUp(int initial_semispace_capacity,
                      int maximum_semispace_capacity) {
-  DCHECK_LE(initial_semispace_capacity, maximum_semispace_capacity);
+  DCHECK(initial_semispace_capacity <= maximum_semispace_capacity);
   DCHECK(base::bits::IsPowerOfTwo32(maximum_semispace_capacity));
-  DCHECK_GE(initial_semispace_capacity, 2 * Page::kPageSize);
 
   to_space_.SetUp(initial_semispace_capacity, maximum_semispace_capacity);
   from_space_.SetUp(initial_semispace_capacity, maximum_semispace_capacity);
   if (!to_space_.Commit()) {
     return false;
   }
   DCHECK(!from_space_.is_committed());  // No need to use memory yet.
   ResetAllocationInfo();
 
   // Allocate and set up the histogram arrays if necessary.
@@ skipping 80 matching lines @@
 bool SemiSpace::EnsureCurrentCapacity() {
   if (is_committed()) {
     const int expected_pages = current_capacity_ / Page::kPageSize;
     int actual_pages = 0;
     Page* current_page = anchor()->next_page();
     while (current_page != anchor()) {
       actual_pages++;
       current_page = current_page->next_page();
       if (actual_pages > expected_pages) {
         Page* to_remove = current_page->prev_page();
-        if (to_remove == current_page_) {
-          // Corner case: All pages have been moved within new space. We are
-          // removing the page that contains the top pointer and need to set
-          // it to the end of the intermediate generation.
-          NewSpace* new_space = heap()->new_space();
-          CHECK_EQ(new_space->top(), current_page_->area_start());
-          current_page_ = to_remove->prev_page();
-          CHECK(current_page_->InIntermediateGeneration());
-          new_space->SetAllocationInfo(page_high(), page_high());
-        }
+        // Make sure we don't overtake the actual top pointer.
+        CHECK_NE(to_remove, current_page_);
         to_remove->Unlink();
         heap()->memory_allocator()->Free<MemoryAllocator::kPooledAndQueue>(
             to_remove);
       }
     }
     while (actual_pages < expected_pages) {
       actual_pages++;
       current_page =
           heap()->memory_allocator()->AllocatePage<MemoryAllocator::kPooled>(
               Page::kAllocatableMemory, this, executable());
@@ skipping 305 matching lines @@
             Page::kAllocatableMemory, this, executable());
     if (new_page == nullptr) {
       RewindPages(current, pages_added);
       return false;
     }
     new_page->InsertAfter(current);
     current = new_page;
   }
   Reset();
   AccountCommitted(current_capacity_);
+  if (age_mark_ == nullptr) {
+    age_mark_ = first_page()->area_start();
+  }
   committed_ = true;
   return true;
 }
 
 
 bool SemiSpace::Uncommit() {
   DCHECK(is_committed());
   for (auto it = begin(); it != end();) {
     Page* p = *(it++);
     heap()->memory_allocator()->Free<MemoryAllocator::kPooledAndQueue>(p);
@@ skipping 91 matching lines @@
   anchor_.set_owner(this);
   anchor_.prev_page()->set_next_page(&anchor_);
   anchor_.next_page()->set_prev_page(&anchor_);
 
   for (Page* page : *this) {
     page->set_owner(this);
     page->SetFlags(flags, mask);
     if (id_ == kToSpace) {
       page->ClearFlag(MemoryChunk::IN_FROM_SPACE);
       page->SetFlag(MemoryChunk::IN_TO_SPACE);
-      page->ClearFlag(MemoryChunk::IN_INTERMEDIATE_GENERATION);
+      page->ClearFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
       page->ResetLiveBytes();
     } else {
       page->SetFlag(MemoryChunk::IN_FROM_SPACE);
       page->ClearFlag(MemoryChunk::IN_TO_SPACE);
     }
     DCHECK(page->IsFlagSet(MemoryChunk::IN_TO_SPACE) ||
            page->IsFlagSet(MemoryChunk::IN_FROM_SPACE));
   }
 }
 
@@ skipping 22 matching lines @@
   // We won't be swapping semispaces without data in them.
   DCHECK_NE(from->anchor_.next_page(), &from->anchor_);
   DCHECK_NE(to->anchor_.next_page(), &to->anchor_);
 
   intptr_t saved_to_space_flags = to->current_page()->GetFlags();
 
   // We swap all properties but id_.
   std::swap(from->current_capacity_, to->current_capacity_);
   std::swap(from->maximum_capacity_, to->maximum_capacity_);
   std::swap(from->minimum_capacity_, to->minimum_capacity_);
+  std::swap(from->age_mark_, to->age_mark_);
   std::swap(from->committed_, to->committed_);
   std::swap(from->anchor_, to->anchor_);
   std::swap(from->current_page_, to->current_page_);
 
   to->FixPagesFlags(saved_to_space_flags, Page::kCopyOnFlipFlagsMask);
   from->FixPagesFlags(0, 0);
 }
 
-void NewSpace::SealIntermediateGeneration() {
-  fragmentation_in_intermediate_generation_ = 0;
-  const Address mark = top();
 
-  if (mark == to_space_.space_start()) {
-    // Do not mark any pages as being part of the intermediate generation if no
-    // objects got moved.
-    return;
-  }
-
-  for (Page* p : NewSpacePageRange(to_space_.space_start(), mark)) {
-    p->SetFlag(MemoryChunk::IN_INTERMEDIATE_GENERATION);
-  }
-
-  Page* p = Page::FromAllocationAreaAddress(mark);
-  if (mark < p->area_end()) {
-    heap()->CreateFillerObjectAt(mark, static_cast<int>(p->area_end() - mark),
-                                 ClearRecordedSlots::kNo);
-    fragmentation_in_intermediate_generation_ =
-        static_cast<size_t>(p->area_end() - mark);
-    DCHECK_EQ(to_space_.current_page(), p);
-    if (to_space_.AdvancePage()) {
-      UpdateAllocationInfo();
-    } else {
-      allocation_info_.Reset(to_space_.page_high(), to_space_.page_high());
-    }
-  }
-  if (FLAG_trace_gc_verbose) {
-    PrintIsolate(heap()->isolate(),
-                 "Sealing intermediate generation: bytes_lost=%zu\n",
-                 fragmentation_in_intermediate_generation_);
+void SemiSpace::set_age_mark(Address mark) {
+  DCHECK_EQ(Page::FromAllocationAreaAddress(mark)->owner(), this);
+  age_mark_ = mark;
+  // Mark all pages up to the one containing mark.
+  for (Page* p : NewSpacePageRange(space_start(), mark)) {
+    p->SetFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
   }
 }
 
+
 #ifdef DEBUG
 void SemiSpace::Print() {}
 #endif
 
 #ifdef VERIFY_HEAP
 void SemiSpace::Verify() {
   bool is_from_space = (id_ == kFromSpace);
   Page* page = anchor_.next_page();
   CHECK(anchor_.owner() == this);
   while (page != &anchor_) {
@@ skipping 1132 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8