Make full GC reduce memory footprint an explicit event in the idle notification handler.

src/heap/gc-idle-time-handler.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/gc-tracer.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 21 matching lines @@
       if (additional_work) {
         PrintF("; finalized marking");
       }
       break;
     case DO_SCAVENGE:
       PrintF("scavenge");
       break;
     case DO_FULL_GC:
       PrintF("full GC");
       break;
+    case DO_FULL_GC_COMPACT:
+      PrintF("full GC compact");
+      break;
     case DO_FINALIZE_SWEEPING:
       PrintF("finalize sweeping");
       break;
   }
 }
 
 
 void GCIdleTimeHandler::HeapState::Print() {
   PrintF("contexts_disposed=%d ", contexts_disposed);
   PrintF("contexts_disposal_rate=%f ", contexts_disposal_rate);
@@ skipping 97 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 bool GCIdleTimeHandler::ShouldDoMarkCompact(
     size_t idle_time_in_ms, size_t size_of_objects,
     size_t mark_compact_speed_in_bytes_per_ms) {
-  return idle_time_in_ms >= kMaxScheduledIdleTime &&
-         idle_time_in_ms >=
-             EstimateMarkCompactTime(size_of_objects,
-                                     mark_compact_speed_in_bytes_per_ms);
+  return idle_time_in_ms >=
+         EstimateMarkCompactTime(size_of_objects,
+                                 mark_compact_speed_in_bytes_per_ms);
 }
 
 
+bool GCIdleTimeHandler::ShouldDoReduceMemoryMarkCompact(
+    size_t idle_time_in_ms) {
+  return idle_time_in_ms >= kMinTimeForReduceMemory;
+}
+
+
 bool GCIdleTimeHandler::ShouldDoContextDisposalMarkCompact(
     int contexts_disposed, double contexts_disposal_rate) {
   return contexts_disposed > 0 && contexts_disposal_rate > 0 &&
          contexts_disposal_rate < kHighContextDisposalRate;
 }
 
 
 bool GCIdleTimeHandler::ShouldDoFinalIncrementalMarkCompact(
     size_t idle_time_in_ms, size_t size_of_objects,
     size_t final_incremental_mark_compact_speed_in_bytes_per_ms) {
@@ skipping 24 matching lines @@
 
 // The following logic is implemented by the controller:
 // (1) If we don't have any idle time, do nothing, unless a context was
 // disposed, incremental marking is stopped, and the heap is small. Then do
 // a full GC.
 // (2) If the new space is almost full and we can afford a Scavenge or if the
 // next Scavenge will very likely take long, then a Scavenge is performed.
 // (3) If there is currently no MarkCompact idle round going on, we start a
 // new idle round if enough garbage was created. Otherwise we do not perform
 // garbage collection to keep system utilization low.
-// (4) If incremental marking is done, we perform a full garbage collection
-// if  we are allowed to still do full garbage collections during this idle
+// (4) If we have long idle time, we try to reduce the memory footprint.
+// (5) If incremental marking is done, we perform a full garbage collection
+// if we are allowed to still do full garbage collections during this idle
 // round or if we are not allowed to start incremental marking. Otherwise we
 // do not perform garbage collection to keep system utilization low.
-// (5) If sweeping is in progress and we received a large enough idle time
+// (6) If sweeping is in progress and we received a large enough idle time
 // request, we finalize sweeping here.
-// (6) If incremental marking is in progress, we perform a marking step. Note,
+// (7) If incremental marking is in progress, we perform a marking step. Note,
 // that this currently may trigger a full garbage collection.
 GCIdleTimeAction GCIdleTimeHandler::Compute(double idle_time_in_ms,
                                             HeapState heap_state) {
   if (static_cast<int>(idle_time_in_ms) <= 0) {
     if (heap_state.contexts_disposed > 0) {
       StartIdleRound();
     }
     if (heap_state.incremental_marking_stopped) {
       if (ShouldDoContextDisposalMarkCompact(
               heap_state.contexts_disposed,
@@ skipping 13 matching lines @@
   }
 
   if (IsMarkCompactIdleRoundFinished()) {
     if (EnoughGarbageSinceLastIdleRound()) {
       StartIdleRound();
     } else {
       return GCIdleTimeAction::Done();
     }
   }
 
+  if (ShouldDoReduceMemoryMarkCompact(static_cast<size_t>(idle_time_in_ms))) {
+    return GCIdleTimeAction::FullGCCompact();
+  }
+
   if (heap_state.incremental_marking_stopped) {
     if (ShouldDoMarkCompact(static_cast<size_t>(idle_time_in_ms),
                             heap_state.size_of_objects,
                             heap_state.mark_compact_speed_in_bytes_per_ms)) {
       return GCIdleTimeAction::FullGC();
     }
   }
   if (heap_state.sweeping_in_progress) {
     if (heap_state.sweeping_completed) {
       return GCIdleTimeAction::FinalizeSweeping();
     } else {
       return NothingOrDone();
     }
   }
   if (heap_state.incremental_marking_stopped &&
       !heap_state.can_start_incremental_marking) {
     return NothingOrDone();
   }
 
   size_t step_size = EstimateMarkingStepSize(
       static_cast<size_t>(kIncrementalMarkingStepTimeInMs),
       heap_state.incremental_marking_speed_in_bytes_per_ms);
   return GCIdleTimeAction::IncrementalMarking(step_size);
 }
 }
 }