[heap] Scale max heap growing factor.

test/unittests/heap/heap-unittest.cc

 // Copyright 2014 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 <cmath>
 #include <iostream>
 #include <limits>
 
 #include "src/objects.h"
 #include "src/objects-inl.h"
@@ skipping 15 matching lines @@
 
 void CheckEqualRounded(double expected, double actual) {
   expected = Round(expected);
   actual = Round(actual);
   EXPECT_DOUBLE_EQ(expected, actual);
 }
 
 
 TEST(Heap, HeapGrowingFactor) {
   CheckEqualRounded(Heap::kMaxHeapGrowingFactor,
-                    Heap::HeapGrowingFactor(34, 1));
-  CheckEqualRounded(3.553, Heap::HeapGrowingFactor(45, 1));
-  CheckEqualRounded(2.830, Heap::HeapGrowingFactor(50, 1));
-  CheckEqualRounded(1.478, Heap::HeapGrowingFactor(100, 1));
-  CheckEqualRounded(1.193, Heap::HeapGrowingFactor(200, 1));
-  CheckEqualRounded(1.121, Heap::HeapGrowingFactor(300, 1));
-  CheckEqualRounded(Heap::HeapGrowingFactor(300, 1),
-                    Heap::HeapGrowingFactor(600, 2));
+                    Heap::HeapGrowingFactor(34, 1, 4.0));
+  CheckEqualRounded(3.553, Heap::HeapGrowingFactor(45, 1, 4.0));
+  CheckEqualRounded(2.830, Heap::HeapGrowingFactor(50, 1, 4.0));
+  CheckEqualRounded(1.478, Heap::HeapGrowingFactor(100, 1, 4.0));
+  CheckEqualRounded(1.193, Heap::HeapGrowingFactor(200, 1, 4.0));
+  CheckEqualRounded(1.121, Heap::HeapGrowingFactor(300, 1, 4.0));
+  CheckEqualRounded(Heap::HeapGrowingFactor(300, 1, 4.0),
+                    Heap::HeapGrowingFactor(600, 2, 4.0));
   CheckEqualRounded(Heap::kMinHeapGrowingFactor,
-                    Heap::HeapGrowingFactor(400, 1));
+                    Heap::HeapGrowingFactor(400, 1, 4.0));
+}
+
+TEST(Heap, MaxHeapGrowingFactor) {
+  CheckEqualRounded(
+      1.3, Heap::MaxHeapGrowingFactor(Heap::kMinOldGenerationSize * MB));
+  CheckEqualRounded(
+      1.600, Heap::MaxHeapGrowingFactor(Heap::kMaxOldGenerationSize / 2 * MB));
+  CheckEqualRounded(
+      1.999,
+      Heap::MaxHeapGrowingFactor(
+          (Heap::kMaxOldGenerationSize - Heap::kPointerMultiplier) * MB));
+  CheckEqualRounded(4.0,
+                    Heap::MaxHeapGrowingFactor(
+                        static_cast<size_t>(Heap::kMaxOldGenerationSize) * MB));
 }
 
 TEST(Heap, SemiSpaceSize) {
   uint64_t configurations[][2] = {
       {0, 1 * i::Heap::kPointerMultiplier},
       {512 * i::MB, 1 * i::Heap::kPointerMultiplier},
       {1 * i::GB, 3 * i::Heap::kPointerMultiplier},
       {2 * static_cast<uint64_t>(i::GB), i::Heap::kMaxSemiSpaceSize},
       {4 * static_cast<uint64_t>(i::GB), i::Heap::kMaxSemiSpaceSize},
       {8 * static_cast<uint64_t>(i::GB), i::Heap::kMaxSemiSpaceSize}};
 
   for (auto configuration : configurations) {
     ASSERT_EQ(configuration[1],
               static_cast<uint64_t>(
                   i::Heap::ComputeMaxSemiSpaceSize(configuration[0])));
   }
 }
 
 TEST(Heap, OldGenerationSize) {
   uint64_t configurations[][2] = {
-      {0, i::Heap::kMinOldSpaceSize},
-      {512, i::Heap::kMinOldSpaceSize},
+      {0, i::Heap::kMinOldGenerationSize},
+      {512, i::Heap::kMinOldGenerationSize},
       {1 * i::GB, 256 * i::Heap::kPointerMultiplier},
       {2 * static_cast<uint64_t>(i::GB), 512 * i::Heap::kPointerMultiplier},
-      {4 * static_cast<uint64_t>(i::GB), i::Heap::kMaxOldSpaceSize},
-      {8 * static_cast<uint64_t>(i::GB), i::Heap::kMaxOldSpaceSize}};
+      {4 * static_cast<uint64_t>(i::GB), i::Heap::kMaxOldGenerationSize},
+      {8 * static_cast<uint64_t>(i::GB), i::Heap::kMaxOldGenerationSize}};
 
   for (auto configuration : configurations) {
     ASSERT_EQ(configuration[1],
               static_cast<uint64_t>(
                   i::Heap::ComputeMaxOldGenerationSize(configuration[0])));
   }
 }
 
 }  // namespace internal
 }  // namespace v8