Change halfway-to-the-max GC trigger to measure committed pages, not allocated objects

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 48 matching lines @@
     : amount_of_external_allocated_memory_(0),
       amount_of_external_allocated_memory_at_last_global_gc_(0),
       isolate_(NULL),
       code_range_size_(0),
       // semispace_size_ should be a power of 2 and old_generation_size_ should
       // be a multiple of Page::kPageSize.
       reserved_semispace_size_(8 * (kPointerSize / 4) * MB),
       max_semi_space_size_(8 * (kPointerSize / 4) * MB),
       initial_semispace_size_(Page::kPageSize),
       target_semispace_size_(Page::kPageSize),
-      max_old_generation_size_(700ul * (kPointerSize / 4) * MB),
+      max_old_generation_size_(kDefaultMaxOldGenSize),
       initial_old_generation_size_(max_old_generation_size_ /
                                    kInitalOldGenerationLimitFactor),
       old_generation_size_configured_(false),
       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),
@@ skipping 16 matching lines @@
       raw_allocations_hash_(0),
       dump_allocations_hash_countdown_(FLAG_dump_allocations_digest_at_alloc),
       ms_count_(0),
       gc_count_(0),
       remembered_unmapped_pages_index_(0),
       unflattened_strings_length_(0),
 #ifdef DEBUG
       allocation_timeout_(0),
 #endif  // DEBUG
       old_generation_allocation_limit_(initial_old_generation_size_),
+      old_generation_committed_memory_limit_(kDefaultMaxOldGenSize >> 1),
       old_gen_exhausted_(false),
       inline_allocation_disabled_(false),
       store_buffer_rebuilder_(store_buffer()),
       hidden_string_(NULL),
       gc_safe_size_of_old_object_(NULL),
       total_regexp_code_generated_(0),
       tracer_(this),
       high_survival_rate_period_length_(0),
       promoted_objects_size_(0),
       promotion_ratio_(0),
@@ skipping 738 matching lines @@
 
   EnsureFillerObjectAtTop();
 
   if (collector == SCAVENGER && !incremental_marking()->IsStopped()) {
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Scavenge during marking.\n");
     }
   }
 
   if (collector == MARK_COMPACTOR &&
-      !mark_compact_collector()->abort_incremental_marking() &&
+      !mark_compact_collector()->incremental_marking_abort_requested() &&
       !incremental_marking()->IsStopped() &&
       !incremental_marking()->should_hurry() &&
       FLAG_incremental_marking_steps) {
     // Make progress in incremental marking.
     const intptr_t kStepSizeWhenDelayedByScavenge = 1 * MB;
     incremental_marking()->Step(kStepSizeWhenDelayedByScavenge,
                                 IncrementalMarking::NO_GC_VIA_STACK_GUARD);
     if (!incremental_marking()->IsComplete() &&
         !mark_compact_collector_.marking_deque_.IsEmpty() && !FLAG_gc_global) {
       if (FLAG_trace_incremental_marking) {
@@ skipping 22 matching lines @@
 
     GarbageCollectionEpilogue();
     if (collector == MARK_COMPACTOR && FLAG_track_detached_contexts) {
       isolate()->CheckDetachedContextsAfterGC();
     }
     tracer()->Stop(collector);
   }
 
   // Start incremental marking for the next cycle. The heap snapshot
   // generator needs incremental marking to stay off after it aborted.
-  if (!mark_compact_collector()->abort_incremental_marking() &&
-      WorthActivatingIncrementalMarking()) {
+  if (!mark_compact_collector()->incremental_marking_abort_requested() &&
+      incremental_marking()->IsStopped() &&
+      incremental_marking()->ShouldActivate()) {
     incremental_marking()->Start();
   }
 
   return next_gc_likely_to_collect_more;
 }
 
 
 int Heap::NotifyContextDisposed(bool dependant_context) {
   if (!dependant_context) {
     tracer()->ResetSurvivalEvents();
@@ skipping 236 matching lines @@
     incremental_marking()->NotifyOfHighPromotionRate();
   }
 
   if (collector == MARK_COMPACTOR) {
     // Perform mark-sweep with optional compaction.
     MarkCompact();
     sweep_generation_++;
     // Temporarily set the limit for case when PostGarbageCollectionProcessing
     // allocates and triggers GC. The real limit is set at after
     // PostGarbageCollectionProcessing.
-    old_generation_allocation_limit_ =
-        OldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(), 0);
+    SetOldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(), 0, false);
     old_gen_exhausted_ = false;
     old_generation_size_configured_ = true;
   } else {
     Scavenge();
   }
 
   UpdateSurvivalStatistics(start_new_space_size);
   ConfigureInitialOldGenerationSize();
 
   isolate_->counters()->objs_since_last_young()->Set(0);
@@ skipping 13 matching lines @@
 
   isolate_->eternal_handles()->PostGarbageCollectionProcessing(this);
 
   // Update relocatables.
   Relocatable::PostGarbageCollectionProcessing(isolate_);
 
   if (collector == MARK_COMPACTOR) {
     // Register the amount of external allocated memory.
     amount_of_external_allocated_memory_at_last_global_gc_ =
         amount_of_external_allocated_memory_;
-    old_generation_allocation_limit_ = OldGenerationAllocationLimit(
-        PromotedSpaceSizeOfObjects(), freed_global_handles);
+    SetOldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(),
+                                    freed_global_handles, true);
     // We finished a marking cycle. We can uncommit the marking deque until
     // we start marking again.
     mark_compact_collector_.UncommitMarkingDeque();
   }
 
   {
     GCCallbacksScope scope(this);
     if (scope.CheckReenter()) {
       AllowHeapAllocation allow_allocation;
       GCTracer::Scope scope(tracer(), GCTracer::Scope::EXTERNAL);
@@ skipping 3370 matching lines @@
               gc_idle_time_handler_.ShouldDoFinalIncrementalMarkCompact(
                   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");
     return true;
   }
   return false;
 }
 
 
-bool Heap::WorthActivatingIncrementalMarking() {
-  return incremental_marking()->IsStopped() &&
-         incremental_marking()->WorthActivating() && NextGCIsLikelyToBeFull();
-}
-
-
 static double MonotonicallyIncreasingTimeInMs() {
   return V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() *
          static_cast<double>(base::Time::kMillisecondsPerSecond);
 }
 
 
 bool Heap::IdleNotification(int idle_time_in_ms) {
   return IdleNotification(
       V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() +
       (static_cast<double>(idle_time_in_ms) /
@@ skipping 624 matching lines @@
 
 int64_t Heap::PromotedExternalMemorySize() {
   if (amount_of_external_allocated_memory_ <=
       amount_of_external_allocated_memory_at_last_global_gc_)
     return 0;
   return amount_of_external_allocated_memory_ -
          amount_of_external_allocated_memory_at_last_global_gc_;
 }
 
 
-intptr_t Heap::OldGenerationAllocationLimit(intptr_t old_gen_size,
-                                            int freed_global_handles) {
+void Heap::SetOldGenerationAllocationLimit(intptr_t old_gen_size,
+                                           int freed_global_handles,
+                                           bool weak_callbacks_completed) {
   const int kMaxHandles = 1000;
   const int kMinHandles = 100;
   double min_factor = 1.1;
   double max_factor = 4;
   // We set the old generation growing factor to 2 to grow the heap slower on
   // memory-constrained devices.
   if (max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice) {
     max_factor = 2;
   }
   // If there are many freed global handles, then the next full GC will
@@ skipping 13 matching lines @@
                  (kMaxHandles - kMinHandles);
   }
 
   if (FLAG_stress_compaction ||
       mark_compact_collector()->reduce_memory_footprint_) {
     factor = min_factor;
   }
 
   intptr_t limit = static_cast<intptr_t>(old_gen_size * factor);
   limit = Max(limit, kMinimumOldGenerationAllocationLimit);
-  limit += new_space_.Capacity();
-  intptr_t halfway_to_the_max = (old_gen_size + max_old_generation_size_) / 2;
-  return Min(limit, halfway_to_the_max);
+
+  old_generation_allocation_limit_ = limit + new_space_.Capacity();

[ulan, 2015/04/07 13:27:19]

Should we enforce that old_generation_allocation_limit_ <
old_generation_committed_memory_limit_ ?

[Erik Corry Chromium.org, 2015/04/09 12:26:15]

I think since we consult both, it is clearer to let them be independent.

+
+  // The committed memory limit is halfway from the current live object count
+  // to the max size.  This means that if half of our allowed extra memory is
+  // currently taken by fragmentation we will immediately start another
+  // incremental GC.  If there is no fragmentation, we will start incremental
+  // GC when we have committed half the allowed extra memory.  This limit will
+  // be compared against the committed memory, ie including fragmentation.
+  intptr_t commit_limit_basis = old_gen_size;

[ulan, 2015/04/07 13:27:19]

This can lead to never-ending GCs even if fragmentation is moderate.
Example:
max_old_generation_size = 1400
old_gen_size = 800
committed = 1101

This will immediately start another GC and there is no guarantee "committed"
will decrease.

I think commit_limit_basis should always be CommittedOldGenerationMemory().

[Erik Corry Chromium.org, 2015/04/09 12:26:15]

Done.

+  if (FLAG_never_compact || !FLAG_compact_code_space) {
+    // No point in provoking GCs to get rid of fragmentation if we can't
+    // actually get rid of fragmentation.  In this case set the limit higher.
+    commit_limit_basis = CommittedOldGenerationMemory();
+  }
+  old_generation_committed_memory_limit_ =
+      commit_limit_basis / 2 + max_old_generation_size_ / 2;
+
+  if (weak_callbacks_completed && FLAG_trace_gc) {
+    PrintPID("%8.0f ms: ", isolate()->time_millis_since_init());
+    PrintF("Next GC at %.1f (%.1f) -> %.1f (%.1f)\n", old_gen_size * 1.0 / MB,
+           CommittedOldGenerationMemory() * 1.0 / MB, limit * 1.0 / MB,
+           old_generation_committed_memory_limit_ * 1.0 / MB);
+  }
 }
 
 
 void Heap::EnableInlineAllocation() {
   if (!inline_allocation_disabled_) return;
   inline_allocation_disabled_ = false;
 
   // Update inline allocation limit for new space.
   new_space()->UpdateInlineAllocationLimit(0);
 }
@@ skipping 1126 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