[heap] Fix global memory scheduling

Rework limit computation:
- Model controller as static classes based on traits.
- Compute growing factors for both controllers and pick the
  larger growing factor for both controllers.
- Factor out limit computation in its own function.

Bug: chromium:948807
Change-Id: Id466a66d7aa573de91ad388ea9218e9f6721d19a
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1627534
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61801}

src/heap/heap-controller.cc

@@ -10,6 +10,49 @@
 namespace v8 {
 namespace internal {
 
+template <typename Trait>
+double MemoryController<Trait>::GrowingFactor(Heap* heap, size_t max_heap_size,
+                                              double gc_speed,
+                                              double mutator_speed) {
+  const double max_factor = MaxGrowingFactor(max_heap_size);
+  const double factor =
+      DynamicGrowingFactor(gc_speed, mutator_speed, max_factor);
+  if (FLAG_trace_gc_verbose) {
+    Isolate::FromHeap(heap)->PrintWithTimestamp(
+        "[%s] factor %.1f based on mu=%.3f, speed_ratio=%.f "
+        "(gc=%.f, mutator=%.f)\n",
+        Trait::kName, factor, Trait::kTargetMutatorUtilization,
+        gc_speed / mutator_speed, gc_speed, mutator_speed);
+  }
+  return factor;
+}
+
+template <typename Trait>
+double MemoryController<Trait>::MaxGrowingFactor(size_t max_heap_size) {
+  constexpr double kMinSmallFactor = 1.3;
+  constexpr double kMaxSmallFactor = 2.0;
+  constexpr double kHighFactor = 4.0;
+
+  size_t max_size_in_mb = max_heap_size / MB;
+  max_size_in_mb = Max(max_size_in_mb, Trait::kMinSize);
+
+  // If we are on a device with lots of memory, we allow a high heap
+  // growing factor.
+  if (max_size_in_mb >= Trait::kMaxSize) {
+    return kHighFactor;
+  }
+
+  DCHECK_GE(max_size_in_mb, Trait::kMinSize);
+  DCHECK_LT(max_size_in_mb, Trait::kMaxSize);
+
+  // On smaller devices we linearly scale the factor: (X-A)/(B-A)*(D-C)+C
+  double factor = (max_size_in_mb - Trait::kMinSize) *
+                      (kMaxSmallFactor - kMinSmallFactor) /
+                      (Trait::kMaxSize - Trait::kMinSize) +
+                  kMinSmallFactor;
+  return factor;
+}
+
 // Given GC speed in bytes per ms, the allocation throughput in bytes per ms
 // (mutator speed), this function returns the heap growing factor that will
 // achieve the target_mutator_utilization_ if the GC speed and the mutator speed
@@ -49,35 +92,49 @@ namespace internal {
 //   F * (1 - MU / (R * (1 - MU))) = 1
 //   F * (R * (1 - MU) - MU) / (R * (1 - MU)) = 1
 //   F = R * (1 - MU) / (R * (1 - MU) - MU)
-double MemoryController::GrowingFactor(double gc_speed, double mutator_speed,
+template <typename Trait>
+double MemoryController<Trait>::DynamicGrowingFactor(double gc_speed,
+                                                     double mutator_speed,
                                                      double max_factor) {
-  DCHECK_LE(min_growing_factor_, max_factor);
-  DCHECK_GE(max_growing_factor_, max_factor);
+  DCHECK_LE(Trait::kMinGrowingFactor, max_factor);
+  DCHECK_GE(Trait::kMaxGrowingFactor, max_factor);
   if (gc_speed == 0 || mutator_speed == 0) return max_factor;
 
   const double speed_ratio = gc_speed / mutator_speed;
 
-  const double a = speed_ratio * (1 - target_mutator_utlization_);
-  const double b = speed_ratio * (1 - target_mutator_utlization_) -
-                   target_mutator_utlization_;
+  const double a = speed_ratio * (1 - Trait::kTargetMutatorUtilization);
+  const double b = speed_ratio * (1 - Trait::kTargetMutatorUtilization) -
+                   Trait::kTargetMutatorUtilization;
 
   // The factor is a / b, but we need to check for small b first.
   double factor = (a < b * max_factor) ? a / b : max_factor;
   factor = Min(factor, max_factor);
-  factor = Max(factor, min_growing_factor_);
+  factor = Max(factor, Trait::kMinGrowingFactor);
   return factor;
 }
 
-size_t MemoryController::CalculateAllocationLimitBase(
-    size_t curr_size, size_t max_size, double factor, size_t additional_bytes,
+template <typename Trait>
+size_t MemoryController<Trait>::MinimumAllocationLimitGrowingStep(
     Heap::HeapGrowingMode growing_mode) {
+  const size_t kRegularAllocationLimitGrowingStep = 8;
+  const size_t kLowMemoryAllocationLimitGrowingStep = 2;
+  size_t limit = (Page::kPageSize > MB ? Page::kPageSize : MB);
+  return limit * (growing_mode == Heap::HeapGrowingMode::kConservative
+                      ? kLowMemoryAllocationLimitGrowingStep
+                      : kRegularAllocationLimitGrowingStep);
+}
+
+template <typename Trait>
+size_t MemoryController<Trait>::CalculateAllocationLimit(
+    Heap* heap, size_t current_size, size_t max_size, size_t new_space_capacity,
+    double factor, Heap::HeapGrowingMode growing_mode) {
   switch (growing_mode) {
     case Heap::HeapGrowingMode::kConservative:
     case Heap::HeapGrowingMode::kSlow:
-      factor = Min(factor, conservative_growing_factor_);
+      factor = Min(factor, Trait::kConservativeGrowingFactor);
       break;
     case Heap::HeapGrowingMode::kMinimal:
-      factor = min_growing_factor_;
+      factor = Trait::kMinGrowingFactor;
       break;
     case Heap::HeapGrowingMode::kDefault:
       break;
@@ -87,119 +144,33 @@ size_t MemoryController::CalculateAllocationLimitBase(
     factor = 1.0 + FLAG_heap_growing_percent / 100.0;
   }
 
+  if (FLAG_heap_growing_percent > 0) {
+    factor = 1.0 + FLAG_heap_growing_percent / 100.0;
+  }
+
   CHECK_LT(1.0, factor);
-  CHECK_LT(0, curr_size);
+  CHECK_LT(0, current_size);
   const uint64_t limit =
-      Max(static_cast<uint64_t>(curr_size * factor),
-          static_cast<uint64_t>(curr_size) +
+      Max(static_cast<uint64_t>(current_size * factor),
+          static_cast<uint64_t>(current_size) +
               MinimumAllocationLimitGrowingStep(growing_mode)) +
-      additional_bytes;
+      new_space_capacity;
   const uint64_t halfway_to_the_max =
-      (static_cast<uint64_t>(curr_size) + max_size) / 2;
+      (static_cast<uint64_t>(current_size) + max_size) / 2;
   const size_t result = static_cast<size_t>(Min(limit, halfway_to_the_max));
   if (FLAG_trace_gc_verbose) {
-    Isolate::FromHeap(heap_)->PrintWithTimestamp(
+    Isolate::FromHeap(heap)->PrintWithTimestamp(
         "[%s] Limit: old size: %zu KB, new limit: %zu KB (%.1f)\n",
-        ControllerName(), curr_size / KB, result / KB, factor);
+        Trait::kName, current_size / KB, result / KB, factor);
   }
   return result;
 }
 
-size_t MemoryController::MinimumAllocationLimitGrowingStep(
-    Heap::HeapGrowingMode growing_mode) {
-  const size_t kRegularAllocationLimitGrowingStep = 8;
-  const size_t kLowMemoryAllocationLimitGrowingStep = 2;
-  size_t limit = (Page::kPageSize > MB ? Page::kPageSize : MB);
-  return limit * (growing_mode == Heap::HeapGrowingMode::kConservative
-                      ? kLowMemoryAllocationLimitGrowingStep
-                      : kRegularAllocationLimitGrowingStep);
-}
-
-double HeapController::MaxGrowingFactor(size_t curr_max_size) {
-  constexpr double kMinSmallFactor = 1.3;
-  constexpr double kMaxSmallFactor = 2.0;
-  constexpr double kHighFactor = 4.0;
-
-  size_t max_size_in_mb = curr_max_size / MB;
-  max_size_in_mb = Max(max_size_in_mb, kMinSize);
-
-  // If we are on a device with lots of memory, we allow a high heap
-  // growing factor.
-  if (max_size_in_mb >= kMaxSize) {
-    return kHighFactor;
-  }
-
-  DCHECK_GE(max_size_in_mb, kMinSize);
-  DCHECK_LT(max_size_in_mb, kMaxSize);
-
-  // On smaller devices we linearly scale the factor: (X-A)/(B-A)*(D-C)+C
-  double factor = (max_size_in_mb - kMinSize) *
-                      (kMaxSmallFactor - kMinSmallFactor) /
-                      (kMaxSize - kMinSize) +
-                  kMinSmallFactor;
-  return factor;
-}
-
-double GlobalMemoryController::MaxGrowingFactor(size_t curr_max_size) {
-  constexpr double kMinSmallFactor = 1.3;
-  constexpr double kMaxSmallFactor = 2.0;
-  constexpr double kHighFactor = 4.0;
-
-  size_t max_size_in_mb = curr_max_size / MB;
-  max_size_in_mb = Max(max_size_in_mb, kMinSize);
-
-  // If we are on a device with lots of memory, we allow a high heap
-  // growing factor.
-  if (max_size_in_mb >= kMaxSize) {
-    return kHighFactor;
-  }
-
-  DCHECK_GE(max_size_in_mb, kMinSize);
-  DCHECK_LT(max_size_in_mb, kMaxSize);
-
-  // On smaller devices we linearly scale the factor: (X-A)/(B-A)*(D-C)+C
-  double factor = (max_size_in_mb - kMinSize) *
-                      (kMaxSmallFactor - kMinSmallFactor) /
-                      (kMaxSize - kMinSize) +
-                  kMinSmallFactor;
-  return factor;
-}
-
-size_t HeapController::CalculateAllocationLimit(
-    size_t curr_size, size_t max_size, double gc_speed, double mutator_speed,
-    size_t new_space_capacity, Heap::HeapGrowingMode growing_mode) {
-  const double max_factor = MaxGrowingFactor(max_size);
-  const double factor = GrowingFactor(gc_speed, mutator_speed, max_factor);
-
-  if (FLAG_trace_gc_verbose) {
-    Isolate::FromHeap(heap_)->PrintWithTimestamp(
-        "[%s] factor %.1f based on mu=%.3f, speed_ratio=%.f "
-        "(gc=%.f, mutator=%.f)\n",
-        ControllerName(), factor, target_mutator_utlization_,
-        gc_speed / mutator_speed, gc_speed, mutator_speed);
-  }
-
-  return CalculateAllocationLimitBase(curr_size, max_size, factor,
-                                      new_space_capacity, growing_mode);
-}
-
-size_t GlobalMemoryController::CalculateAllocationLimit(
-    size_t curr_size, size_t max_size, double gc_speed, double mutator_speed,
-    size_t new_space_capacity, Heap::HeapGrowingMode growing_mode) {
-  const double max_factor = MaxGrowingFactor(max_size);
-  const double factor = GrowingFactor(gc_speed, mutator_speed, max_factor);
-
-  if (FLAG_trace_gc_verbose) {
-    Isolate::FromHeap(heap_)->PrintWithTimestamp(
-        "[%s] factor %.1f based on mu=%.3f, speed_ratio=%.f "
-        "(gc=%.f, mutator=%.f)\n",
-        ControllerName(), factor, target_mutator_utlization_,
-        gc_speed / mutator_speed, gc_speed, mutator_speed);
-  }
+template class V8_EXPORT_PRIVATE MemoryController<V8HeapTrait>;
+template class V8_EXPORT_PRIVATE MemoryController<GlobalMemoryTrait>;
 
-  return CalculateAllocationLimitBase(curr_size, max_size, factor,
-                                      new_space_capacity, growing_mode);
-}
+const char* V8HeapTrait::kName = "HeapController";
+const char* GlobalMemoryTrait::kName = "GlobalMemoryController";
 
 }  // namespace internal
 }  // namespace v8

src/heap/heap-controller.h

@@ -13,85 +13,48 @@
 namespace v8 {
 namespace internal {
 
-class V8_EXPORT_PRIVATE MemoryController {
- public:
-  // Computes the growing step when the limit increases.
-  static size_t MinimumAllocationLimitGrowingStep(
-      Heap::HeapGrowingMode growing_mode);
-
-  virtual ~MemoryController() = default;
-
- protected:
-  MemoryController(Heap* heap, double min_growing_factor,
-                   double max_growing_factor,
-                   double conservative_growing_factor,
-                   double target_mutator_utlization)
-      : heap_(heap),
-        min_growing_factor_(min_growing_factor),
-        max_growing_factor_(max_growing_factor),
-        conservative_growing_factor_(conservative_growing_factor),
-        target_mutator_utlization_(target_mutator_utlization) {}
-
-  // Computes the allocation limit to trigger the next garbage collection.
-  size_t CalculateAllocationLimitBase(size_t curr_size, size_t max_size,
-                                      double factor, size_t additional_bytes,
-                                      Heap::HeapGrowingMode growing_mode);
-
-  double GrowingFactor(double gc_speed, double mutator_speed,
-                       double max_factor);
-
-  virtual const char* ControllerName() = 0;
-
-  Heap* const heap_;
-  const double min_growing_factor_;
-  const double max_growing_factor_;
-  const double conservative_growing_factor_;
-  const double target_mutator_utlization_;
-};
-
-class V8_EXPORT_PRIVATE HeapController : public MemoryController {
- public:
+struct BaseControllerTrait {
   // Sizes are in MB.
   static constexpr size_t kMinSize = 128 * Heap::kPointerMultiplier;
   static constexpr size_t kMaxSize = 1024 * Heap::kPointerMultiplier;
 
-  explicit HeapController(Heap* heap)
-      : MemoryController(heap, 1.1, 4.0, 1.3, 0.97) {}
-
-  size_t CalculateAllocationLimit(size_t curr_size, size_t max_size,
-                                  double gc_speed, double mutator_speed,
-                                  size_t new_space_capacity,
-                                  Heap::HeapGrowingMode growing_mode);
-
- protected:
-  double MaxGrowingFactor(size_t curr_max_size);
+  static constexpr double kMinGrowingFactor = 1.1;
+  static constexpr double kMaxGrowingFactor = 4.0;
+  static constexpr double kConservativeGrowingFactor = 1.3;
+  static constexpr double kTargetMutatorUtilization = 0.97;
+};
 
-  const char* ControllerName() override { return "HeapController"; }
+struct V8HeapTrait : public BaseControllerTrait {
+  static const char* kName;
+};
 
-  FRIEND_TEST(HeapControllerTest, HeapGrowingFactor);
-  FRIEND_TEST(HeapControllerTest, MaxHeapGrowingFactor);
-  FRIEND_TEST(HeapControllerTest, MaxOldGenerationSize);
-  FRIEND_TEST(HeapControllerTest, OldGenerationAllocationLimit);
+struct GlobalMemoryTrait : public BaseControllerTrait {
+  static const char* kName;
 };
 
-class V8_EXPORT_PRIVATE GlobalMemoryController : public MemoryController {
+template <typename Trait>
+class V8_EXPORT_PRIVATE MemoryController : public AllStatic {
  public:
-  // Sizes are in MB.
-  static constexpr size_t kMinSize = 128 * Heap::kPointerMultiplier;
-  static constexpr size_t kMaxSize = 1024 * Heap::kPointerMultiplier;
+  // Computes the growing step when the limit increases.
+  static size_t MinimumAllocationLimitGrowingStep(
+      Heap::HeapGrowingMode growing_mode);
 
-  explicit GlobalMemoryController(Heap* heap)
-      : MemoryController(heap, 1.1, 4.0, 1.3, 0.97) {}
+  static double GrowingFactor(Heap* heap, size_t max_heap_size, double gc_speed,
+                              double mutator_speed);
 
-  size_t CalculateAllocationLimit(size_t curr_size, size_t max_size,
-                                  double gc_speed, double mutator_speed,
+  static size_t CalculateAllocationLimit(Heap* heap, size_t current_size,
+                                         size_t max_size,
                                          size_t new_space_capacity,
+                                         double factor,
                                          Heap::HeapGrowingMode growing_mode);
 
- protected:
-  double MaxGrowingFactor(size_t curr_max_size);
+ private:
+  static double MaxGrowingFactor(size_t max_heap_size);
+  static double DynamicGrowingFactor(double gc_speed, double mutator_speed,
+                                     double max_factor);
 
-  const char* ControllerName() override { return "GlobalMemoryController"; }
+  FRIEND_TEST(MemoryControllerTest, HeapGrowingFactor);
+  FRIEND_TEST(MemoryControllerTest, MaxHeapGrowingFactor);
 };
 
 }  // namespace internal

src/heap/heap.cc

@@ -212,7 +212,7 @@ size_t Heap::ComputeMaxOldGenerationSize(uint64_t physical_memory) {
   size_t computed_size = static_cast<size_t>(physical_memory / i::MB /
                                              old_space_physical_memory_factor *
                                              kPointerMultiplier);
-  size_t max_size_in_mb = HeapController::kMaxSize;
+  size_t max_size_in_mb = V8HeapTrait::kMaxSize;
 
   // Finch experiment: Increase the heap size from 2GB to 4GB for 64-bit
   // systems with physical memory bigger than 16GB.
@@ -223,7 +223,7 @@ size_t Heap::ComputeMaxOldGenerationSize(uint64_t physical_memory) {
     max_size_in_mb = 4096;  // 4GB
   }
 
-  return Max(Min(computed_size, max_size_in_mb), HeapController::kMinSize);
+  return Max(Min(computed_size, max_size_in_mb), V8HeapTrait::kMinSize);
 }
 
 size_t Heap::Capacity() {
@@ -1928,28 +1928,65 @@ bool Heap::PerformGarbageCollection(
   // Update relocatables.
   Relocatable::PostGarbageCollectionProcessing(isolate_);
 
-  double gc_speed = tracer()->CombinedMarkCompactSpeedInBytesPerMillisecond();
-  double mutator_speed =
-      tracer()->CurrentOldGenerationAllocationThroughputInBytesPerMillisecond();
-  size_t old_gen_size = OldGenerationSizeOfObjects();
+  RecomputeLimits(collector);
 
-  double global_mutator_speed;
-  double global_gc_speed;
-  size_t global_memory_size;
+  {
+    GCCallbacksScope scope(this);
+    if (scope.CheckReenter()) {
+      AllowHeapAllocation allow_allocation;
+      AllowJavascriptExecution allow_js(isolate());
+      TRACE_GC(tracer(), GCTracer::Scope::HEAP_EXTERNAL_EPILOGUE);
+      VMState<EXTERNAL> state(isolate_);
+      HandleScope handle_scope(isolate_);
+      CallGCEpilogueCallbacks(gc_type, gc_callback_flags);
+    }
+  }
+
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    VerifyStringTable(this->isolate());
+  }
+#endif
+
+  return freed_global_handles > 0;
+}
+
+void Heap::RecomputeLimits(GarbageCollector collector) {
+  if (!((collector == MARK_COMPACTOR) ||
+        (HasLowYoungGenerationAllocationRate() &&
+         old_generation_size_configured_))) {
+    return;
+  }
+
+  double v8_gc_speed =
+      tracer()->CombinedMarkCompactSpeedInBytesPerMillisecond();
+  double v8_mutator_speed =
+      tracer()->CurrentOldGenerationAllocationThroughputInBytesPerMillisecond();
+  double v8_growing_factor = MemoryController<V8HeapTrait>::GrowingFactor(
+      this, max_old_generation_size_, v8_gc_speed, v8_mutator_speed);
+  double global_growing_factor = 0;
   if (UseGlobalMemoryScheduling()) {
-    global_mutator_speed = GCTracer::CombineSpeedsInBytesPerMillisecond(
-        mutator_speed,
+    double embedder_gc_speed =
         local_embedder_heap_tracer()
             ? tracer()
                   ->CurrentEmbedderAllocationThroughputInBytesPerMillisecond()
-            : 0.0);
-    global_gc_speed = GCTracer::CombineSpeedsInBytesPerMillisecond(
-        gc_speed, local_embedder_heap_tracer()
+            : 0.0;
+    double embedder_speed = local_embedder_heap_tracer()
                                 ? tracer()->EmbedderSpeedInBytesPerMillisecond()
-                      : 0.0);
-    global_memory_size = GlobalSizeOfObjects();
+                                : 0.0;
+    double embedder_growing_factor =
+        (embedder_gc_speed > 0 && embedder_speed > 0)
+            ? MemoryController<GlobalMemoryTrait>::GrowingFactor(
+                  this, max_global_memory_size_, embedder_gc_speed,
+                  embedder_speed)
+            : 0;
+    global_growing_factor = Max(v8_growing_factor, embedder_growing_factor);
   }
 
+  size_t old_gen_size = OldGenerationSizeOfObjects();
+  size_t new_space_capacity = new_space()->Capacity();
+  HeapGrowingMode mode = CurrentHeapGrowingMode();
+
   if (collector == MARK_COMPACTOR) {
     // Register the amount of external allocated memory.
     isolate()->isolate_data()->external_memory_at_last_mark_compact_ =
@@ -1959,60 +1996,40 @@ bool Heap::PerformGarbageCollection(
         kExternalAllocationSoftLimit;
 
     old_generation_allocation_limit_ =
-        heap_controller()->CalculateAllocationLimit(
-            old_gen_size, max_old_generation_size_, gc_speed, mutator_speed,
-            new_space()->Capacity(), CurrentHeapGrowingMode());
+        MemoryController<V8HeapTrait>::CalculateAllocationLimit(
+            this, old_gen_size, max_old_generation_size_, new_space_capacity,
+            v8_growing_factor, mode);
     if (UseGlobalMemoryScheduling()) {
+      DCHECK_GT(global_growing_factor, 0);
       global_allocation_limit_ =
-          global_memory_controller()->CalculateAllocationLimit(
-              global_memory_size, max_global_memory_size_, global_gc_speed,
-              global_mutator_speed, new_space()->Capacity(),
-              CurrentHeapGrowingMode());
+          MemoryController<GlobalMemoryTrait>::CalculateAllocationLimit(
+              this, GlobalSizeOfObjects(), max_global_memory_size_,
+              new_space_capacity, global_growing_factor, mode);
     }
     CheckIneffectiveMarkCompact(
         old_gen_size, tracer()->AverageMarkCompactMutatorUtilization());
   } else if (HasLowYoungGenerationAllocationRate() &&
              old_generation_size_configured_) {
-    size_t new_limit = heap_controller()->CalculateAllocationLimit(
-        old_gen_size, max_old_generation_size_, gc_speed, mutator_speed,
-        new_space()->Capacity(), CurrentHeapGrowingMode());
-    if (new_limit < old_generation_allocation_limit_) {
-      old_generation_allocation_limit_ = new_limit;
+    size_t new_old_generation_limit =
+        MemoryController<V8HeapTrait>::CalculateAllocationLimit(
+            this, old_gen_size, max_old_generation_size_, new_space_capacity,
+            v8_growing_factor, mode);
+    if (new_old_generation_limit < old_generation_allocation_limit_) {
+      old_generation_allocation_limit_ = new_old_generation_limit;
     }
     if (UseGlobalMemoryScheduling()) {
-      const size_t new_global_limit =
-          global_memory_controller()->CalculateAllocationLimit(
-              global_memory_size, max_global_memory_size_, global_gc_speed,
-              global_mutator_speed, new_space()->Capacity(),
-              CurrentHeapGrowingMode());
+      DCHECK_GT(global_growing_factor, 0);
+      size_t new_global_limit =
+          MemoryController<GlobalMemoryTrait>::CalculateAllocationLimit(
+              this, GlobalSizeOfObjects(), max_global_memory_size_,
+              new_space_capacity, global_growing_factor, mode);
       if (new_global_limit < global_allocation_limit_) {
         global_allocation_limit_ = new_global_limit;
       }
     }
   }
-
-  {
-    GCCallbacksScope scope(this);
-    if (scope.CheckReenter()) {
-      AllowHeapAllocation allow_allocation;
-      AllowJavascriptExecution allow_js(isolate());
-      TRACE_GC(tracer(), GCTracer::Scope::HEAP_EXTERNAL_EPILOGUE);
-      VMState<EXTERNAL> state(isolate_);
-      HandleScope handle_scope(isolate_);
-      CallGCEpilogueCallbacks(gc_type, gc_callback_flags);
-    }
-  }
-
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    VerifyStringTable(this->isolate());
-  }
-#endif
-
-  return freed_global_handles > 0;
 }
 
-
 void Heap::CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags) {
   RuntimeCallTimerScope runtime_timer(
       isolate(), RuntimeCallCounterId::kGCPrologueCallback);
@@ -2646,7 +2663,7 @@ void Heap::UnregisterArrayBuffer(JSArrayBuffer buffer) {
 void Heap::ConfigureInitialOldGenerationSize() {
   if (!old_generation_size_configured_ && tracer()->SurvivalEventsRecorded()) {
     const size_t minimum_growing_step =
-        MemoryController::MinimumAllocationLimitGrowingStep(
+        MemoryController<V8HeapTrait>::MinimumAllocationLimitGrowingStep(
             CurrentHeapGrowingMode());
     const size_t new_old_generation_allocation_limit =
         Max(OldGenerationSizeOfObjects() + minimum_growing_step,
@@ -4729,9 +4746,6 @@ void Heap::SetUp() {
 
   store_buffer_.reset(new StoreBuffer(this));
 
-  heap_controller_.reset(new HeapController(this));
-  global_memory_controller_.reset(new GlobalMemoryController(this));
-
   mark_compact_collector_.reset(new MarkCompactCollector(this));
 
   scavenger_collector_.reset(new ScavengerCollector(this));
@@ -5007,9 +5021,6 @@ void Heap::TearDown() {
     stress_scavenge_observer_ = nullptr;
   }
 
-  heap_controller_.reset();
-  global_memory_controller_.reset();
-
   if (mark_compact_collector_) {
     mark_compact_collector_->TearDown();
     mark_compact_collector_.reset();

src/heap/heap.h

@@ -62,7 +62,6 @@ class ConcurrentMarking;
 class GCIdleTimeHandler;
 class GCIdleTimeHeapState;
 class GCTracer;
-class GlobalMemoryController;
 class HeapController;
 class HeapObjectAllocationTracker;
 class HeapObjectsFilter;
@@ -213,6 +212,8 @@ class Heap {
   EphemeronRememberedSet ephemeron_remembered_set_;
   enum FindMementoMode { kForRuntime, kForGC };
 
+  enum class HeapGrowingMode { kSlow, kConservative, kMinimal, kDefault };
+
   enum HeapState {
     NOT_IN_GC,
     SCAVENGE,
@@ -1692,10 +1693,6 @@ class Heap {
   // Growing strategy. =========================================================
   // ===========================================================================
 
-  HeapController* heap_controller() { return heap_controller_.get(); }
-  GlobalMemoryController* global_memory_controller() const {
-    return global_memory_controller_.get();
-  }
   MemoryReducer* memory_reducer() { return memory_reducer_.get(); }
 
   // For some webpages RAIL mode does not switch from PERFORMANCE_LOAD.
@@ -1716,8 +1713,6 @@ class Heap {
 
   bool ShouldExpandOldGenerationOnSlowAllocation();
 
-  enum class HeapGrowingMode { kSlow, kConservative, kMinimal, kDefault };
-
   HeapGrowingMode CurrentHeapGrowingMode();
 
   enum class IncrementalMarkingLimit { kNoLimit, kSoftLimit, kHardLimit };
@@ -1729,6 +1724,8 @@ class Heap {
 
   size_t GlobalMemoryAvailable();
 
+  void RecomputeLimits(GarbageCollector collector);
+
   // ===========================================================================
   // Idle notification. ========================================================
   // ===========================================================================
@@ -1985,8 +1982,6 @@ class Heap {
   std::unique_ptr<ArrayBufferCollector> array_buffer_collector_;
   std::unique_ptr<MemoryAllocator> memory_allocator_;
   std::unique_ptr<StoreBuffer> store_buffer_;
-  std::unique_ptr<HeapController> heap_controller_;
-  std::unique_ptr<GlobalMemoryController> global_memory_controller_;
   std::unique_ptr<IncrementalMarking> incremental_marking_;
   std::unique_ptr<ConcurrentMarking> concurrent_marking_;
   std::unique_ptr<GCIdleTimeHandler> gc_idle_time_handler_;
@@ -2086,9 +2081,6 @@ class Heap {
   friend class ConcurrentMarking;
   friend class GCCallbacksScope;
   friend class GCTracer;
-  friend class GlobalMemoryController;
-  friend class HeapController;
-  friend class MemoryController;
   friend class HeapIterator;
   friend class IdleScavengeObserver;
   friend class IncrementalMarking;

test/unittests/heap/heap-controller-unittest.cc

@@ -19,7 +19,7 @@
 namespace v8 {
 namespace internal {
 
-using HeapControllerTest = TestWithIsolate;
+using MemoryControllerTest = TestWithIsolate;
 
 double Round(double x) {
   // Round to three digits.
@@ -32,82 +32,81 @@ void CheckEqualRounded(double expected, double actual) {
   EXPECT_DOUBLE_EQ(expected, actual);
 }
 
-TEST_F(HeapControllerTest, HeapGrowingFactor) {
-  HeapController heap_controller(i_isolate()->heap());
-  double min_factor = heap_controller.min_growing_factor_;
-  double max_factor = heap_controller.max_growing_factor_;
-
-  CheckEqualRounded(max_factor, heap_controller.GrowingFactor(34, 1, 4.0));
-  CheckEqualRounded(3.553, heap_controller.GrowingFactor(45, 1, 4.0));
-  CheckEqualRounded(2.830, heap_controller.GrowingFactor(50, 1, 4.0));
-  CheckEqualRounded(1.478, heap_controller.GrowingFactor(100, 1, 4.0));
-  CheckEqualRounded(1.193, heap_controller.GrowingFactor(200, 1, 4.0));
-  CheckEqualRounded(1.121, heap_controller.GrowingFactor(300, 1, 4.0));
-  CheckEqualRounded(heap_controller.GrowingFactor(300, 1, 4.0),
-                    heap_controller.GrowingFactor(600, 2, 4.0));
-  CheckEqualRounded(min_factor, heap_controller.GrowingFactor(400, 1, 4.0));
+namespace {
+
+using V8Controller = MemoryController<V8HeapTrait>;
+
+}  // namespace
+
+TEST_F(MemoryControllerTest, HeapGrowingFactor) {
+  CheckEqualRounded(V8HeapTrait::kMaxGrowingFactor,
+                    V8Controller::DynamicGrowingFactor(34, 1, 4.0));
+  CheckEqualRounded(3.553, V8Controller::DynamicGrowingFactor(45, 1, 4.0));
+  CheckEqualRounded(2.830, V8Controller::DynamicGrowingFactor(50, 1, 4.0));
+  CheckEqualRounded(1.478, V8Controller::DynamicGrowingFactor(100, 1, 4.0));
+  CheckEqualRounded(1.193, V8Controller::DynamicGrowingFactor(200, 1, 4.0));
+  CheckEqualRounded(1.121, V8Controller::DynamicGrowingFactor(300, 1, 4.0));
+  CheckEqualRounded(V8Controller::DynamicGrowingFactor(300, 1, 4.0),
+                    V8Controller::DynamicGrowingFactor(600, 2, 4.0));
+  CheckEqualRounded(V8HeapTrait::kMinGrowingFactor,
+                    V8Controller::DynamicGrowingFactor(400, 1, 4.0));
 }
 
-TEST_F(HeapControllerTest, MaxHeapGrowingFactor) {
-  HeapController heap_controller(i_isolate()->heap());
+TEST_F(MemoryControllerTest, MaxHeapGrowingFactor) {
+  CheckEqualRounded(1.3,
+                    V8Controller::MaxGrowingFactor(V8HeapTrait::kMinSize * MB));
   CheckEqualRounded(
-      1.3, heap_controller.MaxGrowingFactor(HeapController::kMinSize * MB));
-  CheckEqualRounded(1.600, heap_controller.MaxGrowingFactor(
-                               HeapController::kMaxSize / 2 * MB));
+      1.600, V8Controller::MaxGrowingFactor(V8HeapTrait::kMaxSize / 2 * MB));
   CheckEqualRounded(
-      1.999, heap_controller.MaxGrowingFactor(
-                 (HeapController::kMaxSize - Heap::kPointerMultiplier) * MB));
-  CheckEqualRounded(4.0,
-                    heap_controller.MaxGrowingFactor(
-                        static_cast<size_t>(HeapController::kMaxSize) * MB));
+      1.999, V8Controller::MaxGrowingFactor(
+                 (V8HeapTrait::kMaxSize - Heap::kPointerMultiplier) * MB));
+  CheckEqualRounded(4.0, V8Controller::MaxGrowingFactor(
+                             static_cast<size_t>(V8HeapTrait::kMaxSize) * MB));
 }
 
-TEST_F(HeapControllerTest, OldGenerationAllocationLimit) {
+TEST_F(MemoryControllerTest, OldGenerationAllocationLimit) {
   Heap* heap = i_isolate()->heap();
-  HeapController heap_controller(heap);
   size_t old_gen_size = 128 * MB;
   size_t max_old_generation_size = 512 * MB;
   double gc_speed = 100;
   double mutator_speed = 1;
   size_t new_space_capacity = 16 * MB;
 
-  double max_factor = heap_controller.MaxGrowingFactor(max_old_generation_size);
-  double factor =
-      heap_controller.GrowingFactor(gc_speed, mutator_speed, max_factor);
+  double factor = V8Controller::GrowingFactor(heap, max_old_generation_size,
+                                              gc_speed, mutator_speed);
 
   EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
-            heap->heap_controller()->CalculateAllocationLimit(
-                old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
-                new_space_capacity, Heap::HeapGrowingMode::kDefault));
+            V8Controller::CalculateAllocationLimit(
+                heap, old_gen_size, max_old_generation_size, new_space_capacity,
+                factor, Heap::HeapGrowingMode::kDefault));
 
-  factor = Min(factor, heap_controller.conservative_growing_factor_);
+  factor = Min(factor, V8HeapTrait::kConservativeGrowingFactor);
   EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
-            heap->heap_controller()->CalculateAllocationLimit(
-                old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
-                new_space_capacity, Heap::HeapGrowingMode::kSlow));
+            V8Controller::CalculateAllocationLimit(
+                heap, old_gen_size, max_old_generation_size, new_space_capacity,
+                factor, Heap::HeapGrowingMode::kSlow));
 
-  factor = Min(factor, heap_controller.conservative_growing_factor_);
+  factor = Min(factor, V8HeapTrait::kConservativeGrowingFactor);
   EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
-            heap->heap_controller()->CalculateAllocationLimit(
-                old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
-                new_space_capacity, Heap::HeapGrowingMode::kConservative));
+            V8Controller::CalculateAllocationLimit(
+                heap, old_gen_size, max_old_generation_size, new_space_capacity,
+                factor, Heap::HeapGrowingMode::kConservative));
 
-  factor = heap_controller.min_growing_factor_;
+  factor = V8HeapTrait::kMinGrowingFactor;
   EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
-            heap->heap_controller()->CalculateAllocationLimit(
-                old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
-                new_space_capacity, Heap::HeapGrowingMode::kMinimal));
+            V8Controller::CalculateAllocationLimit(
+                heap, old_gen_size, max_old_generation_size, new_space_capacity,
+                factor, Heap::HeapGrowingMode::kMinimal));
 }
 
-TEST_F(HeapControllerTest, MaxOldGenerationSize) {
-  HeapController heap_controller(i_isolate()->heap());
+TEST_F(MemoryControllerTest, MaxOldGenerationSize) {
   uint64_t configurations[][2] = {
-      {0, HeapController::kMinSize},
-      {512, HeapController::kMinSize},
+      {0, V8HeapTrait::kMinSize},
+      {512, V8HeapTrait::kMinSize},
       {1 * GB, 256 * Heap::kPointerMultiplier},
       {2 * static_cast<uint64_t>(GB), 512 * Heap::kPointerMultiplier},
-      {4 * static_cast<uint64_t>(GB), HeapController::kMaxSize},
-      {8 * static_cast<uint64_t>(GB), HeapController::kMaxSize}};
+      {4 * static_cast<uint64_t>(GB), V8HeapTrait::kMaxSize},
+      {8 * static_cast<uint64_t>(GB), V8HeapTrait::kMaxSize}};
 
   for (auto configuration : configurations) {
     ASSERT_EQ(configuration[1],