Shrink new space and uncommit from space in idle notification during long idle times.

src/heap/heap.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 4486 matching lines @@
   if (!IsHeapIterable()) {
     CollectAllGarbage(kMakeHeapIterableMask, "Heap::MakeHeapIterable");
   }
   if (mark_compact_collector()->sweeping_in_progress()) {
     mark_compact_collector()->EnsureSweepingCompleted();
   }
   DCHECK(IsHeapIterable());
 }
 
 
-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;
-  }
-  CollectAllGarbage(kReduceMemoryFootprintMask, message);
-  gc_idle_time_handler_.NotifyIdleMarkCompact();
-  gc_count_at_last_idle_gc_ = gc_count_;
-  if (uncommit) {
+void Heap::ReduceNewSpaceSize(bool long_idle_time) {

[rmcilroy, 2015/04/28 11:19:09]

nit - would be clearer as is_long_idle_notification

[Hannes Payer (out of office), 2015/04/28 11:27:47]

Done.

+  if (long_idle_time) {
     new_space_.Shrink();
     UncommitFromSpace();
   }
 }
 
 
 bool Heap::TryFinalizeIdleIncrementalMarking(
-    double idle_time_in_ms, size_t size_of_objects,
+    bool long_idle_time, double idle_time_in_ms, size_t size_of_objects,

[rmcilroy, 2015/04/28 11:19:08]

ditto

[Hannes Payer (out of office), 2015/04/28 11:27:46]

Done.

     size_t final_incremental_mark_compact_speed_in_bytes_per_ms) {
   if (FLAG_overapproximate_weak_closure &&
       (incremental_marking()->IsReadyToOverApproximateWeakClosure() ||
        (!incremental_marking()->weak_closure_was_overapproximated() &&
         mark_compact_collector_.marking_deque()->IsEmpty() &&
         gc_idle_time_handler_.ShouldDoOverApproximateWeakClosure(
             static_cast<size_t>(idle_time_in_ms))))) {
     OverApproximateWeakClosure(
         "Idle notification: overapproximate weak closure");
     return true;
   } else if (incremental_marking()->IsComplete() ||
              (mark_compact_collector_.marking_deque()->IsEmpty() &&
               gc_idle_time_handler_.ShouldDoFinalIncrementalMarkCompact(
                   static_cast<size_t>(idle_time_in_ms), size_of_objects,
                   final_incremental_mark_compact_speed_in_bytes_per_ms))) {
     CollectAllGarbage(kNoGCFlags, "idle notification: finalize incremental");
+    ReduceNewSpaceSize(long_idle_time);
     return true;
   }
   return false;
 }
 
 
 static double MonotonicallyIncreasingTimeInMs() {
   return V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() *
          static_cast<double>(base::Time::kMillisecondsPerSecond);
 }
 
 
 bool Heap::IdleNotification(int idle_time_in_ms) {
   return IdleNotification(
       V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() +
       (static_cast<double>(idle_time_in_ms) /
        static_cast<double>(base::Time::kMillisecondsPerSecond)));
 }
 
 
 bool Heap::IdleNotification(double deadline_in_seconds) {
   CHECK(HasBeenSetUp());  // http://crbug.com/425035
   double deadline_in_ms =
       deadline_in_seconds *
       static_cast<double>(base::Time::kMillisecondsPerSecond);
   HistogramTimerScope idle_notification_scope(
       isolate_->counters()->gc_idle_notification());
   double idle_time_in_ms = deadline_in_ms - MonotonicallyIncreasingTimeInMs();
+  bool long_idle_time = static_cast<size_t>(idle_time_in_ms) >

[rmcilroy, 2015/04/28 11:19:08]

nit - would be clearer as is_long_idle_notification

[Hannes Payer (out of office), 2015/04/28 11:27:46]

Done.

+                        GCIdleTimeHandler::kMaxFrameRenderingIdleTime;
 
   GCIdleTimeHandler::HeapState heap_state;
   heap_state.contexts_disposed = contexts_disposed_;
   heap_state.contexts_disposal_rate =
       tracer()->ContextDisposalRateInMilliseconds();
   heap_state.size_of_objects = static_cast<size_t>(SizeOfObjects());
   heap_state.incremental_marking_stopped = incremental_marking()->IsStopped();
   // TODO(ulan): Start incremental marking only for large heaps.
   intptr_t limit = old_generation_allocation_limit_;
-  if (static_cast<size_t>(idle_time_in_ms) >
-      GCIdleTimeHandler::kMaxFrameRenderingIdleTime) {
+  if (long_idle_time) {
     limit = idle_old_generation_allocation_limit_;
   }
 
   heap_state.can_start_incremental_marking =
       incremental_marking()->CanBeActivated() &&
       HeapIsFullEnoughToStartIncrementalMarking(limit) &&
       !mark_compact_collector()->sweeping_in_progress();
   heap_state.sweeping_in_progress =
       mark_compact_collector()->sweeping_in_progress();
   heap_state.sweeping_completed =
@@ skipping 34 matching lines @@
             IncrementalMarking::FORCE_MARKING,
             IncrementalMarking::DO_NOT_FORCE_COMPLETION);
         remaining_idle_time_in_ms =
             deadline_in_ms - MonotonicallyIncreasingTimeInMs();
       } while (remaining_idle_time_in_ms >=
                    2.0 * GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs &&
                !incremental_marking()->IsComplete() &&
                !mark_compact_collector_.marking_deque()->IsEmpty());
       if (remaining_idle_time_in_ms > 0.0) {
         action.additional_work = TryFinalizeIdleIncrementalMarking(
-            remaining_idle_time_in_ms, heap_state.size_of_objects,
+            long_idle_time, remaining_idle_time_in_ms,
+            heap_state.size_of_objects,
             heap_state.final_incremental_mark_compact_speed_in_bytes_per_ms);
       }
       break;
     }
     case DO_FULL_GC: {
+      if (long_idle_time && gc_count_at_last_idle_gc_ == gc_count) {
+        isolate_->compilation_cache()->Clear();
+      }
       if (contexts_disposed_) {
         HistogramTimerScope scope(isolate_->counters()->gc_context());
         CollectAllGarbage(kNoGCFlags, "idle notification: contexts disposed");
-        gc_idle_time_handler_.NotifyIdleMarkCompact();
-        gc_count_at_last_idle_gc_ = gc_count_;
       } else {
-        IdleMarkCompact("idle notification: finalize idle round");
+        CollectAllGarbage(kReduceMemoryFootprintMask,
+                          "idle notification: finalize idle round");
       }
+      gc_count_at_last_idle_gc_ = gc_count_;
+      ReduceNewSpaceSize(long_idle_time);
+      gc_idle_time_handler_.NotifyIdleMarkCompact();
       break;
     }
     case DO_SCAVENGE:
       CollectGarbage(NEW_SPACE, "idle notification: scavenge");
+      ReduceNewSpaceSize(idle_time_in_ms);

[rmcilroy, 2015/04/28 11:19:08]

You are passing idle_time_in_ms to this ReduceNewSpaceSize(bool long_idle_time)
- are you sure this is what you want to do? Do you want
ReduceNewSpaceSize(idle_time_in_ms >                     
GCIdleTimeHandler::kMaxFrameRenderingIdleTime)

[Hannes Payer (out of office), 2015/04/28 11:27:46]

long_idle_time should be there. thanks, done

       break;
     case DO_FINALIZE_SWEEPING:
       mark_compact_collector()->EnsureSweepingCompleted();
       break;
     case DO_NOTHING:
       break;
   }
 
   double current_time = MonotonicallyIncreasingTimeInMs();
   last_idle_notification_time_ = current_time;
@@ skipping 1718 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal