Adapt fragmentation heuristics for over reserved pages.

src/mark-compact.cc

 // Copyright 2012 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 482 matching lines @@
 
   return static_cast<int>(ratio - ratio_threshold);
 }
 
 
 void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
   ASSERT(space->identity() == OLD_POINTER_SPACE ||
          space->identity() == OLD_DATA_SPACE ||
          space->identity() == CODE_SPACE);
 
+  const int kMaxMaxEvacuationCandidates = 1000;
   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 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;
   }
 
   class Candidate {
    public:
     Candidate() : fragmentation_(0), page_(NULL) { }
     Candidate(int f, Page* p) : fragmentation_(f), page_(p) { }
 
     int fragmentation() { return fragmentation_; }
     Page* page() { return page_; }
 
    private:
     int fragmentation_;
     Page* page_;
   };
 
   enum CompactionMode {
     COMPACT_FREE_LISTS,
     REDUCE_MEMORY_FOOTPRINT
   };
 
   CompactionMode mode = COMPACT_FREE_LISTS;
 
   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() &&
-      reduce_memory_footprint_) {
-    mode = REDUCE_MEMORY_FOOTPRINT;
+  if (over_reserved >= 2 * space->AreaSize()) {
 
-    // We expect that empty pages are easier to compact so slightly bump the
-    // limit.
-    max_evacuation_candidates += 2;
+    // 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;
+    }
 
-    if (FLAG_trace_fragmentation) {
-      PrintF("Estimated over reserved memory: %.1f MB (setting threshold %d)\n",
+    // 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 && 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));
     }
   }
 
   intptr_t estimated_release = 0;
 
   Candidate candidates[kMaxMaxEvacuationCandidates];
 
+  max_evacuation_candidates =
+      Min(kMaxMaxEvacuationCandidates, max_evacuation_candidates);
+
   int count = 0;
   int fragmentation = 0;
   Candidate* least = NULL;
 
   PageIterator it(space);
   if (it.has_next()) it.next();  // Never compact the first page.
 
   while (it.has_next()) {
     Page* p = it.next();
     p->ClearEvacuationCandidate();
@@ skipping 13 matching lines @@
       if (!p->WasSwept()) {
         free_bytes = (p->area_size() - p->LiveBytes());
       } else {
         FreeList::SizeStats sizes;
         space->CountFreeListItems(p, &sizes);
         free_bytes = sizes.Total();
       }
 
       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 {
         fragmentation = 0;
       }
 
       if (FLAG_trace_fragmentation) {
         PrintF("%p [%s]: %d (%.2f%%) free %s\n",
                reinterpret_cast<void*>(p),
                AllocationSpaceName(space->identity()),
@@ skipping 3518 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal