blob: 485b22902a03e27ba60fc0144ecc45968b86d52a [file] [log] [blame]
 // 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/heap/heap-controller.h" #include "src/isolate-inl.h" namespace v8 { namespace internal { // 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 kTargetMutatorUtilisation if the GC speed and the mutator speed // remain the same until the next GC. // // For a fixed time-frame T = TM + TG, the mutator utilization is the ratio // TM / (TM + TG), where TM is the time spent in the mutator and TG is the // time spent in the garbage collector. // // Let MU be kTargetMutatorUtilisation, the desired mutator utilization for the // time-frame from the end of the current GC to the end of the next GC. Based // on the MU we can compute the heap growing factor F as // // F = R * (1 - MU) / (R * (1 - MU) - MU), where R = gc_speed / mutator_speed. // // This formula can be derived as follows. // // F = Limit / Live by definition, where the Limit is the allocation limit, // and the Live is size of live objects. // Let’s assume that we already know the Limit. Then: // TG = Limit / gc_speed // TM = (TM + TG) * MU, by definition of MU. // TM = TG * MU / (1 - MU) // TM = Limit * MU / (gc_speed * (1 - MU)) // On the other hand, if the allocation throughput remains constant: // Limit = Live + TM * allocation_throughput = Live + TM * mutator_speed // Solving it for TM, we get // TM = (Limit - Live) / mutator_speed // Combining the two equation for TM: // (Limit - Live) / mutator_speed = Limit * MU / (gc_speed * (1 - MU)) // (Limit - Live) = Limit * MU * mutator_speed / (gc_speed * (1 - MU)) // substitute R = gc_speed / mutator_speed // (Limit - Live) = Limit * MU / (R * (1 - MU)) // substitute F = Limit / Live // F - 1 = F * MU / (R * (1 - MU)) // F - F * MU / (R * (1 - MU)) = 1 // 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, double max_factor) { DCHECK_LE(kMinGrowingFactor, max_factor); DCHECK_GE(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 - kTargetMutatorUtilization); const double b = speed_ratio * (1 - kTargetMutatorUtilization) - 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, kMinGrowingFactor); return factor; } double MemoryController::MaxGrowingFactor(size_t curr_max_size) { const double min_small_factor = 1.3; const double max_small_factor = 2.0; const double high_factor = 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 high_factor; } 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) * (max_small_factor - min_small_factor) / (kMaxSize - kMinSize) + min_small_factor; return factor; } size_t MemoryController::CalculateAllocationLimit( size_t curr_size, size_t max_size, double gc_speed, double mutator_speed, size_t new_space_capacity, Heap::HeapGrowingMode growing_mode) { double max_factor = MaxGrowingFactor(max_size); double factor = GrowingFactor(gc_speed, mutator_speed, max_factor); if (FLAG_trace_gc_verbose) { heap_->isolate()->PrintWithTimestamp( "%s factor %.1f based on mu=%.3f, speed_ratio=%.f " "(gc=%.f, mutator=%.f)\n", ControllerName(), factor, kTargetMutatorUtilization, gc_speed / mutator_speed, gc_speed, mutator_speed); } if (growing_mode == Heap::HeapGrowingMode::kConservative || growing_mode == Heap::HeapGrowingMode::kSlow) { factor = Min(factor, kConservativeGrowingFactor); } if (growing_mode == Heap::HeapGrowingMode::kMinimal) { factor = kMinGrowingFactor; } 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); uint64_t limit = static_cast(curr_size * factor); limit = Max(limit, static_cast(curr_size) + MinimumAllocationLimitGrowingStep(growing_mode)); limit += new_space_capacity; uint64_t halfway_to_the_max = (static_cast(curr_size) + max_size) / 2; size_t result = static_cast(Min(limit, halfway_to_the_max)); if (FLAG_trace_gc_verbose) { heap_->isolate()->PrintWithTimestamp( "%s Limit: old size: %" PRIuS " KB, new limit: %" PRIuS " KB (%.1f)\n", ControllerName(), curr_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); } } // namespace internal } // namespace v8