Abort incremental marking on idle notification after context disposal.

src/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4820 matching lines @@
     gc_count_at_last_idle_gc_ = gc_count_;
     if (uncommit) {
       new_space_.Shrink();
       UncommitFromSpace();
     }
   }
 }
 
 
 bool Heap::IdleNotification(int hint) {
-  intptr_t size_factor = Min(Max(hint, 30), 1000) / 10;
+  const int kMaxHint = 1000;
+  intptr_t size_factor = Min(Max(hint, 30), kMaxHint) / 10;
   // The size factor is in range [3..100].
   intptr_t step_size = size_factor * IncrementalMarking::kAllocatedThreshold;
 
   if (contexts_disposed_ > 0) {
     int mark_sweep_time = Min(TimeMarkSweepWouldTakeInMs(), 1000);
     if (hint >= mark_sweep_time && !FLAG_expose_gc) {
       HistogramTimerScope scope(isolate_->counters()->gc_context());
-      CollectAllGarbage(kReduceMemoryFootprintMask,
-                        "idle notification: contexts disposed");
+      if (hint >= kMaxHint) {
+        // The embedder can tolerate long pauses, do precise GC.
+        CollectAllGarbage(kReduceMemoryFootprintMask |
+                          kAbortIncrementalMarkingMask,
+                          "idle notification: contexts disposed"
+                          " (abort incremental marking)");
+      } else {
+        CollectAllGarbage(kReduceMemoryFootprintMask,
+                          "idle notification: contexts disposed");
+      }
     } else {
       AdvanceIdleIncrementalMarking(step_size);
       contexts_disposed_ = 0;
     }
     // Make sure that we have no pending context disposals.
     // Take into account that we might have decided to delay full collection
     // because incremental marking is in progress.
     ASSERT((contexts_disposed_ == 0) || !incremental_marking()->IsStopped());
     return false;
   }
 
-  if (hint >= 1000 || !FLAG_incremental_marking ||
+  if (hint >= kMaxHint || !FLAG_incremental_marking ||
       FLAG_expose_gc || Serializer::enabled()) {
     return IdleGlobalGC();
   }
 
   // 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,
@@ skipping 2094 matching lines @@
   } else {
     p ^= 0x1d1ed & (Page::kPageSize - 1);  // I died.
   }
   remembered_unmapped_pages_[remembered_unmapped_pages_index_] =
       reinterpret_cast<Address>(p);
   remembered_unmapped_pages_index_++;
   remembered_unmapped_pages_index_ %= kRememberedUnmappedPages;
 }
 
 } }  // namespace v8::internal