Perform scavenge in idle tasks.

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/flags.h"
 #include "src/heap/gc-tracer.h"
 #include "src/utils.h"
 
@@ skipping 14 matching lines @@
       break;
     case DO_NOTHING:
       PrintF("no action");
       break;
     case DO_INCREMENTAL_STEP:
       PrintF("incremental step");
       if (additional_work) {
         PrintF("; finalized marking");
       }
       break;
-    case DO_SCAVENGE:
-      PrintF("scavenge");
-      break;
     case DO_FULL_GC:
       PrintF("full GC");
       break;
   }
 }
 
 
 void GCIdleTimeHeapState::Print() {
   PrintF("contexts_disposed=%d ", contexts_disposed);
   PrintF("contexts_disposal_rate=%f ", contexts_disposal_rate);
   PrintF("size_of_objects=%" V8_PTR_PREFIX "d ", size_of_objects);
   PrintF("incremental_marking_stopped=%d ", incremental_marking_stopped);
   PrintF("sweeping_in_progress=%d ", sweeping_in_progress);
   PrintF("has_low_allocation_rate=%d", has_low_allocation_rate);
   PrintF("mark_compact_speed=%" V8_PTR_PREFIX "d ",
          mark_compact_speed_in_bytes_per_ms);
   PrintF("incremental_marking_speed=%" V8_PTR_PREFIX "d ",
          incremental_marking_speed_in_bytes_per_ms);
-  PrintF("scavenge_speed=%" V8_PTR_PREFIX "d ", scavenge_speed_in_bytes_per_ms);
-  PrintF("new_space_size=%" V8_PTR_PREFIX "d ", used_new_space_size);
-  PrintF("new_space_capacity=%" V8_PTR_PREFIX "d ", new_space_capacity);
-  PrintF("new_space_allocation_throughput=%" V8_PTR_PREFIX "d ",
-         new_space_allocation_throughput_in_bytes_per_ms);
 }
 
 
 size_t GCIdleTimeHandler::EstimateMarkingStepSize(
     size_t idle_time_in_ms, size_t marking_speed_in_bytes_per_ms) {
   DCHECK(idle_time_in_ms > 0);
 
   if (marking_speed_in_bytes_per_ms == 0) {
     marking_speed_in_bytes_per_ms = kInitialConservativeMarkingSpeed;
   }
@@ skipping 29 matching lines @@
   if (final_incremental_mark_compact_speed_in_bytes_per_ms == 0) {
     final_incremental_mark_compact_speed_in_bytes_per_ms =
         kInitialConservativeFinalIncrementalMarkCompactSpeed;
   }
   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;
-  }
-
-  // Calculates how much memory are we able to scavenge in
-  // kMaxFrameRenderingIdleTime ms. If scavenge_speed_in_bytes_per_ms is 0 we
-  // will take care of this later.
-  size_t idle_new_space_allocation_limit =
-      kMaxFrameRenderingIdleTime * 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 (idle_new_space_allocation_limit > new_space_size) {
-    idle_new_space_allocation_limit = new_space_size;
-  }
-
-  // We do not know the allocation throughput before the first scavenge.
-  // TODO(hpayer): Estimate allocation throughput before the first scavenge.
-  if (new_space_allocation_throughput_in_bytes_per_ms > 0) {
-    // We have to trigger scavenge before we reach the end of new space.
-    size_t adjust_limit = new_space_allocation_throughput_in_bytes_per_ms *
-                          kTimeUntilNextIdleEvent;
-    if (adjust_limit > idle_new_space_allocation_limit) {
-      idle_new_space_allocation_limit = 0;
-    } else {
-      idle_new_space_allocation_limit -= adjust_limit;
-    }
-  }
-
-  // The allocated new space limit to trigger a scavange has to be at least
-  // kMinimumNewSpaceSizeToPerformScavenge.
-  if (idle_new_space_allocation_limit < kMinimumNewSpaceSizeToPerformScavenge) {
-    idle_new_space_allocation_limit = kMinimumNewSpaceSizeToPerformScavenge;
-  }
-
-  // Set an initial scavenge speed if it is unknown.
-  if (scavenge_speed_in_bytes_per_ms == 0) {
-    scavenge_speed_in_bytes_per_ms = kInitialConservativeScavengeSpeed;
-  }
-
-  // We apply a max factor to the new space size to make sure that a slowly
-  // allocating application still leaves enough of wiggle room to schedule a
-  // scavenge.
-  size_t max_limit;
-  const double kMaxNewSpaceSizeFactorLongIdleTimes = 0.5;
-  const double kMaxNewSpaceSizeFactorShortIdleTimes = 0.8;
-  if (idle_time_in_ms > kMaxFrameRenderingIdleTime) {
-    max_limit = static_cast<size_t>(new_space_size *
-                                    kMaxNewSpaceSizeFactorLongIdleTimes);
-  } else {
-    max_limit = static_cast<size_t>(new_space_size *
-                                    kMaxNewSpaceSizeFactorShortIdleTimes);
-  }
-  idle_new_space_allocation_limit =
-      Min(idle_new_space_allocation_limit, max_limit);
-
-  // We perform a scavenge if we are over the idle new space limit and
-  // a scavenge fits into the given idle time bucket.
-  if (idle_new_space_allocation_limit <= used_new_space_size) {
-    if (used_new_space_size / scavenge_speed_in_bytes_per_ms <=
-        idle_time_in_ms) {
-      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);
 }
 
 
@@ skipping 59 matching lines @@
     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(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 (!FLAG_incremental_marking || heap_state.incremental_marking_stopped) {
     return GCIdleTimeAction::Done();
   }
 
   return GCIdleTimeAction::IncrementalStep();
 }
 
 
 }
 }