[heap] Scale max 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 <vector>
 
@@ skipping 609 matching lines @@
 #else
   static const int kPointerMultiplier = i::kPointerSize / 4;
 #endif
 
   // The new space size has to be a power of 2. Sizes are in MB.
   static const int kMinSemiSpaceSize = 1 * kPointerMultiplier;
   static const int kMaxSemiSpaceSize = 8 * kPointerMultiplier;
 
   // The old space size has to be a multiple of Page::kPageSize.
   // Sizes are in MB.
-  static const int kMinOldSpaceSize = 128 * kPointerMultiplier;
-  static const int kMaxOldSpaceSize = 1024 * kPointerMultiplier;
+  static const int kMinOldGenerationSize = 128 * kPointerMultiplier;
+  static const int kMaxOldGenerationSize = 1024 * kPointerMultiplier;
 
   static const int kTraceRingBufferSize = 512;
   static const int kStacktraceBufferSize = 512;
 
   V8_EXPORT_PRIVATE static const double kMinHeapGrowingFactor;
   V8_EXPORT_PRIVATE static const double kMaxHeapGrowingFactor;
   static const double kMaxHeapGrowingFactorMemoryConstrained;
   static const double kMaxHeapGrowingFactorIdle;
   static const double kConservativeHeapGrowingFactor;
   static const double kTargetMutatorUtilization;
@@ skipping 70 matching lines @@
       case SCAVENGER:
         return "Scavenger";
       case MARK_COMPACTOR:
         return "Mark-Compact";
       case MINOR_MARK_COMPACTOR:
         return "Minor Mark-Compact";
     }
     return "Unknown collector";
   }
 
+  V8_EXPORT_PRIVATE static double MaxHeapGrowingFactor(
+      size_t max_old_generation_size);
   V8_EXPORT_PRIVATE static double HeapGrowingFactor(double gc_speed,
-                                                    double mutator_speed);
+                                                    double mutator_speed,
+                                                    double max_factor);
 
   // Copy block of memory from src to dst. Size of block should be aligned
   // by pointer size.
   static inline void CopyBlock(Address dst, Address src, int byte_size);
 
   // Determines a static visitor id based on the given {map} that can then be
   // stored on the map to facilitate fast dispatch for {StaticVisitorBase}.
   static int GetStaticVisitorIdForMap(Map* map);
 
   // Notifies the heap that is ok to start marking or other activities that
@@ skipping 208 matching lines @@
   bool deserialization_complete() const { return deserialization_complete_; }
 
   bool HasLowAllocationRate();
   bool HasHighFragmentation();
   bool HasHighFragmentation(size_t used, size_t committed);
 
   void ActivateMemoryReducerIfNeeded();
 
   bool ShouldOptimizeForMemoryUsage();
 
-  bool IsLowMemoryDevice() {
-    const int kMaxOldSpaceSizeLowMemoryDevice = 128 * kPointerMultiplier;
-    return max_old_generation_size_ <= kMaxOldSpaceSizeLowMemoryDevice;
-  }
-
-  bool IsMemoryConstrainedDevice() {
-    const int kMaxOldSpaceSizeMediumMemoryDevice = 256 * kPointerMultiplier;
-    return max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice;
-  }
-
   bool HighMemoryPressure() {
     return memory_pressure_level_.Value() != MemoryPressureLevel::kNone;
   }
 
   size_t HeapLimitForDebugging() {
     const size_t kDebugHeapSizeFactor = 4;
     size_t max_limit = std::numeric_limits<size_t>::max() / 4;
     return Min(max_limit,
                initial_max_old_generation_size_ * kDebugHeapSizeFactor);
   }
@@ skipping 380 matching lines @@
   }
   size_t MaxSemiSpaceSize() { return max_semi_space_size_; }
   size_t InitialSemiSpaceSize() { return initial_semispace_size_; }
   size_t MaxOldGenerationSize() { return max_old_generation_size_; }
 
   static size_t ComputeMaxOldGenerationSize(uint64_t physical_memory) {
     const int old_space_physical_memory_factor = 4;
     int computed_size =
         static_cast<int>(physical_memory / i::MB /
                          old_space_physical_memory_factor * kPointerMultiplier);
-    return Max(Min(computed_size, kMaxOldSpaceSize), kMinOldSpaceSize);
+    return Max(Min(computed_size, kMaxOldGenerationSize),
+               kMinOldGenerationSize);
   }
 
   static size_t ComputeMaxSemiSpaceSize(uint64_t physical_memory) {
     const uint64_t min_physical_memory = 512 * MB;
     const uint64_t max_physical_memory = 2 * static_cast<uint64_t>(GB);
 
     uint64_t capped_physical_memory =
         Max(Min(physical_memory, max_physical_memory), min_physical_memory);
     // linearly scale max semi-space size: (X-A)/(B-A)*(D-C)+C
     return static_cast<int>(((capped_physical_memory - min_physical_memory) *
@@ skipping 1301 matching lines @@
   friend class PagedSpace;
   DISALLOW_COPY_AND_ASSIGN(AllocationObserver);
 };
 
 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_