Adapt fragmentation heuristics for over reserved pages.

src/mark-compact.cc

Index: src/mark-compact.cc
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 67f6e8e0a7556c89a1f5162ac441ec3da5b4a1c4..5789b5ffcc312a6026d5f5a8db7dfb0f82092050 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -500,12 +500,10 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
          space->identity() == OLD_DATA_SPACE ||
          space->identity() == CODE_SPACE);
 
-  int number_of_pages = space->CountTotalPages();
-
   const int kMaxMaxEvacuationCandidates = 1000;
-  int max_evacuation_candidates = Min(
-    kMaxMaxEvacuationCandidates,
-    static_cast<int>(sqrt(static_cast<double>(number_of_pages / 2)) + 1));
+  int number_of_pages = space->CountTotalPages();
+  int max_evacuation_candidates =
+      static_cast<int>(sqrt(static_cast<double>(number_of_pages / 2)) + 1);
 
   if (FLAG_stress_compaction || FLAG_always_compact) {
     max_evacuation_candidates = kMaxMaxEvacuationCandidates;
@@ -533,20 +531,33 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
 
   intptr_t reserved = number_of_pages * space->AreaSize();
   intptr_t over_reserved = reserved - space->SizeOfObjects();
-  static const intptr_t kFreenessThreshold = 50;
+  intptr_t freeness_threshold = 100;
+
+  if (over_reserved >= 2 * space->AreaSize()) {
 
-  if (over_reserved >= 2 * space->AreaSize() &&
-      reduce_memory_footprint_) {
-    mode = REDUCE_MEMORY_FOOTPRINT;
+    // If reduction of memory footprint was requested, we are aggressive
+    // about choosing pages to free.  We expect that halve empty pages

[Erik Corry, 2012/06/22 08:52:54]

halve empty -> half-empty

[Michael Starzinger, 2012/06/22 09:14:23]

Done.

+    // are easier to compact so slightly bump the limit.
+    if (reduce_memory_footprint_) {
+      mode = REDUCE_MEMORY_FOOTPRINT;
+      freeness_threshold = 50;
+      max_evacuation_candidates += 2;
+    }
 
-    // We expect that empty pages are easier to compact so slightly bump the
-    // limit.
-    max_evacuation_candidates += 2;
+    // If over-usage is very high (more than a third of the space), we
+    // try to free all mostly empty pages.  We expect that empty pages

[Erik Corry, 2012/06/22 08:52:54]

that empty pages -> that almost empty pages
?

[Michael Starzinger, 2012/06/22 09:14:23]

Done.

+    // are even easier to compact so bump the limit even more.
+    if (over_reserved > reserved / 3) {
+      mode = REDUCE_MEMORY_FOOTPRINT;
+      freeness_threshold = 80;

[Erik Corry, 2012/06/22 08:52:54]

I think we shouldn't set this so high.  We might have 1/3 over-allocation and no
pages are 80% free, but that shouldn't exclude them all from consideration.  We
pick the best 'n' below anyway.

[Michael Starzinger, 2012/06/22 09:14:23]

Done. Reverted it back to a constant of 50 like before. Less magic constants.

+      max_evacuation_candidates *= 2;
+    }
 
-    if (FLAG_trace_fragmentation) {
-      PrintF("Estimated over reserved memory: %.1f MB (setting threshold %d)\n",
+    if (FLAG_trace_fragmentation && mode == REDUCE_MEMORY_FOOTPRINT) {
+      PrintF("Estimated over reserved memory: %.1f / %.1f MB (threshold %d)\n",
              static_cast<double>(over_reserved) / MB,
-             static_cast<int>(kFreenessThreshold));
+             static_cast<double>(reserved) / MB,
+             static_cast<int>(freeness_threshold));
     }
   }
 
@@ -554,6 +565,9 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
 
   Candidate candidates[kMaxMaxEvacuationCandidates];
 
+  max_evacuation_candidates =
+      Min(kMaxMaxEvacuationCandidates, max_evacuation_candidates);
+
   int count = 0;
   int fragmentation = 0;
   Candidate* least = NULL;
@@ -587,7 +601,7 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
 
       int free_pct = static_cast<int>(free_bytes * 100) / p->area_size();
 
-      if (free_pct >= kFreenessThreshold) {
+      if (free_pct >= freeness_threshold) {
         estimated_release += 2 * p->area_size() - free_bytes;
         fragmentation = free_pct;
       } else {