If a large object is truncated, also truncate the page.

runtime/vm/pages.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 164 matching lines @@
   page->set_next(large_pages_);
   large_pages_ = page;
   usage_.capacity_in_words += page_size_in_words;
   // Only one object in this page (at least until String::MakeExternal or
   // Array::MakeArray is called).
   page->set_object_end(page->object_start() + size);
   return page;
 }
 
 
+void PageSpace::TruncateLargePage(HeapPage* page,
+                                  intptr_t new_object_size_in_bytes) {
+  const intptr_t old_object_size_in_bytes =
+      page->object_end() - page->object_start();
+  ASSERT(new_object_size_in_bytes < old_object_size_in_bytes);
+  const intptr_t new_page_size_in_words =
+      LargePageSizeInWordsFor(new_object_size_in_bytes);
+  VirtualMemory* memory = page->memory_;
+  const intptr_t old_page_size_in_words = (memory->size() >> kWordSizeLog2);
+  memory->Truncate(memory->start(), (new_page_size_in_words << kWordSizeLog2));
+  usage_.capacity_in_words -= old_page_size_in_words;
+  usage_.capacity_in_words += new_page_size_in_words;
+  page->set_object_end(page->object_start() + new_object_size_in_bytes);
+}
+
+
 void PageSpace::FreePage(HeapPage* page, HeapPage* previous_page) {
   usage_.capacity_in_words -= (page->memory_->size() >> kWordSizeLog2);
   // Remove the page from the list.
   if (previous_page != NULL) {
     previous_page->set_next(page->next());
   } else {
     pages_ = page->next();
   }
   if (page == pages_tail_) {
     pages_tail_ = previous_page;
@@ skipping 336 matching lines @@
     // Advance to the next page.
     page = next_page;
   }
 
   int64_t mid3 = OS::GetCurrentTimeMicros();
 
   prev_page = NULL;
   page = large_pages_;
   while (page != NULL) {
     HeapPage* next_page = page->next();
-    bool page_in_use = sweeper.SweepLargePage(page);
-    if (page_in_use) {
+    const intptr_t bytes_to_end = sweeper.SweepLargePage(page);
+    if (bytes_to_end == 0) {
+      FreeLargePage(page, prev_page);
+    } else {
+      if (bytes_to_end < (page->object_end() - page->object_start())) {

[Ivan Posva, 2014/06/30 05:51:05]

I am wondering whether we want to move the logic here into TruncateLargePage by
checking whether the the old page size and new page size differ.

[koda, 2014/06/30 22:57:49]

Done.

+        TruncateLargePage(page, bytes_to_end);
+      }
       prev_page = page;
-    } else {
-      FreeLargePage(page, prev_page);
     }
     // Advance to the next page.
     page = next_page;
   }
 
   // Make code pages read-only.
   WriteProtectCode(true);
 
   int64_t end = OS::GetCurrentTimeMicros();
 
@@ skipping 139 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart