[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::SwapFromSpacePageWithToSpacePage(Page* from_space_page) {
+  // The method is called when replacing a *to* space page with a *from* space
+  // page when moving a page within new space. Since there's still a full page
+  // to move (which would've been copied otherwise) *to* space cannot be
+  // on the last page.
+  DCHECK(!to_space_.OnLastPage());
+
+  Page* to_space_page = to_space_.anchor()->prev_page();
+  Page* from_space_page_prev_page = from_space_page->prev_page();
+  SwapPages(from_space_page, to_space_page, to_space_.anchor(),
+            from_space_page_prev_page);
+  // Since we removed an unused to space page but added a used one we need
+  // to increment the page counter.
+  pages_used_++;
+}
+
+void NewSpace::SwapPages(Page* from_space_page, Page* to_space_page,
+                         Page* from_target, Page* to_target) {
+  DCHECK(from_space_page->InFromSpace());
+  DCHECK(to_space_page->InToSpace());
+  to_space_page->Unlink();
+  from_space_page->Unlink();
+  // Swap owner.
+  to_space_page->set_owner(&from_space_);
+  from_space_page->set_owner(&to_space_);
+  // Swap flags.
+  intptr_t tmp_flags = to_space_page->GetFlags();
+  to_space_page->SetFlags(from_space_page->GetFlags(), Page::kCopyAllFlags);
+  from_space_page->SetFlags(tmp_flags, Page::kCopyAllFlags);
+  // Insert again.
+  to_space_page->InsertAfter(to_target);
+  from_space_page->InsertAfter(from_target);
+  DCHECK(to_space_page->InFromSpace());
+  DCHECK(from_space_page->InToSpace());
+  // Update current page of space.
+  if (from_space_.current_page() == from_space_page)
+    from_space_.current_page_ = to_space_page;
+  if (to_space_.current_page() == to_space_page)
+    to_space_.current_page_ = from_space_page;
+}
 
 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()));
@@ skipping 1821 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8