dart::PageSpaceController Class Reference

#include <pages.h>

Public Member Functions
	PageSpaceController (Heap *heap, int heap_growth_ratio, int heap_growth_max, int garbage_collection_time_ratio)
	~PageSpaceController ()
bool	ReachedHardThreshold (SpaceUsage after) const
bool	ReachedSoftThreshold (SpaceUsage after) const
bool	ReachedIdleThreshold (SpaceUsage current) const
void	EvaluateGarbageCollection (SpaceUsage before, SpaceUsage after, int64_t start, int64_t end)
void	EvaluateAfterLoading (SpaceUsage after)
void	set_last_usage (SpaceUsage current)

Friends
class	PageSpace

Detailed Description

Definition at line 56 of file pages.h.

Constructor & Destructor Documentation

PageSpaceController()

dart::PageSpaceController::PageSpaceController	(	Heap *	heap,
		int	heap_growth_ratio,
		int	heap_growth_max,
		int	garbage_collection_time_ratio
	)

Definition at line 1556 of file pages.cc.

    : heap_(heap),
      heap_growth_ratio_(heap_growth_ratio),
      desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
      heap_growth_max_(heap_growth_max),
      garbage_collection_time_ratio_(garbage_collection_time_ratio),
      idle_gc_threshold_in_words_(0) {
  const intptr_t growth_in_pages = heap_growth_max / 2;
  RecordUpdate(last_usage_, last_usage_, growth_in_pages, "initial");
}

~PageSpaceController()

dart::PageSpaceController::~PageSpaceController

(

)

Definition at line 1570 of file pages.cc.

{}

Member Function Documentation

EvaluateAfterLoading()

void dart::PageSpaceController::EvaluateAfterLoading

(

SpaceUsage

after

)

Definition at line 1704 of file pages.cc.

                                                               {
  // Number of pages we can allocate and still be within the desired growth
  // ratio.
  intptr_t growth_in_pages;
  if (desired_utilization_ == 0.0) {
    growth_in_pages = heap_growth_max_;
  } else {
    growth_in_pages = (static_cast<intptr_t>(after.CombinedUsedInWords() /
                                             desired_utilization_) -
                       (after.CombinedUsedInWords())) /
                      kPageSizeInWords;
  }
 
  // Apply growth cap.
  growth_in_pages =
      Utils::Minimum(static_cast<intptr_t>(heap_growth_max_), growth_in_pages);
 
  RecordUpdate(after, after, growth_in_pages, "loaded");
}

EvaluateGarbageCollection()

void dart::PageSpaceController::EvaluateGarbageCollection	(	SpaceUsage	before,
		SpaceUsage	after,
		int64_t	start,
		int64_t	end
	)

Definition at line 1599 of file pages.cc.

                                                                 {
  ASSERT(end >= start);
  history_.AddGarbageCollectionTime(start, end);
  const int gc_time_fraction = history_.GarbageCollectionTimeFraction();
 
  // Assume garbage increases linearly with allocation:
  // G = kA, and estimate k from the previous cycle.
  const intptr_t allocated_since_previous_gc =
      before.CombinedUsedInWords() - last_usage_.CombinedUsedInWords();
  intptr_t grow_heap;
  if (allocated_since_previous_gc > 0) {
    intptr_t garbage =
        before.CombinedUsedInWords() - after.CombinedUsedInWords();
    // Garbage may be negative if when the OOM reservation is refilled.
    garbage = Utils::Maximum(static_cast<intptr_t>(0), garbage);
    // It makes no sense to expect that each kb allocated will cause more than
    // one kb of garbage, so we clamp k at 1.0.
    const double k = Utils::Minimum(
        1.0, garbage / static_cast<double>(allocated_since_previous_gc));
 
    const int garbage_ratio = static_cast<int>(k * 100);
 
    // Define GC to be 'worthwhile' iff at least fraction t of heap is garbage.
    double t = 1.0 - desired_utilization_;
    // If we spend too much time in GC, strive for even more free space.
    if (gc_time_fraction > garbage_collection_time_ratio_) {
      t += (gc_time_fraction - garbage_collection_time_ratio_) / 100.0;
    }
 
    // Number of pages we can allocate and still be within the desired growth
    // ratio.
    const intptr_t grow_pages =
        (static_cast<intptr_t>(after.CombinedUsedInWords() /
                               desired_utilization_) -
         (after.CombinedUsedInWords())) /
        kPageSizeInWords;
    if (garbage_ratio == 0) {
      // No garbage in the previous cycle so it would be hard to compute a
      // grow_heap size based on estimated garbage so we use growth ratio
      // heuristics instead.
      grow_heap =
          Utils::Maximum(static_cast<intptr_t>(heap_growth_max_), grow_pages);
    } else if (garbage_collection_time_ratio_ == 0) {
      // Exclude time from the growth policy decision for --deterministic.
      grow_heap =
          Utils::Maximum(static_cast<intptr_t>(heap_growth_max_), grow_pages);
    } else {
      // Find minimum 'grow_heap' such that after increasing capacity by
      // 'grow_heap' pages and filling them, we expect a GC to be worthwhile.
      intptr_t max = heap_growth_max_;
      intptr_t min = 0;
      intptr_t local_grow_heap = 0;
      while (min < max) {
        local_grow_heap = (max + min) / 2;
        const intptr_t limit =
            after.CombinedUsedInWords() + (local_grow_heap * kPageSizeInWords);
        const intptr_t allocated_before_next_gc =
            limit - (after.CombinedUsedInWords());
        const double estimated_garbage = k * allocated_before_next_gc;
        if (t <= estimated_garbage / limit) {
          max = local_grow_heap - 1;
        } else {
          min = local_grow_heap + 1;
        }
      }
      local_grow_heap = (max + min) / 2;
      grow_heap = local_grow_heap;
      ASSERT(grow_heap >= 0);
      // If we are going to grow by heap_grow_max_ then ensure that we
      // will be growing the heap at least by the growth ratio heuristics.
      if (grow_heap >= heap_growth_max_) {
        grow_heap = Utils::Maximum(grow_pages, grow_heap);
      }
    }
  } else {
    grow_heap = 0;
  }
  last_usage_ = after;
 
  intptr_t max_capacity_in_words = heap_->old_space()->max_capacity_in_words_;
  if (max_capacity_in_words != 0) {
    ASSERT(grow_heap >= 0);
    // Fraction of asymptote used.
    double f = static_cast<double>(after.CombinedUsedInWords() +
                                   (kPageSizeInWords * grow_heap)) /
               static_cast<double>(max_capacity_in_words);
    ASSERT(f >= 0.0);
    // Increase weight at the high end.
    f = f * f;
    // Fraction of asymptote available.
    f = 1.0 - f;
    ASSERT(f <= 1.0);
    // Discount growth more the closer we get to the desired asymptote.
    grow_heap = static_cast<intptr_t>(grow_heap * f);
    // Minimum growth step after reaching the asymptote.
    intptr_t min_step = (2 * MB) / kPageSize;
    grow_heap = Utils::Maximum(min_step, grow_heap);
  }
 
  RecordUpdate(before, after, grow_heap, "gc");
}

ReachedHardThreshold()

bool dart::PageSpaceController::ReachedHardThreshold

(

SpaceUsage

after

)

const

Definition at line 1572 of file pages.cc.

                                                                     {
  if (heap_growth_ratio_ == 100) {
    return false;
  }
  if ((heap_ != nullptr) && (heap_->mode() == Dart_PerformanceMode_Latency)) {
    return false;
  }
  return after.CombinedUsedInWords() > hard_gc_threshold_in_words_;
}

ReachedIdleThreshold()

bool dart::PageSpaceController::ReachedIdleThreshold

(

SpaceUsage

current

)

const

Definition at line 1592 of file pages.cc.

                                                                       {
  if (heap_growth_ratio_ == 100) {
    return false;
  }
  return current.CombinedUsedInWords() > idle_gc_threshold_in_words_;
}

ReachedSoftThreshold()

bool dart::PageSpaceController::ReachedSoftThreshold

(

SpaceUsage

after

)

const

Definition at line 1582 of file pages.cc.

                                                                     {
  if (heap_growth_ratio_ == 100) {
    return false;
  }
  if ((heap_ != nullptr) && (heap_->mode() == Dart_PerformanceMode_Latency)) {
    return false;
  }
  return after.CombinedUsedInWords() > soft_gc_threshold_in_words_;
}

set_last_usage()

void dart::PageSpaceController::set_last_usage ( SpaceUsage  current )

inline

Definition at line 82 of file pages.h.

{ last_usage_ = current; }

Friends And Related Function Documentation

PageSpace

friend class PageSpace

friend

Definition at line 85 of file pages.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/heap/pages.h
• third_party/dart-lang/sdk/runtime/vm/heap/pages.cc