Use deadline in IdleNotification.

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 148 matching lines @@
 // new idle round if enough garbage was created. Otherwise we do not perform
 // garbage collection to keep system utilization low.
 // (4) If incremental marking is done, we perform a full garbage collection
 // 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.
 // (5) If sweeping is in progress and we received a large enough idle time
 // request, we finalize sweeping here.
 // (6) 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,
+GCIdleTimeAction GCIdleTimeHandler::Compute(double idle_time,

[rmcilroy, 2014/11/25 14:28:06]

nit - keep this as idle_time_in_ms

[Hannes Payer (out of office), 2014/11/25 16:01:36]

Done.

                                             HeapState heap_state) {
-  if (idle_time_in_ms == 0) {
+  if (idle_time <= 0.0) {
     if (heap_state.incremental_marking_stopped) {
       if (ShouldDoContextDisposalMarkCompact(
               heap_state.contexts_disposed,
               heap_state.contexts_disposal_rate)) {
         return GCIdleTimeAction::FullGC();
       }
     }
     return GCIdleTimeAction::Nothing();
   }
 
+  size_t idle_time_in_ms = static_cast<size_t>(idle_time);
+
   if (ShouldDoScavenge(
           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 (IsMarkCompactIdleRoundFinished()) {
     if (EnoughGarbageSinceLastIdleRound()) {
@@ skipping 32 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);
 }
 }
 }