Idle old generation limit is used when allocation rate is low.

src/heap/heap.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 4584 matching lines @@
                   static_cast<size_t>(idle_time_in_ms), size_of_objects,
                   final_incremental_mark_compact_speed_in_bytes_per_ms))) {
     CollectAllGarbage(kNoGCFlags, "idle notification: finalize incremental");
     gc_idle_time_handler_.NotifyIdleMarkCompact();
     return true;
   }
   return false;
 }
 
 
-GCIdleTimeHandler::HeapState Heap::ComputeHeapState(bool reduce_memory) {
+GCIdleTimeHandler::HeapState Heap::ComputeHeapState() {
   GCIdleTimeHandler::HeapState heap_state;
   heap_state.contexts_disposed = contexts_disposed_;
   heap_state.contexts_disposal_rate =
       tracer()->ContextDisposalRateInMilliseconds();
   heap_state.size_of_objects = static_cast<size_t>(SizeOfObjects());
   heap_state.incremental_marking_stopped = incremental_marking()->IsStopped();
-  // TODO(ulan): Start incremental marking only for large heaps.
-  intptr_t limit = old_generation_allocation_limit_;
-  if (reduce_memory) {
-    limit = idle_old_generation_allocation_limit_;
-  }
-
-  heap_state.can_start_incremental_marking =
-      incremental_marking()->CanBeActivated() &&
-      HeapIsFullEnoughToStartIncrementalMarking(limit) &&
-      !mark_compact_collector()->sweeping_in_progress();
   heap_state.sweeping_in_progress =
       mark_compact_collector()->sweeping_in_progress();
   heap_state.sweeping_completed =
       mark_compact_collector()->IsSweepingCompleted();
   heap_state.mark_compact_speed_in_bytes_per_ms =
       static_cast<size_t>(tracer()->MarkCompactSpeedInBytesPerMillisecond());
   heap_state.incremental_marking_speed_in_bytes_per_ms = static_cast<size_t>(
       tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
   heap_state.final_incremental_mark_compact_speed_in_bytes_per_ms =
       static_cast<size_t>(
           tracer()->FinalIncrementalMarkCompactSpeedInBytesPerMillisecond());
   heap_state.scavenge_speed_in_bytes_per_ms =
       static_cast<size_t>(tracer()->ScavengeSpeedInBytesPerMillisecond());
   heap_state.used_new_space_size = new_space_.Size();
   heap_state.new_space_capacity = new_space_.Capacity();
   heap_state.new_space_allocation_throughput_in_bytes_per_ms =
       tracer()->NewSpaceAllocationThroughputInBytesPerMillisecond();
   heap_state.current_new_space_allocation_throughput_in_bytes_per_ms =
       tracer()->CurrentNewSpaceAllocationThroughputInBytesPerMillisecond();
+  intptr_t limit = old_generation_allocation_limit_;
+  if (HasLowAllocationRate(
+          heap_state.current_new_space_allocation_throughput_in_bytes_per_ms)) {
+    limit = idle_old_generation_allocation_limit_;
+  }
+  heap_state.can_start_incremental_marking =
+      incremental_marking()->CanBeActivated() &&
+      HeapIsFullEnoughToStartIncrementalMarking(limit) &&
+      !mark_compact_collector()->sweeping_in_progress();
   return heap_state;
 }
 
 
 bool Heap::PerformIdleTimeAction(GCIdleTimeAction action,
                                  GCIdleTimeHandler::HeapState heap_state,
                                  double deadline_in_ms,
                                  bool is_long_idle_notification) {
   bool result = false;
   switch (action.type) {
@@ skipping 115 matching lines @@
 bool Heap::IdleNotification(int idle_time_in_ms) {
   return IdleNotification(
       V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() +
       (static_cast<double>(idle_time_in_ms) /
        static_cast<double>(base::Time::kMillisecondsPerSecond)));
 }
 
 
 bool Heap::IdleNotification(double deadline_in_seconds) {
   CHECK(HasBeenSetUp());
-  static const double kLastGCTimeTreshold = 1000;
   double deadline_in_ms =
       deadline_in_seconds *
       static_cast<double>(base::Time::kMillisecondsPerSecond);
   HistogramTimerScope idle_notification_scope(
       isolate_->counters()->gc_idle_notification());
   double start_ms = MonotonicallyIncreasingTimeInMs();
   double idle_time_in_ms = deadline_in_ms - start_ms;
   bool is_long_idle_notification =
       static_cast<size_t>(idle_time_in_ms) >
       GCIdleTimeHandler::kMaxFrameRenderingIdleTime;
-  bool has_low_gc_activity = (start_ms - last_gc_time_) > kLastGCTimeTreshold;
 
   if (is_long_idle_notification) {
     tracer()->SampleNewSpaceAllocation(start_ms, NewSpaceAllocationCounter());
   }
 
-  GCIdleTimeHandler::HeapState heap_state =
-      ComputeHeapState(is_long_idle_notification && has_low_gc_activity);
+  GCIdleTimeHandler::HeapState heap_state = ComputeHeapState();
 
   GCIdleTimeAction action =
       gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state);
 
   bool result = PerformIdleTimeAction(action, heap_state, deadline_in_ms,
                                       is_long_idle_notification);
 
   IdleNotificationEpilogue(action, heap_state, start_ms, deadline_in_ms,
                            is_long_idle_notification);
   return result;
@@ skipping 1785 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }
 }  // namespace v8::internal