Fix idle notification for background tab.

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/flags.h"
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/gc-tracer.h"
 #include "src/utils.h"
 
 namespace v8 {
@@ skipping 96 matching lines @@
   size_t result =
       size_of_objects / final_incremental_mark_compact_speed_in_bytes_per_ms;
   return Min(result, kMaxFinalIncrementalMarkCompactTimeInMs);
 }
 
 
 bool GCIdleTimeHandler::ShouldDoScavenge(
     size_t idle_time_in_ms, size_t new_space_size, size_t used_new_space_size,
     size_t scavenge_speed_in_bytes_per_ms,
     size_t new_space_allocation_throughput_in_bytes_per_ms) {
+  if (idle_time_in_ms >= kMinBackgroundIdleTime) {
+    // It is better to do full GC for the background tab.
+    return false;
+  }
   size_t new_space_allocation_limit =
       kMaxScheduledIdleTime * scavenge_speed_in_bytes_per_ms;
 
   // If the limit is larger than the new space size, then scavenging used to be
   // really fast. We can take advantage of the whole new space.
   if (new_space_allocation_limit > new_space_size) {
     new_space_allocation_limit = new_space_size;
   }
 
   // We do not know the allocation throughput before the first scavenge.
@@ skipping 59 matching lines @@
 }
 
 
 bool GCIdleTimeHandler::ShouldDoOverApproximateWeakClosure(
     size_t idle_time_in_ms) {
   // TODO(jochen): Estimate the time it will take to build the object groups.
   return idle_time_in_ms >= kMinTimeForOverApproximatingWeakClosureInMs;
 }
 
 
-GCIdleTimeAction GCIdleTimeHandler::NothingOrDone() {
-  if (idle_times_which_made_no_progress_ >= kMaxNoProgressIdleTimes) {
+GCIdleTimeAction GCIdleTimeHandler::NothingOrDone(double idle_time_in_ms) {
+  if (idle_times_which_made_no_progress_ >= kMaxNoProgressIdleTimes &&
+      idle_time_in_ms < kMinBackgroundIdleTime) {
     return GCIdleTimeAction::Done();
   } else {
     idle_times_which_made_no_progress_++;

[rmcilroy, 2015/07/29 18:11:04]

Could this cause wrapping of idle_times_which_made_no_progress_? Maybe clap
idle_times_which_made_no_progress_ to be less than or equal to
kMaxNoProgressIdleTimes?

[ulan, 2015/07/29 18:21:30]

Thanks, rewrote to clap the counter.
Interval between background idle notifications is at least 1 second, so wrapping
can happen in 60 years. :)

[rmcilroy, 2015/07/30 07:14:07]

Better safe than sorry ;). Thanks.

     return GCIdleTimeAction::Nothing();
   }
 }
 
 
 // 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 context disposal rate is high and we cannot perform a full GC,
@@ skipping 14 matching lines @@
         return GCIdleTimeAction::FullGC();
       }
     }
     return GCIdleTimeAction::Nothing();
   }
 
   // We are in a context disposal GC scenario. Don't do anything if we do not
   // get the right idle signal.
   if (ShouldDoContextDisposalMarkCompact(heap_state.contexts_disposed,
                                          heap_state.contexts_disposal_rate)) {
-    return NothingOrDone();
+    return NothingOrDone(idle_time_in_ms);
   }
 
   if (ShouldDoScavenge(
           static_cast<size_t>(idle_time_in_ms), heap_state.new_space_capacity,
           heap_state.used_new_space_size,
           heap_state.scavenge_speed_in_bytes_per_ms,
           heap_state.new_space_allocation_throughput_in_bytes_per_ms)) {
     return GCIdleTimeAction::Scavenge();
   }
 
   if (heap_state.sweeping_in_progress) {
     if (heap_state.sweeping_completed) {
       return GCIdleTimeAction::FinalizeSweeping();
     } else {
-      return NothingOrDone();
+      return NothingOrDone(idle_time_in_ms);
     }
   }
 
   if (!FLAG_incremental_marking || heap_state.incremental_marking_stopped) {
     return GCIdleTimeAction::Done();
   }
 
   size_t step_size = EstimateMarkingStepSize(
       static_cast<size_t>(kIncrementalMarkingStepTimeInMs),
       heap_state.incremental_marking_speed_in_bytes_per_ms);
   return GCIdleTimeAction::IncrementalMarking(step_size);
 }
 
 
 }
 }