Revert of [heap] Add page evacuation mode for new->new

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 "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/semaphore.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 1368 matching lines @@
     DeleteArray(promoted_histogram_);
     promoted_histogram_ = NULL;
   }
 
   allocation_info_.Reset(nullptr, nullptr);
 
   to_space_.TearDown();
   from_space_.TearDown();
 }
 
+
 void NewSpace::Flip() { SemiSpace::Swap(&from_space_, &to_space_); }
 
 
 void NewSpace::Grow() {
   // Double the semispace size but only up to maximum capacity.
   DCHECK(TotalCapacity() < MaximumCapacity());
   int new_capacity =
       Min(MaximumCapacity(),
           FLAG_semi_space_growth_factor * static_cast<int>(TotalCapacity()));
   if (to_space_.GrowTo(new_capacity)) {
@@ skipping 25 matching lines @@
       if (!to_space_.GrowTo(from_space_.current_capacity())) {
         // We are in an inconsistent state because we could not
         // commit/uncommit memory from new space.
         CHECK(false);
       }
     }
   }
   DCHECK_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
-bool NewSpace::Rebalance() {
-  CHECK(heap()->promotion_queue()->is_empty());
-  // Order here is important to make use of the page pool.
-  return to_space_.EnsureCurrentCapacity() &&
-         from_space_.EnsureCurrentCapacity();
-}
-
-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.
-        DCHECK_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());
-      if (current_page == nullptr) return false;
-      DCHECK_NOT_NULL(current_page);
-      current_page->InsertAfter(anchor());
-      Bitmap::Clear(current_page);
-      current_page->SetFlags(anchor()->prev_page()->GetFlags(),
-                             Page::kCopyAllFlags);
-      heap()->CreateFillerObjectAt(current_page->area_start(),
-                                   current_page->area_size(),
-                                   ClearRecordedSlots::kNo);
-    }
-  }
-  return true;
-}
 
 void LocalAllocationBuffer::Close() {
   if (IsValid()) {
     heap_->CreateFillerObjectAt(
         allocation_info_.top(),
         static_cast<int>(allocation_info_.limit() - allocation_info_.top()),
         ClearRecordedSlots::kNo);
   }
 }
 
@@ skipping 422 matching lines @@
            page->IsFlagSet(MemoryChunk::IN_FROM_SPACE));
   }
 }
 
 
 void SemiSpace::Reset() {
   DCHECK_NE(anchor_.next_page(), &anchor_);
   current_page_ = anchor_.next_page();
 }
 
-void SemiSpace::RemovePage(Page* page) {
-  if (current_page_ == page) {
-    current_page_ = page->prev_page();
-  }
-  page->Unlink();
-}
-
-void SemiSpace::PrependPage(Page* page) {
-  page->SetFlags(current_page()->GetFlags(), Page::kCopyAllFlags);
-  page->set_owner(this);
-  page->InsertAfter(anchor());
+bool SemiSpace::ReplaceWithEmptyPage(Page* old_page) {
+  // TODO(mlippautz): We do not have to get a new page here when the semispace
+  // is uncommitted later on.
+  Page* new_page = heap()->memory_allocator()->AllocatePage(
+      Page::kAllocatableMemory, this, executable());
+  if (new_page == nullptr) return false;
+  Bitmap::Clear(new_page);
+  new_page->SetFlags(old_page->GetFlags(), Page::kCopyAllFlags);
+  new_page->set_next_page(old_page->next_page());
+  new_page->set_prev_page(old_page->prev_page());
+  old_page->next_page()->set_prev_page(new_page);
+  old_page->prev_page()->set_next_page(new_page);
+  heap()->CreateFillerObjectAt(new_page->area_start(), new_page->area_size(),
+                               ClearRecordedSlots::kNo);
+  return true;
 }
 
 void SemiSpace::Swap(SemiSpace* from, SemiSpace* to) {
   // 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_.
@@ skipping 1318 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8