Rename kMaxFrameRenderingIdleTime to kMaxActiveIdleTime and adjust it to the currently maximum valu…

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 99 matching lines @@
       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) {
   size_t new_space_allocation_limit =
-      kMaxFrameRenderingIdleTime * scavenge_speed_in_bytes_per_ms;
+      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.
   // TODO(hpayer): Estimate allocation throughput before the first Scavenge.
   if (new_space_allocation_throughput_in_bytes_per_ms == 0) {
     new_space_allocation_limit =
         static_cast<size_t>(new_space_size * kConservativeTimeRatio);
   } else {
     // We have to trigger scavenge before we reach the end of new space.
     new_space_allocation_limit -=
-        new_space_allocation_throughput_in_bytes_per_ms *
-        kMaxFrameRenderingIdleTime;
+        new_space_allocation_throughput_in_bytes_per_ms * kMaxScheduledIdleTime;
   }
 
   if (scavenge_speed_in_bytes_per_ms == 0) {
     scavenge_speed_in_bytes_per_ms = kInitialConservativeScavengeSpeed;
   }
 
   if (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;
@@ skipping 89 matching lines @@
     if (ShouldDoMarkCompact(static_cast<size_t>(idle_time_in_ms),
                             heap_state.size_of_objects,
                             heap_state.mark_compact_speed_in_bytes_per_ms)) {
       // If there are no more than two GCs left in this idle round and we are
       // allowed to do a full GC, then make those GCs full in order to compact
       // the code space.
       // TODO(ulan): Once we enable code compaction for incremental marking, we
       // can get rid of this special case and always start incremental marking.
       int remaining_mark_sweeps =
           kMaxMarkCompactsInIdleRound - mark_compacts_since_idle_round_started_;
-      if (static_cast<size_t>(idle_time_in_ms) > kMaxFrameRenderingIdleTime &&
+      if (static_cast<size_t>(idle_time_in_ms) > kMaxScheduledIdleTime &&
           (remaining_mark_sweeps <= 2 ||
            !heap_state.can_start_incremental_marking)) {
         return GCIdleTimeAction::FullGC();
       }
     }
     if (!heap_state.can_start_incremental_marking) {
       return GCIdleTimeAction::Nothing();
     }
   }
   // TODO(hpayer): Estimate finalize sweeping time.
   if (heap_state.sweeping_in_progress &&
       static_cast<size_t>(idle_time_in_ms) >= kMinTimeForFinalizeSweeping) {
     return GCIdleTimeAction::FinalizeSweeping();
   }
 
   if (heap_state.incremental_marking_stopped &&
       !heap_state.can_start_incremental_marking) {
     return GCIdleTimeAction::Nothing();
   }
   size_t step_size = EstimateMarkingStepSize(
       static_cast<size_t>(kIncrementalMarkingStepTimeInMs),
       heap_state.incremental_marking_speed_in_bytes_per_ms);
   return GCIdleTimeAction::IncrementalMarking(step_size);
 }
 }
 }