Implement shrinking of paged spaces during sweeping.

src/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 743 matching lines @@
   int count = 0;
   while (it.has_next()) {
     it.next();
     count++;
   }
   return count;
 }
 #endif
 
 
-void PagedSpace::Shrink() {
-  // TODO(1614) Not implemented.
+void PagedSpace::ReleasePage(Page* page) {
+  ASSERT(page->LiveBytes() == 0);
+  page->Unlink();
+  if (page->IsFlagSet(MemoryChunk::CONTAINS_ONLY_DATA)) {
+    heap()->isolate()->memory_allocator()->Free(page);
+  } else {
+    heap()->QueueMemoryChunkForFree(page);
+  }
+
+  ASSERT(Capacity() > 0);
+  ASSERT(Capacity() % Page::kObjectAreaSize == 0);
+  accounting_stats_.ShrinkSpace(Page::kObjectAreaSize);
 }
 
 
+void PagedSpace::ReleaseAllUnusedPages() {
+  PageIterator it(this);
+  while (it.has_next()) {
+    Page* page = it.next();
+    if (page->LiveBytes() == 0) {
+      ReleasePage(page);
+    }
+  }
+  heap()->FreeQueuedChunks();
+}
+
+
 #ifdef DEBUG
 void PagedSpace::Print() { }
 #endif
 
 
 #ifdef DEBUG
 void PagedSpace::Verify(ObjectVisitor* visitor) {
   // We can only iterate over the pages if they were swept precisely.
   if (was_swept_conservatively_) return;
 
@@ skipping 861 matching lines @@
 
 void FreeList::Reset() {
   available_ = 0;
   small_list_ = NULL;
   medium_list_ = NULL;
   large_list_ = NULL;
   huge_list_ = NULL;
 }
 
 
-int PagedSpace::FreeOrUnmapPage(Page* page, Address start, int size_in_bytes) {
-  Heap* heap = page->heap();
-  // TODO(gc): When we count the live bytes per page we can free empty pages
-  // instead of sweeping.  At that point this if should be turned into an
-  // ASSERT that the area to be freed cannot be the entire page.
-  if (size_in_bytes == Page::kObjectAreaSize &&
-      heap->ShouldWeGiveBackAPageToTheOS()) {
-    page->Unlink();
-    if (page->IsFlagSet(MemoryChunk::CONTAINS_ONLY_DATA)) {
-      heap->isolate()->memory_allocator()->Free(page);
-    } else {
-      heap->QueueMemoryChunkForFree(page);
-    }
-    return 0;
-  }
-  return Free(start, size_in_bytes);
-}
-
-
 int FreeList::Free(Address start, int size_in_bytes) {
   if (size_in_bytes == 0) return 0;
   FreeListNode* node = FreeListNode::FromAddress(start);
   node->set_size(heap_, size_in_bytes);
 
   // Early return to drop too-small blocks on the floor.
   if (size_in_bytes < kSmallListMin) return size_in_bytes;
 
   // Insert other blocks at the head of a free list of the appropriate
   // magnitude.
@@ skipping 232 matching lines @@
   // We don't have a linear allocation area while sweeping.  It will be restored
   // on the first allocation after the sweep.
   // Mark the old linear allocation area with a free space map so it can be
   // skipped when scanning the heap.
   int old_linear_size = static_cast<int>(limit() - top());
   Free(top(), old_linear_size);
   SetTop(NULL, NULL);
 
   // Stop lazy sweeping and clear marking bits for unswept pages.
   if (first_unswept_page_ != NULL) {
-    Page* last = last_unswept_page_->next_page();
+    Page* last = last_unswept_page_;
     Page* p = first_unswept_page_;
     do {
       // Do not use ShouldBeSweptLazily predicate here.
       // New evacuation candidates were selected but they still have
       // to be swept before collection starts.
       if (!p->WasSwept()) {
         Bitmap::Clear(p);
         if (FLAG_gc_verbose) {
           PrintF("Sweeping 0x%" V8PRIxPTR " lazily abandoned.\n",
                  reinterpret_cast<intptr_t>(p));
@@ skipping 36 matching lines @@
 // doesn't know that memory was 'promised' to large object space.
 bool LargeObjectSpace::ReserveSpace(int bytes) {
   return heap()->OldGenerationSpaceAvailable() >= bytes;
 }
 
 
 bool PagedSpace::AdvanceSweeper(intptr_t bytes_to_sweep) {
   if (IsSweepingComplete()) return true;
 
   intptr_t freed_bytes = 0;
-  Page* last = last_unswept_page_->next_page();
+  Page* last = last_unswept_page_;
   Page* p = first_unswept_page_;
   do {
     Page* next_page = p->next_page();
     if (ShouldBeSweptLazily(p)) {
       if (FLAG_gc_verbose) {
         PrintF("Sweeping 0x%" V8PRIxPTR " lazily advanced.\n",
                reinterpret_cast<intptr_t>(p));
       }
       freed_bytes += MarkCompactCollector::SweepConservatively(this, p);
     }
@@ skipping 524 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal