v8::internal::GCIdleTimeHandler Class Reference

#include <gc-idle-time-handler.h>

Collaboration diagram for v8::internal::GCIdleTimeHandler:

Classes
struct	HeapState

Public Member Functions
	GCIdleTimeHandler ()
GCIdleTimeAction	Compute (size_t idle_time_in_ms, HeapState heap_state)
void	NotifyIdleMarkCompact ()
void	NotifyScavenge ()

Static Public Member Functions
static size_t	EstimateMarkingStepSize (size_t idle_time_in_ms, size_t marking_speed_in_bytes_per_ms)
static size_t	EstimateMarkCompactTime (size_t size_of_objects, size_t mark_compact_speed_in_bytes_per_ms)
static size_t	EstimateScavengeTime (size_t new_space_size, size_t scavenger_speed_in_bytes_per_ms)
static bool	ScavangeMayHappenSoon (size_t available_new_space_memory, size_t new_space_allocation_throughput_in_bytes_per_ms)

Static Public Attributes
static const size_t	kInitialConservativeMarkingSpeed = 100 * KB
static const size_t	kMaximumMarkingStepSize = 700 * MB
static const double	kConservativeTimeRatio = 0.9
static const size_t	kInitialConservativeMarkCompactSpeed = 2 * MB
static const size_t	kMaxMarkCompactTimeInMs = 1000
static const size_t	kMinTimeForFinalizeSweeping = 100
static const int	kMaxMarkCompactsInIdleRound = 7
static const int	kIdleScavengeThreshold = 5
static const size_t	kSmallHeapSize = 4 * kPointerSize * MB
static const size_t	kMaxFrameRenderingIdleTime = 16
static const size_t	kNewSpaceAlmostFullTreshold = 100 * KB
static const size_t	kInitialConservativeScavengeSpeed = 100 * KB

Private Member Functions
void	StartIdleRound ()
bool	IsMarkCompactIdleRoundFinished ()
bool	EnoughGarbageSinceLastIdleRound ()
	DISALLOW_COPY_AND_ASSIGN (GCIdleTimeHandler)

Private Attributes
int	mark_compacts_since_idle_round_started_
int	scavenges_since_last_idle_round_

Detailed Description

Definition at line 78 of file gc-idle-time-handler.h.

Constructor & Destructor Documentation

GCIdleTimeHandler()

v8::internal::GCIdleTimeHandler::GCIdleTimeHandler ( )

inline

Definition at line 138 of file gc-idle-time-handler.h.

      : mark_compacts_since_idle_round_started_(0),
        scavenges_since_last_idle_round_(0) {}

Member Function Documentation

Compute()

GCIdleTimeAction v8::internal::GCIdleTimeHandler::Compute	(	size_t	idle_time_in_ms,
		HeapState	heap_state
	)

Definition at line 111 of file gc-idle-time-handler.cc.

                                                                  {
  if (idle_time_in_ms <= kMaxFrameRenderingIdleTime &&
      ScavangeMayHappenSoon(
          heap_state.available_new_space_memory,
          heap_state.new_space_allocation_throughput_in_bytes_per_ms) &&
      idle_time_in_ms >=
          EstimateScavengeTime(heap_state.new_space_capacity,
                               heap_state.scavenge_speed_in_bytes_per_ms)) {
    return GCIdleTimeAction::Scavenge();
  }
  if (IsMarkCompactIdleRoundFinished()) {
    if (EnoughGarbageSinceLastIdleRound() || heap_state.contexts_disposed > 0) {
      StartIdleRound();
    } else {
      return GCIdleTimeAction::Done();
    }
  }
 
  if (idle_time_in_ms == 0) {
    return GCIdleTimeAction::Nothing();
  }
 
  if (heap_state.incremental_marking_stopped) {
    size_t estimated_time_in_ms =
        EstimateMarkCompactTime(heap_state.size_of_objects,
                                heap_state.mark_compact_speed_in_bytes_per_ms);
    if (idle_time_in_ms >= estimated_time_in_ms ||
        (heap_state.size_of_objects < kSmallHeapSize &&
         heap_state.contexts_disposed > 0)) {
      // If there are no more than two GCs left in this idle round and we are
      // allowed to do a full GC, then make those GCs full in order to compact
      // the code space.
      // TODO(ulan): Once we enable code compaction for incremental marking, we
      // can get rid of this special case and always start incremental marking.
      int remaining_mark_sweeps =
          kMaxMarkCompactsInIdleRound - mark_compacts_since_idle_round_started_;
      if (heap_state.contexts_disposed > 0 ||
          (idle_time_in_ms > kMaxFrameRenderingIdleTime &&
           (remaining_mark_sweeps <= 2 ||
            !heap_state.can_start_incremental_marking))) {
        return GCIdleTimeAction::FullGC();
      }
    }
    if (!heap_state.can_start_incremental_marking) {
      return GCIdleTimeAction::Nothing();
    }
  }
  // TODO(hpayer): Estimate finalize sweeping time.
  if (heap_state.sweeping_in_progress &&
      idle_time_in_ms >= kMinTimeForFinalizeSweeping) {
    return GCIdleTimeAction::FinalizeSweeping();
  }
 
  if (heap_state.incremental_marking_stopped &&
      !heap_state.can_start_incremental_marking) {
    return GCIdleTimeAction::Nothing();
  }
  size_t step_size = EstimateMarkingStepSize(
      idle_time_in_ms, heap_state.incremental_marking_speed_in_bytes_per_ms);
  return GCIdleTimeAction::IncrementalMarking(step_size);
}

References v8::internal::GCIdleTimeHandler::HeapState::available_new_space_memory, v8::internal::GCIdleTimeHandler::HeapState::can_start_incremental_marking, v8::internal::GCIdleTimeHandler::HeapState::contexts_disposed, v8::internal::GCIdleTimeAction::Done(), EnoughGarbageSinceLastIdleRound(), EstimateMarkCompactTime(), EstimateMarkingStepSize(), EstimateScavengeTime(), v8::internal::GCIdleTimeAction::FinalizeSweeping(), v8::internal::GCIdleTimeAction::FullGC(), v8::internal::GCIdleTimeHandler::HeapState::incremental_marking_speed_in_bytes_per_ms, v8::internal::GCIdleTimeHandler::HeapState::incremental_marking_stopped, v8::internal::GCIdleTimeAction::IncrementalMarking(), IsMarkCompactIdleRoundFinished(), kMaxFrameRenderingIdleTime, kMaxMarkCompactsInIdleRound, kMinTimeForFinalizeSweeping, kSmallHeapSize, v8::internal::GCIdleTimeHandler::HeapState::mark_compact_speed_in_bytes_per_ms, mark_compacts_since_idle_round_started_, v8::internal::GCIdleTimeHandler::HeapState::new_space_allocation_throughput_in_bytes_per_ms, v8::internal::GCIdleTimeHandler::HeapState::new_space_capacity, v8::internal::GCIdleTimeAction::Nothing(), ScavangeMayHappenSoon(), v8::internal::GCIdleTimeAction::Scavenge(), v8::internal::GCIdleTimeHandler::HeapState::scavenge_speed_in_bytes_per_ms, v8::internal::GCIdleTimeHandler::HeapState::size_of_objects, StartIdleRound(), and v8::internal::GCIdleTimeHandler::HeapState::sweeping_in_progress.

Referenced by v8::internal::Heap::IdleNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::GCIdleTimeHandler::DISALLOW_COPY_AND_ASSIGN ( GCIdleTimeHandler  )

private

EnoughGarbageSinceLastIdleRound()

bool v8::internal::GCIdleTimeHandler::EnoughGarbageSinceLastIdleRound ( )

inlineprivate

Definition at line 175 of file gc-idle-time-handler.h.

                                         {
    return scavenges_since_last_idle_round_ >= kIdleScavengeThreshold;
  }

References kIdleScavengeThreshold, and scavenges_since_last_idle_round_.

Referenced by Compute().

Here is the caller graph for this function:

EstimateMarkCompactTime()

size_t v8::internal::GCIdleTimeHandler::EstimateMarkCompactTime ( size_t  size_of_objects, size_t  mark_compact_speed_in_bytes_per_ms  )

static

Definition at line 64 of file gc-idle-time-handler.cc.

                                                                       {
  if (mark_compact_speed_in_bytes_per_ms == 0) {
    mark_compact_speed_in_bytes_per_ms = kInitialConservativeMarkCompactSpeed;
  }
  size_t result = size_of_objects / mark_compact_speed_in_bytes_per_ms;
  return Min(result, kMaxMarkCompactTimeInMs);
}

References kInitialConservativeMarkCompactSpeed, kMaxMarkCompactTimeInMs, and v8::internal::Min().

Referenced by Compute(), and v8::internal::TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

EstimateMarkingStepSize()

size_t v8::internal::GCIdleTimeHandler::EstimateMarkingStepSize ( size_t  idle_time_in_ms, size_t  marking_speed_in_bytes_per_ms  )

static

Definition at line 43 of file gc-idle-time-handler.cc.

                                                                  {
  DCHECK(idle_time_in_ms > 0);
 
  if (marking_speed_in_bytes_per_ms == 0) {
    marking_speed_in_bytes_per_ms = kInitialConservativeMarkingSpeed;
  }
 
  size_t marking_step_size = marking_speed_in_bytes_per_ms * idle_time_in_ms;
  if (marking_step_size / marking_speed_in_bytes_per_ms != idle_time_in_ms) {
    // In the case of an overflow we return maximum marking step size.
    return kMaximumMarkingStepSize;
  }
 
  if (marking_step_size > kMaximumMarkingStepSize)
    return kMaximumMarkingStepSize;
 
  return static_cast<size_t>(marking_step_size * kConservativeTimeRatio);
}

References DCHECK, kConservativeTimeRatio, kInitialConservativeMarkingSpeed, and kMaximumMarkingStepSize.

Referenced by Compute(), and v8::internal::TEST().

Here is the caller graph for this function:

EstimateScavengeTime()

size_t v8::internal::GCIdleTimeHandler::EstimateScavengeTime ( size_t  new_space_size, size_t  scavenger_speed_in_bytes_per_ms  )

static

Definition at line 74 of file gc-idle-time-handler.cc.

                                                                  {
  if (scavenge_speed_in_bytes_per_ms == 0) {
    scavenge_speed_in_bytes_per_ms = kInitialConservativeScavengeSpeed;
  }
  return new_space_size / scavenge_speed_in_bytes_per_ms;
}

References kInitialConservativeScavengeSpeed.

Referenced by Compute(), and v8::internal::TEST().

Here is the caller graph for this function:

IsMarkCompactIdleRoundFinished()

bool v8::internal::GCIdleTimeHandler::IsMarkCompactIdleRoundFinished ( )

inlineprivate

Definition at line 171 of file gc-idle-time-handler.h.

                                        {
    return mark_compacts_since_idle_round_started_ ==
           kMaxMarkCompactsInIdleRound;
  }

References kMaxMarkCompactsInIdleRound, and mark_compacts_since_idle_round_started_.

Referenced by Compute().

Here is the caller graph for this function:

NotifyIdleMarkCompact()

void v8::internal::GCIdleTimeHandler::NotifyIdleMarkCompact ( )

inline

Definition at line 144 of file gc-idle-time-handler.h.

                               {
    if (mark_compacts_since_idle_round_started_ < kMaxMarkCompactsInIdleRound) {
      ++mark_compacts_since_idle_round_started_;
      if (mark_compacts_since_idle_round_started_ ==
          kMaxMarkCompactsInIdleRound) {
        scavenges_since_last_idle_round_ = 0;
      }
    }
  }

References kMaxMarkCompactsInIdleRound, mark_compacts_since_idle_round_started_, and scavenges_since_last_idle_round_.

Referenced by v8::internal::Heap::AdvanceIdleIncrementalMarking(), and v8::internal::Heap::IdleNotification().

Here is the caller graph for this function:

NotifyScavenge()

void v8::internal::GCIdleTimeHandler::NotifyScavenge ( )

inline

Definition at line 154 of file gc-idle-time-handler.h.

{ ++scavenges_since_last_idle_round_; }

References scavenges_since_last_idle_round_.

ScavangeMayHappenSoon()

bool v8::internal::GCIdleTimeHandler::ScavangeMayHappenSoon ( size_t  available_new_space_memory, size_t  new_space_allocation_throughput_in_bytes_per_ms  )

static

Definition at line 83 of file gc-idle-time-handler.cc.

                                                            {
  if (available_new_space_memory <=
      new_space_allocation_throughput_in_bytes_per_ms *
          kMaxFrameRenderingIdleTime) {
    return true;
  }
  return false;
}

References kMaxFrameRenderingIdleTime.

Referenced by Compute(), and v8::internal::TEST().

Here is the caller graph for this function:

StartIdleRound()

void v8::internal::GCIdleTimeHandler::StartIdleRound ( )

inlineprivate

Definition at line 170 of file gc-idle-time-handler.h.

{ mark_compacts_since_idle_round_started_ = 0; }

References mark_compacts_since_idle_round_started_.

Referenced by Compute().

Here is the caller graph for this function:

Member Data Documentation

kConservativeTimeRatio

const double v8::internal::GCIdleTimeHandler::kConservativeTimeRatio = 0.9

static

Definition at line 89 of file gc-idle-time-handler.h.

Referenced by EstimateMarkingStepSize(), and v8::internal::TEST().

kIdleScavengeThreshold

const int v8::internal::GCIdleTimeHandler::kIdleScavengeThreshold = 5

static

Definition at line 107 of file gc-idle-time-handler.h.

Referenced by EnoughGarbageSinceLastIdleRound(), and v8::internal::TEST_F().

kInitialConservativeMarkCompactSpeed

const size_t v8::internal::GCIdleTimeHandler::kInitialConservativeMarkCompactSpeed = 2 * MB

static

Definition at line 93 of file gc-idle-time-handler.h.

Referenced by EstimateMarkCompactTime(), and v8::internal::TEST().

kInitialConservativeMarkingSpeed

const size_t v8::internal::GCIdleTimeHandler::kInitialConservativeMarkingSpeed = 100 * KB

static

Definition at line 82 of file gc-idle-time-handler.h.

Referenced by EstimateMarkingStepSize(), and v8::internal::TEST().

kInitialConservativeScavengeSpeed

const size_t v8::internal::GCIdleTimeHandler::kInitialConservativeScavengeSpeed = 100 * KB

static

Definition at line 122 of file gc-idle-time-handler.h.

Referenced by EstimateScavengeTime(), and v8::internal::TEST().

kMaxFrameRenderingIdleTime

const size_t v8::internal::GCIdleTimeHandler::kMaxFrameRenderingIdleTime = 16

static

Definition at line 114 of file gc-idle-time-handler.h.

Referenced by Compute(), ScavangeMayHappenSoon(), and v8::internal::TEST().

kMaximumMarkingStepSize

const size_t v8::internal::GCIdleTimeHandler::kMaximumMarkingStepSize = 700 * MB

static

Definition at line 85 of file gc-idle-time-handler.h.

Referenced by EstimateMarkingStepSize(), and v8::internal::TEST().

kMaxMarkCompactsInIdleRound

const int v8::internal::GCIdleTimeHandler::kMaxMarkCompactsInIdleRound = 7

static

Definition at line 104 of file gc-idle-time-handler.h.

Referenced by Compute(), IsMarkCompactIdleRoundFinished(), NotifyIdleMarkCompact(), and v8::internal::TEST_F().

kMaxMarkCompactTimeInMs

const size_t v8::internal::GCIdleTimeHandler::kMaxMarkCompactTimeInMs = 1000

static

Definition at line 96 of file gc-idle-time-handler.h.

Referenced by EstimateMarkCompactTime(), and v8::internal::TEST().

kMinTimeForFinalizeSweeping

const size_t v8::internal::GCIdleTimeHandler::kMinTimeForFinalizeSweeping = 100

static

Definition at line 100 of file gc-idle-time-handler.h.

Referenced by Compute().

kNewSpaceAlmostFullTreshold

const size_t v8::internal::GCIdleTimeHandler::kNewSpaceAlmostFullTreshold = 100 * KB

static

Definition at line 118 of file gc-idle-time-handler.h.

kSmallHeapSize

const size_t v8::internal::GCIdleTimeHandler::kSmallHeapSize = 4 * kPointerSize * MB

static

Definition at line 111 of file gc-idle-time-handler.h.

Referenced by Compute().

mark_compacts_since_idle_round_started_

int v8::internal::GCIdleTimeHandler::mark_compacts_since_idle_round_started_

private

Definition at line 179 of file gc-idle-time-handler.h.

Referenced by Compute(), IsMarkCompactIdleRoundFinished(), NotifyIdleMarkCompact(), and StartIdleRound().

scavenges_since_last_idle_round_

int v8::internal::GCIdleTimeHandler::scavenges_since_last_idle_round_

private

Definition at line 180 of file gc-idle-time-handler.h.

Referenced by EnoughGarbageSinceLastIdleRound(), NotifyIdleMarkCompact(), and NotifyScavenge().

---

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

• /mnt/V8SourceCode/src/heap/gc-idle-time-handler.h
• /mnt/V8SourceCode/src/heap/gc-idle-time-handler.cc