Perform full gcs when context disposals happen too frequent.

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/once.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 50 matching lines @@
       max_old_generation_size_(700ul * (kPointerSize / 4) * MB),
       max_executable_size_(256ul * (kPointerSize / 4) * MB),
       // Variables set based on semispace_size_ and old_generation_size_ in
       // ConfigureHeap.
       // Will be 4 * reserved_semispace_size_ to ensure that young
       // generation can be aligned to its size.
       maximum_committed_(0),
       survived_since_last_expansion_(0),
       sweep_generation_(0),
       always_allocate_scope_depth_(0),
-      contexts_disposed_(0),
       global_ic_age_(0),
       flush_monomorphic_ics_(false),
+      last_notify_context_disposed_(0.0),
       scan_on_scavenge_pages_(0),
       new_space_(this),
       old_pointer_space_(NULL),
       old_data_space_(NULL),
       code_space_(NULL),
       map_space_(NULL),
       cell_space_(NULL),
       property_cell_space_(NULL),
       lo_space_(NULL),
       gc_state_(NOT_IN_GC),
@@ skipping 767 matching lines @@
   if (!mark_compact_collector()->abort_incremental_marking() &&
       incremental_marking()->IsStopped() &&
       incremental_marking()->WorthActivating() && NextGCIsLikelyToBeFull()) {
     incremental_marking()->Start();
   }
 
   return next_gc_likely_to_collect_more;
 }
 
 
-int Heap::NotifyContextDisposed() {
+void Heap::NotifyContextDisposed() {
+  double current_notify_context_disposed = base::OS::TimeCurrentMillis();
   if (isolate()->concurrent_recompilation_enabled()) {
     // Flush the queued recompilation tasks.
     isolate()->optimizing_compiler_thread()->Flush();
   }
   flush_monomorphic_ics_ = true;
   AgeInlineCaches();
-  return ++contexts_disposed_;
+  if (last_notify_context_disposed_ > 0.0 &&
+      (current_notify_context_disposed - last_notify_context_disposed_ <
+       static_cast<double>(kNotifyContextDisposedFullGCLimitInMS))) {
+    CollectAllGarbage(kReduceMemoryFootprintMask,
+                      "notify contexts disposed at high rate");
+  }
+
+  // After context disposal there is likely a lot of garbage remaining, reset
+  // the idle notification counters in order to allow more idle notifcations.
+  StartIdleRound();
+
+  last_notify_context_disposed_ = base::OS::TimeCurrentMillis();
 }
 
 
 void Heap::MoveElements(FixedArray* array, int dst_index, int src_index,
                         int len) {
   if (len == 0) return;
 
   DCHECK(array->map() != fixed_cow_array_map());
   Object** dst_objects = array->data_start() + dst_index;
   MemMove(dst_objects, array->data_start() + src_index, len * kPointerSize);
@@ skipping 3416 matching lines @@
   intptr_t size_factor = Min(Max(hint, 20), kMaxHint) / 4;
   // The size factor is in range [5..250]. The numbers here are chosen from
   // experiments. If you changes them, make sure to test with
   // chrome/performance_ui_tests --gtest_filter="GeneralMixMemoryTest.*
   intptr_t step_size = size_factor * IncrementalMarking::kAllocatedThreshold;
 
   isolate()->counters()->gc_idle_time_allotted_in_ms()->AddSample(hint);
   HistogramTimerScope idle_notification_scope(
       isolate_->counters()->gc_idle_notification());
 
-  if (contexts_disposed_ > 0) {
-    contexts_disposed_ = 0;
-    int mark_sweep_time = Min(TimeMarkSweepWouldTakeInMs(), 1000);
-    if (hint >= mark_sweep_time && !FLAG_expose_gc &&
-        incremental_marking()->IsStopped()) {
-      HistogramTimerScope scope(isolate_->counters()->gc_context());
-      CollectAllGarbage(kReduceMemoryFootprintMask,
-                        "idle notification: contexts disposed");
-    } else {
-      AdvanceIdleIncrementalMarking(step_size);
-    }
-
-    // After context disposal there is likely a lot of garbage remaining, reset
-    // the idle notification counters in order to trigger more incremental GCs
-    // on subsequent idle notifications.
-    StartIdleRound();
-    return false;
-  }
-
-  // By doing small chunks of GC work in each IdleNotification,
-  // perform a round of incremental GCs and after that wait until
-  // the mutator creates enough garbage to justify a new round.
-  // An incremental GC progresses as follows:
-  // 1. many incremental marking steps,
-  // 2. one old space mark-sweep-compact,
-  // Use mark-sweep-compact events to count incremental GCs in a round.
-
   if (mark_sweeps_since_idle_round_started_ >= kMaxMarkSweepsInIdleRound) {
     if (EnoughGarbageSinceLastIdleRound()) {
       StartIdleRound();
     } else {
       return true;
     }
   }
 
-  int remaining_mark_sweeps =
-      kMaxMarkSweepsInIdleRound - mark_sweeps_since_idle_round_started_;
-
-  if (incremental_marking()->IsStopped()) {
+  int mark_sweep_time = Min(TimeMarkSweepWouldTakeInMs(), 1000);
+  // Perform a full gc if there is enough idle time.
+  if (hint >= mark_sweep_time) {
+    CollectAllGarbage(kReduceMemoryFootprintMask,

[jochen (gone - plz use gerrit), 2014/08/07 09:14:51]

this is a somewhat new behavior, because previously we'd only do this if there
was a context disposal notification before, no?

But since we're respecting the idle hint, I think that's ok

[Hannes Payer (out of office), 2014/08/07 10:53:30]

Yes, this is different. Note that before we were just preforming a full gc when
incremental marking was stopped. However, we should do a full gc when the hint
is big enough. I thought about doing it in a separate cl but it is quit a mess.

+                      "idle notification: finalize idle round");
+    mark_sweeps_since_idle_round_started_++;
+  } else if (incremental_marking()->IsStopped()) {
+    int remaining_mark_sweeps =
+        kMaxMarkSweepsInIdleRound - mark_sweeps_since_idle_round_started_;
     // 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.
     if (remaining_mark_sweeps <= 2 && hint >= kMinHintForFullGC) {
       CollectAllGarbage(kReduceMemoryFootprintMask,
                         "idle notification: finalize idle round");
       mark_sweeps_since_idle_round_started_++;
     } else if (hint > kMinHintForIncrementalMarking) {
@@ skipping 1789 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal