Take into account freed global handles and fragmentation when computing heap growing factor.

src/heap/heap.h

 // 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.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 1140 matching lines @@
   static const int kMaxExecutableSizeLowMemoryDevice = 96 * kPointerMultiplier;
   static const int kMaxExecutableSizeMediumMemoryDevice =
       192 * kPointerMultiplier;
   static const int kMaxExecutableSizeHighMemoryDevice =
       256 * kPointerMultiplier;
   static const int kMaxExecutableSizeHugeMemoryDevice =
       256 * kPointerMultiplier;
 
   static const int kTraceRingBufferSize = 512;
 
+  // These constant are used in HeapGrowingFactor() and to estimate if
+  // the next GC is likely to free more memory.
+  static const int kLowFragmentationPercent = 40;
+  static const int kHighFragmentationPercent = 80;
+
   // Calculates the allocation limit based on a given growing factor and a
   // given old generation size.
   intptr_t CalculateOldGenerationAllocationLimit(double factor,
                                                  intptr_t old_gen_size);
 
   // Sets the allocation limit to trigger the next full garbage collection.
-  void SetOldGenerationAllocationLimit(intptr_t old_gen_size,
-                                       size_t current_allocation_throughput);
+  void SetOldGenerationAllocationLimit(intptr_t old_gen_size, double factor);
+
+  // Calculates the factor for old generation allocation limit.
+  double HeapGrowingFactor(int freed_global_handles,
+                           size_t allocation_throughput,
+                           int fragmentation_percent);
+
+  // Percentage of free space in old generation space that have compaction
+  // enabled.
+  int FragmentationOfCompactedSpacesInPercent() {
+    size_t live = old_space_->SizeOfObjects();
+    size_t committed = old_space_->CommittedMemory();
+    if (FLAG_compact_code_space && FLAG_incremental_code_compaction) {
+      live += code_space_->SizeOfObjects();
+      committed += code_space_->CommittedMemory();
+    }
+    // Allow slack of one page for each space.

[Hannes Payer (out of office), 2015/06/02 08:23:00]

I think this function should only return the real percent of fragmentation. I
would prefer passing in the slack as an "additional live memory" parameter.
FLAG_never_compact should be applied outside as well. WDYT?

[ulan, 2015/06/02 12:27:05]

Done.

+    const size_t kSlack = 2 * Page::kPageSize;
+    if (live + kSlack >= committed || FLAG_never_compact) return 0;
+    return 100 - static_cast<int>(100.0 * live / committed);
+  }
 
   // Indicates whether inline bump-pointer allocation has been disabled.
   bool inline_allocation_disabled() { return inline_allocation_disabled_; }
 
   // Switch whether inline bump-pointer allocation should be used.
   void EnableInlineAllocation();
   void DisableInlineAllocation();
 
   // Implements the corresponding V8 API function.
   bool IdleNotification(double deadline_in_seconds);
@@ skipping 1567 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_