[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(initial_semispace_capacity <= maximum_semispace_capacity);
+  DCHECK_LE(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();
-        // Make sure we don't overtake the actual top pointer.
-        CHECK_NE(to_remove, current_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());
+        }
         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::NEW_SPACE_BELOW_AGE_MARK);
+      page->ClearFlag(MemoryChunk::IN_INTERMEDIATE_GENERATION);
       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();
 
-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);
+  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_);
   }
 }
 
-
 #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