Sweep pages with lowest live memory first.

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 2485 matching lines @@
 
 // You have to call this last, since the implementation from PagedSpace
 // doesn't know that memory was 'promised' to large object space.
 bool LargeObjectSpace::ReserveSpace(int bytes) {
   return heap()->OldGenerationCapacityAvailable() >= bytes &&
          (!heap()->incremental_marking()->IsStopped() ||
            heap()->OldGenerationSpaceAvailable() >= bytes);
 }
 
 
+intptr_t PagedSpace::SweepPageWithLowestLiveMemory() {
+  Page* p = first_unswept_page_;
+  Page* sweep_canditate = NULL;
+
+  while (p != anchor()) {
+    if (ShouldBeSweptLazily(p) && !p->WasSweptConservatively()) {
+      if (sweep_canditate == NULL ||
+          p->LiveBytes() < sweep_canditate->LiveBytes()) {
+        sweep_canditate = p;
+      }
+    }
+    p = p->next_page();
+  }
+
+  if (sweep_canditate != NULL) {
+    DecreaseUnsweptFreeBytes(sweep_canditate);
+    return MarkCompactCollector::
+        SweepConservatively<MarkCompactCollector::SWEEP_SEQUENTIALLY>(
+            this, NULL, sweep_canditate);
+  }
+  return 0;
+}
+
+
 bool PagedSpace::AdvanceSweeper(intptr_t bytes_to_sweep) {
   if (IsLazySweepingComplete()) return true;
 
-  intptr_t freed_bytes = 0;
+  intptr_t freed_bytes = SweepPageWithLowestLiveMemory();
+
   Page* p = first_unswept_page_;
-  do {
+  while (freed_bytes < bytes_to_sweep && p != anchor()) {
     Page* next_page = p->next_page();
-    if (ShouldBeSweptLazily(p)) {
+    if (ShouldBeSweptLazily(p) && !p->WasSweptConservatively()) {
       if (FLAG_gc_verbose) {
         PrintF("Sweeping 0x%" V8PRIxPTR " lazily advanced.\n",
                reinterpret_cast<intptr_t>(p));
       }
       DecreaseUnsweptFreeBytes(p);
       freed_bytes +=
           MarkCompactCollector::
               SweepConservatively<MarkCompactCollector::SWEEP_SEQUENTIALLY>(
                   this, NULL, p);
     }
     p = next_page;
-  } while (p != anchor() && freed_bytes < bytes_to_sweep);
+  }
 
   if (p == anchor()) {
     first_unswept_page_ = Page::FromAddress(NULL);
   } else {
     first_unswept_page_ = p;
   }
 
   heap()->FreeQueuedChunks();
 
   return IsLazySweepingComplete();
@@ skipping 596 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal