Force scavenge in idle notification if we estimate that it will take long.

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 56 matching lines @@
     mark_compact_speed_in_bytes_per_ms = kInitialConservativeMarkCompactSpeed;
   }
   size_t result = size_of_objects / mark_compact_speed_in_bytes_per_ms;
   return Min(result, kMaxMarkCompactTimeInMs);
 }
 
 
 size_t GCIdleTimeHandler::EstimateScavengeTime(
     size_t new_space_size, size_t scavenge_speed_in_bytes_per_ms) {
   if (scavenge_speed_in_bytes_per_ms == 0) {
-    scavenge_speed_in_bytes_per_ms = kInitialConservativeScavengeSpeed;
+    return GCIdleTimeHandler::kLargeIdleTime;
   }
   return new_space_size / scavenge_speed_in_bytes_per_ms;
 }
 
 
 bool GCIdleTimeHandler::ScavangeMayHappenSoon(
     size_t available_new_space_memory,
     size_t new_space_allocation_throughput_in_bytes_per_ms) {
   if (available_new_space_memory <=
       new_space_allocation_throughput_in_bytes_per_ms *
           kMaxFrameRenderingIdleTime) {
     return true;
   }
   return false;
 }
 
 
+bool GCIdleTimeHandler::DoEarlyScavenge(
+    size_t idle_time_in_ms, size_t new_space_size,
+    size_t available_new_space_memory, size_t scavenger_speed_in_bytes_per_ms) {
+  // For small idle times, we conservatively decide not to do a Scavenge.
+  if (idle_time_in_ms < kLargeIdleTime &&
+      idle_time_in_ms > kMaxFrameRenderingIdleTime) {

[jochen (gone - plz use gerrit), 2014/09/18 18:46:28]

that is 16 < idle_time_in_ms < 10 which is always false

+    return false;
+  }
+
+  size_t currently_allocated = new_space_size - available_new_space_memory;
+  size_t current_scavenging_estimate_in_ms = EstimateScavengeTime(
+      currently_allocated, scavenger_speed_in_bytes_per_ms);
+
+  // We just force a Scavenge if it may take really long.
+  if (current_scavenging_estimate_in_ms < kForceScavengeThreshold) return false;
+
+  if (idle_time_in_ms < current_scavenging_estimate_in_ms) return false;

[jochen (gone - plz use gerrit), 2014/09/18 18:46:28]

so basically, we force a scavenge if it would take between 10 and 16 ms, right?

i thought this method should return true if we should scavenge now if the next
regular scavenge might be more than 10ms?

+  return true;
+}
+
+
+bool GCIdleTimeHandler::DoScavenge(
+    size_t idle_time_in_ms, size_t new_space_size,
+    size_t available_new_space_memory, size_t scavenge_speed_in_bytes_per_ms,
+    size_t new_space_allocation_throughput_in_bytes_per_ms) {
+  // Do not invoke scavenger for large idle notification requests.
+  if (idle_time_in_ms > kMaxFrameRenderingIdleTime) return false;
+
+  // We may force an early Scavenge if we think that the next Scavenge may take
+  // long or if we think that a Scavenge may happen soon.
+  return DoEarlyScavenge(idle_time_in_ms, new_space_size,

[ulan, 2014/09/19 10:47:47]

As discussed offline, we can probably unify these two conditions into one by
maintaining a virtual limit for new space top.

+                         available_new_space_memory,
+                         scavenge_speed_in_bytes_per_ms) ||
+         (ScavangeMayHappenSoon(
+              available_new_space_memory,
+              new_space_allocation_throughput_in_bytes_per_ms) &&
+          idle_time_in_ms >=
+              EstimateScavengeTime(new_space_size,
+                                   scavenge_speed_in_bytes_per_ms));
+}
+
+
 // The following logic is implemented by the controller:
-// (1) If the new space is almost full and we can effort a Scavenge, then a
-// Scavenge is performed.
+// (1) If the new space is almost full and we can effort a Scavenge or if the
+// next Scavenge will very likely take long, then a Scavenge is performed.
 // (2) If there is currently no MarkCompact idle round going on, we start a
 // new idle round if enough garbage was created or we received a context
 // disposal event. Otherwise we do not perform garbage collection to keep
 // system utilization low.
 // (3) If incremental marking is done, we perform a full garbage collection
 // if context was disposed or 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.
 // (4) If sweeping is in progress and we received a large enough idle time
 // request, we finalize sweeping here.
 // (5) If incremental marking is in progress, we perform a marking step. Note,
 // that this currently may trigger a full garbage collection.
 GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms,
                                             HeapState heap_state) {
-  if (ScavangeMayHappenSoon(
-          heap_state.available_new_space_memory,
-          heap_state.new_space_allocation_throughput_in_bytes_per_ms) &&
-      idle_time_in_ms >=
-          EstimateScavengeTime(heap_state.new_space_capacity,
-                               heap_state.scavenge_speed_in_bytes_per_ms)) {
+  if (DoScavenge(idle_time_in_ms, heap_state.new_space_capacity,
+                 heap_state.available_new_space_memory,
+                 heap_state.scavenge_speed_in_bytes_per_ms,
+                 heap_state.new_space_allocation_throughput_in_bytes_per_ms)) {
     return GCIdleTimeAction::Scavenge();
   }
+
   if (IsMarkCompactIdleRoundFinished()) {
     if (EnoughGarbageSinceLastIdleRound() || heap_state.contexts_disposed > 0) {
       StartIdleRound();
     } else {
       return GCIdleTimeAction::Done();
     }
   }
 
   if (idle_time_in_ms == 0) {
     return GCIdleTimeAction::Nothing();
@@ skipping 33 matching lines @@
   if (heap_state.incremental_marking_stopped &&
       !heap_state.can_start_incremental_marking) {
     return GCIdleTimeAction::Nothing();
   }
   size_t step_size = EstimateMarkingStepSize(
       idle_time_in_ms, heap_state.incremental_marking_speed_in_bytes_per_ms);
   return GCIdleTimeAction::IncrementalMarking(step_size);
 }
 }
 }