// 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_CONTROLLER_H_
#define V8_HEAP_HEAP_CONTROLLER_H_

#include <cstddef>
#include "src/allocation.h"
#include "src/heap/heap.h"
#include "testing/gtest/include/gtest/gtest_prod.h"  // nogncheck

namespace v8 {
namespace internal {

class V8_EXPORT_PRIVATE MemoryController {
 public:
  MemoryController(Heap* heap, double min_growing_factor,
                   double max_growing_factor,
                   double conservative_growing_factor,
                   double target_mutator_utilization, size_t min_size,
                   size_t max_size)
      : heap_(heap),
        kMinGrowingFactor(min_growing_factor),
        kMaxGrowingFactor(max_growing_factor),
        kConservativeGrowingFactor(conservative_growing_factor),
        kTargetMutatorUtilization(target_mutator_utilization),
        kMinSize(min_size),
        kMaxSize(max_size) {}
  virtual ~MemoryController() {}

  // Computes the allocation limit to trigger the next garbage collection.
  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);

  // Computes the growing step when the limit increases.
  size_t MinimumAllocationLimitGrowingStep(Heap::HeapGrowingMode growing_mode);

 protected:
  double GrowingFactor(double gc_speed, double mutator_speed,
                       double max_factor);
  double MaxGrowingFactor(size_t curr_max_size);
  virtual const char* ControllerName() = 0;

  Heap* const heap_;

  const double kMinGrowingFactor;
  const double kMaxGrowingFactor;
  const double kConservativeGrowingFactor;
  const double kTargetMutatorUtilization;
  // Sizes are in MB.
  const size_t kMinSize;
  const size_t kMaxSize;

  FRIEND_TEST(HeapControllerTest, HeapGrowingFactor);
  FRIEND_TEST(HeapControllerTest, MaxHeapGrowingFactor);
  FRIEND_TEST(HeapControllerTest, MaxOldGenerationSize);
  FRIEND_TEST(HeapControllerTest, OldGenerationAllocationLimit);
};

class HeapController : public MemoryController {
 public:
  explicit HeapController(Heap* heap)
      : MemoryController(heap, 1.1, 4.0, 1.3, 0.97, kMinHeapSize,
                         kMaxHeapSize) {}

  // Sizes are in MB.
  static const size_t kMinHeapSize = 128 * Heap::kPointerMultiplier;
  static const size_t kMaxHeapSize = 1024 * Heap::kPointerMultiplier;

 protected:
  const char* ControllerName() { return "HeapController"; }
};

}  // namespace internal
}  // namespace v8

#endif  // V8_HEAP_HEAP_CONTROLLER_H_