Revert of Make full GC reduce memory footprint an explicit event in the idle notification handler. (patchset #2 id:20001 of https://codereview.chromium.org/1072363002/)

Reason for revert:
[Sheriff] breaks nosnap with timeouts:
http://build.chromium.org/p/client.v8/builders/V8%20Linux%20-%20nosnap/builds/2513
http://build.chromium.org/p/client.v8/builders/V8%20Win32%20-%20nosnap%20-%20shared/builds/6220

Original issue's description:
> Make full GC reduce memory footprint an explicit event in the idle notification handler.
>
> BUG=
>
> Committed: https://crrev.com/845705aa99b6bfa8d264cfda1c3b5f1229802ab5
> Cr-Commit-Position: refs/heads/master@{#27753}

TBR=ulan@chromium.org,rmcilroy@chromium.org,hpayer@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=

Review URL: https://codereview.chromium.org/1081443002

Cr-Commit-Position: refs/heads/master@{#27755}

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

@@ -39,9 +39,6 @@ void GCIdleTimeAction::Print() {
     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;
@@ -159,15 +156,10 @@ bool GCIdleTimeHandler::ShouldDoScavenge(
 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 >=
-         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;
+  return idle_time_in_ms >= kMaxScheduledIdleTime &&
+         idle_time_in_ms >=
+             EstimateMarkCompactTime(size_of_objects,
+                                     mark_compact_speed_in_bytes_per_ms);
 }
 
 
@@ -215,14 +207,13 @@ GCIdleTimeAction GCIdleTimeHandler::NothingOrDone() {
 // (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 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
+// (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
 // round or if we are not allowed to start incremental marking. Otherwise we
 // do not perform garbage collection to keep system utilization low.
-// (6) If sweeping is in progress and we received a large enough idle time
+// (5) If sweeping is in progress and we received a large enough idle time
 // request, we finalize sweeping here.
-// (7) If incremental marking is in progress, we perform a marking step. Note,
+// (6) 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) {
@@ -256,10 +247,6 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(double idle_time_in_ms,
     }
   }
 
-  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,

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

@@ -16,7 +16,6 @@ enum GCIdleTimeActionType {
   DO_INCREMENTAL_MARKING,
   DO_SCAVENGE,
   DO_FULL_GC,
-  DO_FULL_GC_COMPACT,
   DO_FINALIZE_SWEEPING
 };
 
@@ -63,14 +62,6 @@ class GCIdleTimeAction {
     return result;
   }
 
-  static GCIdleTimeAction FullGCCompact() {
-    GCIdleTimeAction result;
-    result.type = DO_FULL_GC_COMPACT;
-    result.parameter = 0;
-    result.additional_work = false;
-    return result;
-  }
-
   static GCIdleTimeAction FinalizeSweeping() {
     GCIdleTimeAction result;
     result.type = DO_FINALIZE_SWEEPING;
@@ -131,10 +122,6 @@ class GCIdleTimeHandler {
   // 16 ms when there is currently no rendering going on.
   static const size_t kMaxScheduledIdleTime = 50;
 
-  // This is the minimum time needed to trigger a full garbage collection which
-  // tries to reduce memory footprint.
-  static const size_t kMinTimeForReduceMemory = 600;
-
   // We conservatively assume that in the next kTimeUntilNextIdleEvent ms
   // no idle notification happens.
   static const size_t kTimeUntilNextIdleEvent = 100;
@@ -208,8 +195,6 @@ class GCIdleTimeHandler {
                                   size_t size_of_objects,
                                   size_t mark_compact_speed_in_bytes_per_ms);
 
-  static bool ShouldDoReduceMemoryMarkCompact(size_t idle_time_in_ms);
-
   static bool ShouldDoContextDisposalMarkCompact(int context_disposed,
                                                  double contexts_disposal_rate);
 

src/heap/heap.cc

@@ -4502,15 +4502,14 @@ void Heap::MakeHeapIterable() {
 }
 
 
-void Heap::IdleMarkCompact(bool reduce_memory, const char* message) {
+void Heap::IdleMarkCompact(const char* message) {
   bool uncommit = false;
   if (gc_count_at_last_idle_gc_ == gc_count_) {
     // No GC since the last full GC, the mutator is probably not active.
     isolate_->compilation_cache()->Clear();
     uncommit = true;
   }
-  int flags = reduce_memory ? kReduceMemoryFootprintMask : kNoGCFlags;
-  CollectAllGarbage(flags, message);
+  CollectAllGarbage(kReduceMemoryFootprintMask, message);
   gc_idle_time_handler_.NotifyIdleMarkCompact();
   gc_count_at_last_idle_gc_ = gc_count_;
   if (uncommit) {
@@ -4642,14 +4641,10 @@ bool Heap::IdleNotification(double deadline_in_seconds) {
         gc_idle_time_handler_.NotifyIdleMarkCompact();
         gc_count_at_last_idle_gc_ = gc_count_;
       } else {
-        IdleMarkCompact(false, "idle notification: finalize idle round");
+        IdleMarkCompact("idle notification: finalize idle round");
       }
       break;
     }
-    case DO_FULL_GC_COMPACT: {
-      IdleMarkCompact(true, "idle notification: reduce memory footprint");
-      break;
-    }
     case DO_SCAVENGE:
       CollectGarbage(NEW_SPACE, "idle notification: scavenge");
       break;

src/heap/heap.h

@@ -2049,7 +2049,7 @@ class Heap {
 
   void SelectScavengingVisitorsTable();
 
-  void IdleMarkCompact(bool reduce_memory, const char* message);
+  void IdleMarkCompact(const char* message);
 
   bool TryFinalizeIdleIncrementalMarking(
       double idle_time_in_ms, size_t size_of_objects,

test/unittests/heap/gc-idle-time-handler-unittest.cc

@@ -516,18 +516,5 @@ TEST_F(GCIdleTimeHandlerTest, DoneIfNotMakingProgressOnIncrementalMarking) {
   EXPECT_EQ(DONE, action.type);
 }
 
-
-TEST_F(GCIdleTimeHandlerTest, ReduceMemory) {
-  GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
-  double idle_time = GCIdleTimeHandler::kMinTimeForReduceMemory;
-  for (int i = 0; i < GCIdleTimeHandler::kMaxMarkCompactsInIdleRound; i++) {
-    GCIdleTimeAction action = handler()->Compute(idle_time, heap_state);
-    EXPECT_EQ(DO_FULL_GC_COMPACT, action.type);
-    handler()->NotifyIdleMarkCompact();
-  }
-  GCIdleTimeAction action = handler()->Compute(idle_time, heap_state);
-  EXPECT_EQ(DONE, action.type);
-}
-
 }  // namespace internal
 }  // namespace v8