v8::internal::GCTracer Class Reference

#include <gc-tracer.h>

Collaboration diagram for v8::internal::GCTracer:

Classes
class	AllocationEvent
class	Event
class	Scope

Public Types
typedef RingBuffer< Event, kRingBufferMaxSize >	EventBuffer
typedef RingBuffer< AllocationEvent, kRingBufferMaxSize >	AllocationEventBuffer

Public Member Functions
	GCTracer (Heap *heap)
void	Start (GarbageCollector collector, const char *gc_reason, const char *collector_reason)
void	Stop ()
void	AddNewSpaceAllocationTime (double duration, intptr_t allocation_in_bytes)
void	AddIncrementalMarkingStep (double duration, intptr_t bytes)
void	AddMarkingTime (double duration)
double	cumulative_marking_duration () const
void	AddSweepingTime (double duration)
double	cumulative_sweeping_duration () const
double	MeanScavengerDuration () const
double	MaxScavengerDuration () const
double	MeanMarkCompactorDuration () const
double	MaxMarkCompactorDuration () const
double	MeanIncrementalMarkingDuration () const
double	MaxIncrementalMarkingDuration () const
intptr_t	IncrementalMarkingSpeedInBytesPerMillisecond () const
intptr_t	ScavengeSpeedInBytesPerMillisecond () const
intptr_t	MarkCompactSpeedInBytesPerMillisecond () const
intptr_t	NewSpaceAllocationThroughputInBytesPerMillisecond () const

Static Public Attributes
static const int	kRingBufferMaxSize = 10

Private Member Functions
void	PrintNVP () const
void	Print () const
double	MeanDuration (const EventBuffer &events) const
double	MaxDuration (const EventBuffer &events) const
	DISALLOW_COPY_AND_ASSIGN (GCTracer)

Private Attributes
Heap *	heap_
Event	current_
Event	previous_
Event	previous_mark_compactor_event_
EventBuffer	scavenger_events_
EventBuffer	mark_compactor_events_
AllocationEventBuffer	allocation_events_
int	cumulative_incremental_marking_steps_
intptr_t	cumulative_incremental_marking_bytes_
double	cumulative_incremental_marking_duration_
double	cumulative_pure_incremental_marking_duration_
double	longest_incremental_marking_step_
double	cumulative_marking_duration_
double	cumulative_sweeping_duration_
intptr_t	new_space_top_after_gc_

Detailed Description

Definition at line 86 of file gc-tracer.h.

Member Typedef Documentation

AllocationEventBuffer

typedef RingBuffer<AllocationEvent, kRingBufferMaxSize> v8::internal::GCTracer::AllocationEventBuffer

Definition at line 242 of file gc-tracer.h.

EventBuffer

typedef RingBuffer<Event, kRingBufferMaxSize> v8::internal::GCTracer::EventBuffer

Definition at line 240 of file gc-tracer.h.

Constructor & Destructor Documentation

GCTracer()

v8::internal::GCTracer::GCTracer ( Heap *  heap )

explicit

Definition at line 82 of file gc-tracer.cc.

    : heap_(heap),
      cumulative_incremental_marking_steps_(0),
      cumulative_incremental_marking_bytes_(0),
      cumulative_incremental_marking_duration_(0.0),
      cumulative_pure_incremental_marking_duration_(0.0),
      longest_incremental_marking_step_(0.0),
      cumulative_marking_duration_(0.0),
      cumulative_sweeping_duration_(0.0),
      new_space_top_after_gc_(0) {
  current_ = Event(Event::START, NULL, NULL);
  current_.end_time = base::OS::TimeCurrentMillis();
  previous_ = previous_mark_compactor_event_ = current_;
}

References current_, v8::internal::GCTracer::Event::end_time, NULL, previous_, previous_mark_compactor_event_, v8::internal::GCTracer::Event::START, and v8::base::OS::TimeCurrentMillis().

Here is the call graph for this function:

Member Function Documentation

AddIncrementalMarkingStep()

void v8::internal::GCTracer::AddIncrementalMarkingStep	(	double	duration,
		intptr_t	bytes
	)

Definition at line 210 of file gc-tracer.cc.

                                                                        {
  cumulative_incremental_marking_steps_++;
  cumulative_incremental_marking_bytes_ += bytes;
  cumulative_incremental_marking_duration_ += duration;
  longest_incremental_marking_step_ =
      Max(longest_incremental_marking_step_, duration);
  cumulative_marking_duration_ += duration;
  if (bytes > 0) {
    cumulative_pure_incremental_marking_duration_ += duration;
  }
}

References cumulative_incremental_marking_bytes_, cumulative_incremental_marking_duration_, cumulative_incremental_marking_steps_, cumulative_marking_duration_, cumulative_pure_incremental_marking_duration_, longest_incremental_marking_step_, and v8::internal::Max().

Referenced by v8::internal::IncrementalMarking::Step().

Here is the call graph for this function:

Here is the caller graph for this function:

AddMarkingTime()

void v8::internal::GCTracer::AddMarkingTime ( double  duration )

inline

Definition at line 260 of file gc-tracer.h.

                                       {
    cumulative_marking_duration_ += duration;
  }

References cumulative_marking_duration_.

Referenced by v8::internal::IncrementalMarking::Hurry(), and v8::internal::MarkCompactCollector::MarkLiveObjects().

Here is the caller graph for this function:

AddNewSpaceAllocationTime()

void v8::internal::GCTracer::AddNewSpaceAllocationTime	(	double	duration,
		intptr_t	allocation_in_bytes
	)

Definition at line 204 of file gc-tracer.cc.

                                                                       {
  allocation_events_.push_front(AllocationEvent(duration, allocation_in_bytes));
}

References allocation_events_, and v8::internal::RingBuffer< T, MAX_SIZE >::push_front().

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

AddSweepingTime()

void v8::internal::GCTracer::AddSweepingTime ( double  duration )

inline

Definition at line 270 of file gc-tracer.h.

                                        {
    cumulative_sweeping_duration_ += duration;
  }

References cumulative_sweeping_duration_.

Referenced by v8::internal::MarkCompactCollector::SweepSpaces().

Here is the caller graph for this function:

cumulative_marking_duration()

double v8::internal::GCTracer::cumulative_marking_duration ( ) const

inline

Definition at line 265 of file gc-tracer.h.

                                             {
    return cumulative_marking_duration_;
  }

References cumulative_marking_duration_.

cumulative_sweeping_duration()

double v8::internal::GCTracer::cumulative_sweeping_duration ( ) const

inline

Definition at line 275 of file gc-tracer.h.

                                              {
    return cumulative_sweeping_duration_;
  }

References cumulative_sweeping_duration_.

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

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::GCTracer::DISALLOW_COPY_AND_ASSIGN ( GCTracer  )

private

IncrementalMarkingSpeedInBytesPerMillisecond()

intptr_t v8::internal::GCTracer::IncrementalMarkingSpeedInBytesPerMillisecond

(

)

const

Definition at line 407 of file gc-tracer.cc.

                                                                      {
  if (cumulative_incremental_marking_duration_ == 0.0) return 0;
 
  // We haven't completed an entire round of incremental marking, yet.
  // Use data from GCTracer instead of data from event buffers.
  if (mark_compactor_events_.empty()) {
    return static_cast<intptr_t>(cumulative_incremental_marking_bytes_ /
                                 cumulative_pure_incremental_marking_duration_);
  }
 
  intptr_t bytes = 0;
  double durations = 0.0;
  EventBuffer::const_iterator iter = mark_compactor_events_.begin();
  while (iter != mark_compactor_events_.end()) {
    bytes += iter->incremental_marking_bytes;
    durations += iter->pure_incremental_marking_duration;
    ++iter;
  }
 
  if (durations == 0.0) return 0;
 
  return static_cast<intptr_t>(bytes / durations);
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), cumulative_incremental_marking_bytes_, cumulative_incremental_marking_duration_, cumulative_pure_incremental_marking_duration_, v8::internal::RingBuffer< T, MAX_SIZE >::empty(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and mark_compactor_events_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

MarkCompactSpeedInBytesPerMillisecond()

intptr_t v8::internal::GCTracer::MarkCompactSpeedInBytesPerMillisecond

(

)

const

Definition at line 448 of file gc-tracer.cc.

                                                               {
  intptr_t bytes = 0;
  double durations = 0.0;
  EventBuffer::const_iterator iter = mark_compactor_events_.begin();
  while (iter != mark_compactor_events_.end()) {
    bytes += iter->start_object_size;
    durations += iter->end_time - iter->start_time +
                 iter->pure_incremental_marking_duration;
    ++iter;
  }
 
  if (durations == 0.0) return 0;
 
  return static_cast<intptr_t>(bytes / durations);
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and mark_compactor_events_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

MaxDuration()

double v8::internal::GCTracer::MaxDuration ( const EventBuffer &  events ) const

private

Definition at line 354 of file gc-tracer.cc.

                                                            {
  if (events.empty()) return 0.0;
 
  double maximum = 0.0f;
  EventBuffer::const_iterator iter = events.begin();
  while (iter != events.end()) {
    maximum = Max(iter->end_time - iter->start_time, maximum);
    ++iter;
  }
 
  return maximum;
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), v8::internal::RingBuffer< T, MAX_SIZE >::empty(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and v8::internal::Max().

Referenced by MaxMarkCompactorDuration(), and MaxScavengerDuration().

Here is the call graph for this function:

Here is the caller graph for this function:

MaxIncrementalMarkingDuration()

double v8::internal::GCTracer::MaxIncrementalMarkingDuration

(

)

const

Definition at line 393 of file gc-tracer.cc.

                                                     {
  // We haven't completed an entire round of incremental marking, yet.
  // Use data from GCTracer instead of data from event buffers.
  if (mark_compactor_events_.empty()) return longest_incremental_marking_step_;
 
  double max_duration = 0.0;
  EventBuffer::const_iterator iter = mark_compactor_events_.begin();
  while (iter != mark_compactor_events_.end())
    max_duration = Max(iter->longest_incremental_marking_step, max_duration);
 
  return max_duration;
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), v8::internal::RingBuffer< T, MAX_SIZE >::empty(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), longest_incremental_marking_step_, mark_compactor_events_, and v8::internal::Max().

Here is the call graph for this function:

MaxMarkCompactorDuration()

double v8::internal::GCTracer::MaxMarkCompactorDuration ( ) const

inline

Definition at line 297 of file gc-tracer.h.

                                          {
    return MaxDuration(mark_compactor_events_);
  }

References mark_compactor_events_, and MaxDuration().

Here is the call graph for this function:

MaxScavengerDuration()

double v8::internal::GCTracer::MaxScavengerDuration ( ) const

inline

Definition at line 287 of file gc-tracer.h.

{ return MaxDuration(scavenger_events_); }

References MaxDuration(), and scavenger_events_.

Here is the call graph for this function:

MeanDuration()

double v8::internal::GCTracer::MeanDuration ( const EventBuffer &  events ) const

private

Definition at line 340 of file gc-tracer.cc.

                                                             {
  if (events.empty()) return 0.0;
 
  double mean = 0.0;
  EventBuffer::const_iterator iter = events.begin();
  while (iter != events.end()) {
    mean += iter->end_time - iter->start_time;
    ++iter;
  }
 
  return mean / events.size();
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), v8::internal::RingBuffer< T, MAX_SIZE >::empty(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and v8::internal::RingBuffer< T, MAX_SIZE >::size().

Referenced by MeanMarkCompactorDuration(), and MeanScavengerDuration().

Here is the call graph for this function:

Here is the caller graph for this function:

MeanIncrementalMarkingDuration()

double v8::internal::GCTracer::MeanIncrementalMarkingDuration

(

)

const

Definition at line 368 of file gc-tracer.cc.

                                                      {
  if (cumulative_incremental_marking_steps_ == 0) return 0.0;
 
  // We haven't completed an entire round of incremental marking, yet.
  // Use data from GCTracer instead of data from event buffers.
  if (mark_compactor_events_.empty()) {
    return cumulative_incremental_marking_duration_ /
           cumulative_incremental_marking_steps_;
  }
 
  int steps = 0;
  double durations = 0.0;
  EventBuffer::const_iterator iter = mark_compactor_events_.begin();
  while (iter != mark_compactor_events_.end()) {
    steps += iter->incremental_marking_steps;
    durations += iter->incremental_marking_duration;
    ++iter;
  }
 
  if (steps == 0) return 0.0;
 
  return durations / steps;
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), cumulative_incremental_marking_duration_, cumulative_incremental_marking_steps_, v8::internal::RingBuffer< T, MAX_SIZE >::empty(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and mark_compactor_events_.

Here is the call graph for this function:

MeanMarkCompactorDuration()

double v8::internal::GCTracer::MeanMarkCompactorDuration ( ) const

inline

Definition at line 291 of file gc-tracer.h.

                                           {
    return MeanDuration(mark_compactor_events_);
  }

References mark_compactor_events_, and MeanDuration().

Here is the call graph for this function:

MeanScavengerDuration()

double v8::internal::GCTracer::MeanScavengerDuration ( ) const

inline

Definition at line 281 of file gc-tracer.h.

                                       {
    return MeanDuration(scavenger_events_);
  }

References MeanDuration(), and scavenger_events_.

Here is the call graph for this function:

NewSpaceAllocationThroughputInBytesPerMillisecond()

intptr_t v8::internal::GCTracer::NewSpaceAllocationThroughputInBytesPerMillisecond

(

)

const

Definition at line 465 of file gc-tracer.cc.

                                                                           {
  intptr_t bytes = 0;
  double durations = 0.0;
  AllocationEventBuffer::const_iterator iter = allocation_events_.begin();
  while (iter != allocation_events_.end()) {
    bytes += iter->allocation_in_bytes_;
    durations += iter->duration_;
    ++iter;
  }
 
  if (durations == 0.0) return 0;
 
  return static_cast<intptr_t>(bytes / durations);
}

References allocation_events_, v8::internal::RingBuffer< T, MAX_SIZE >::begin(), and v8::internal::RingBuffer< T, MAX_SIZE >::end().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Print()

void v8::internal::GCTracer::Print ( ) const

private

Definition at line 223 of file gc-tracer.cc.

                           {
  PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
 
  PrintF("%s %.1f (%.1f) -> %.1f (%.1f) MB, ", current_.TypeName(false),
         static_cast<double>(current_.start_object_size) / MB,
         static_cast<double>(current_.start_memory_size) / MB,
         static_cast<double>(current_.end_object_size) / MB,
         static_cast<double>(current_.end_memory_size) / MB);
 
  int external_time = static_cast<int>(current_.scopes[Scope::EXTERNAL]);
  if (external_time > 0) PrintF("%d / ", external_time);
 
  double duration = current_.end_time - current_.start_time;
  PrintF("%.1f ms", duration);
  if (current_.type == Event::SCAVENGER) {
    if (current_.incremental_marking_steps > 0) {
      PrintF(" (+ %.1f ms in %d steps since last GC)",
             current_.incremental_marking_duration,
             current_.incremental_marking_steps);
    }
  } else {
    if (current_.incremental_marking_steps > 0) {
      PrintF(
          " (+ %.1f ms in %d steps since start of marking, "
          "biggest step %.1f ms)",
          current_.incremental_marking_duration,
          current_.incremental_marking_steps,
          current_.longest_incremental_marking_step);
    }
  }
 
  if (current_.gc_reason != NULL) {
    PrintF(" [%s]", current_.gc_reason);
  }
 
  if (current_.collector_reason != NULL) {
    PrintF(" [%s]", current_.collector_reason);
  }
 
  PrintF(".\n");
}

References v8::internal::GCTracer::Event::collector_reason, current_, v8::internal::GCTracer::Event::end_memory_size, v8::internal::GCTracer::Event::end_object_size, v8::internal::GCTracer::Event::end_time, v8::internal::GCTracer::Scope::EXTERNAL, v8::internal::GCTracer::Event::gc_reason, heap_, v8::internal::GCTracer::Event::incremental_marking_duration, v8::internal::GCTracer::Event::incremental_marking_steps, v8::internal::Heap::isolate(), v8::internal::GCTracer::Event::longest_incremental_marking_step, v8::internal::MB, NULL, v8::internal::PrintF(), v8::internal::PrintPID(), v8::internal::GCTracer::Event::SCAVENGER, v8::internal::GCTracer::Event::scopes, v8::internal::GCTracer::Event::start_memory_size, v8::internal::GCTracer::Event::start_object_size, v8::internal::GCTracer::Event::start_time, v8::internal::Isolate::time_millis_since_init(), v8::internal::GCTracer::Event::type, and v8::internal::GCTracer::Event::TypeName().

Referenced by Stop().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintNVP()

void v8::internal::GCTracer::PrintNVP ( ) const

private

Definition at line 266 of file gc-tracer.cc.

                              {
  PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
 
  double duration = current_.end_time - current_.start_time;
  double spent_in_mutator = current_.start_time - previous_.end_time;
 
  PrintF("pause=%.1f ", duration);
  PrintF("mutator=%.1f ", spent_in_mutator);
  PrintF("gc=%s ", current_.TypeName(true));
 
  PrintF("external=%.1f ", current_.scopes[Scope::EXTERNAL]);
  PrintF("mark=%.1f ", current_.scopes[Scope::MC_MARK]);
  PrintF("sweep=%.2f ", current_.scopes[Scope::MC_SWEEP]);
  PrintF("sweepns=%.2f ", current_.scopes[Scope::MC_SWEEP_NEWSPACE]);
  PrintF("sweepos=%.2f ", current_.scopes[Scope::MC_SWEEP_OLDSPACE]);
  PrintF("sweepcode=%.2f ", current_.scopes[Scope::MC_SWEEP_CODE]);
  PrintF("sweepcell=%.2f ", current_.scopes[Scope::MC_SWEEP_CELL]);
  PrintF("sweepmap=%.2f ", current_.scopes[Scope::MC_SWEEP_MAP]);
  PrintF("evacuate=%.1f ", current_.scopes[Scope::MC_EVACUATE_PAGES]);
  PrintF("new_new=%.1f ",
         current_.scopes[Scope::MC_UPDATE_NEW_TO_NEW_POINTERS]);
  PrintF("root_new=%.1f ",
         current_.scopes[Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS]);
  PrintF("old_new=%.1f ",
         current_.scopes[Scope::MC_UPDATE_OLD_TO_NEW_POINTERS]);
  PrintF("compaction_ptrs=%.1f ",
         current_.scopes[Scope::MC_UPDATE_POINTERS_TO_EVACUATED]);
  PrintF("intracompaction_ptrs=%.1f ",
         current_.scopes[Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED]);
  PrintF("misc_compaction=%.1f ",
         current_.scopes[Scope::MC_UPDATE_MISC_POINTERS]);
  PrintF("weakcollection_process=%.1f ",
         current_.scopes[Scope::MC_WEAKCOLLECTION_PROCESS]);
  PrintF("weakcollection_clear=%.1f ",
         current_.scopes[Scope::MC_WEAKCOLLECTION_CLEAR]);
  PrintF("weakcollection_abort=%.1f ",
         current_.scopes[Scope::MC_WEAKCOLLECTION_ABORT]);
 
  PrintF("total_size_before=%" V8_PTR_PREFIX "d ", current_.start_object_size);
  PrintF("total_size_after=%" V8_PTR_PREFIX "d ", current_.end_object_size);
  PrintF("holes_size_before=%" V8_PTR_PREFIX "d ", current_.start_holes_size);
  PrintF("holes_size_after=%" V8_PTR_PREFIX "d ", current_.end_holes_size);
 
  intptr_t allocated_since_last_gc =
      current_.start_object_size - previous_.end_object_size;
  PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc);
  PrintF("promoted=%" V8_PTR_PREFIX "d ", heap_->promoted_objects_size_);
  PrintF("semi_space_copied=%" V8_PTR_PREFIX "d ",
         heap_->semi_space_copied_object_size_);
  PrintF("nodes_died_in_new=%d ", heap_->nodes_died_in_new_space_);
  PrintF("nodes_copied_in_new=%d ", heap_->nodes_copied_in_new_space_);
  PrintF("nodes_promoted=%d ", heap_->nodes_promoted_);
  PrintF("promotion_rate=%.1f%% ", heap_->promotion_rate_);
  PrintF("semi_space_copy_rate=%.1f%% ", heap_->semi_space_copied_rate_);
  PrintF("new_space_allocation_throughput=%" V8_PTR_PREFIX "d ",
         NewSpaceAllocationThroughputInBytesPerMillisecond());
 
  if (current_.type == Event::SCAVENGER) {
    PrintF("steps_count=%d ", current_.incremental_marking_steps);
    PrintF("steps_took=%.1f ", current_.incremental_marking_duration);
    PrintF("scavenge_throughput=%" V8_PTR_PREFIX "d ",
           ScavengeSpeedInBytesPerMillisecond());
  } else {
    PrintF("steps_count=%d ", current_.incremental_marking_steps);
    PrintF("steps_took=%.1f ", current_.incremental_marking_duration);
    PrintF("longest_step=%.1f ", current_.longest_incremental_marking_step);
    PrintF("incremental_marking_throughput=%" V8_PTR_PREFIX "d ",
           IncrementalMarkingSpeedInBytesPerMillisecond());
  }
 
  PrintF("\n");
}

References current_, v8::internal::GCTracer::Event::end_holes_size, v8::internal::GCTracer::Event::end_object_size, v8::internal::GCTracer::Event::end_time, v8::internal::GCTracer::Scope::EXTERNAL, heap_, v8::internal::GCTracer::Event::incremental_marking_duration, v8::internal::GCTracer::Event::incremental_marking_steps, IncrementalMarkingSpeedInBytesPerMillisecond(), v8::internal::Heap::isolate(), v8::internal::GCTracer::Event::longest_incremental_marking_step, v8::internal::GCTracer::Scope::MC_EVACUATE_PAGES, v8::internal::GCTracer::Scope::MC_MARK, v8::internal::GCTracer::Scope::MC_SWEEP, v8::internal::GCTracer::Scope::MC_SWEEP_CELL, v8::internal::GCTracer::Scope::MC_SWEEP_CODE, v8::internal::GCTracer::Scope::MC_SWEEP_MAP, v8::internal::GCTracer::Scope::MC_SWEEP_NEWSPACE, v8::internal::GCTracer::Scope::MC_SWEEP_OLDSPACE, v8::internal::GCTracer::Scope::MC_UPDATE_MISC_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_NEW_TO_NEW_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_OLD_TO_NEW_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED, v8::internal::GCTracer::Scope::MC_UPDATE_POINTERS_TO_EVACUATED, v8::internal::GCTracer::Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS, v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_ABORT, v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_CLEAR, v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_PROCESS, NewSpaceAllocationThroughputInBytesPerMillisecond(), v8::internal::Heap::nodes_copied_in_new_space_, v8::internal::Heap::nodes_died_in_new_space_, v8::internal::Heap::nodes_promoted_, previous_, v8::internal::PrintF(), v8::internal::PrintPID(), v8::internal::Heap::promoted_objects_size_, v8::internal::Heap::promotion_rate_, v8::internal::GCTracer::Event::SCAVENGER, ScavengeSpeedInBytesPerMillisecond(), v8::internal::GCTracer::Event::scopes, v8::internal::Heap::semi_space_copied_object_size_, v8::internal::Heap::semi_space_copied_rate_, v8::internal::GCTracer::Event::start_holes_size, v8::internal::GCTracer::Event::start_object_size, v8::internal::GCTracer::Event::start_time, v8::internal::Isolate::time_millis_since_init(), v8::internal::GCTracer::Event::type, v8::internal::GCTracer::Event::TypeName(), and V8_PTR_PREFIX.

Referenced by Stop().

Here is the call graph for this function:

Here is the caller graph for this function:

ScavengeSpeedInBytesPerMillisecond()

intptr_t v8::internal::GCTracer::ScavengeSpeedInBytesPerMillisecond

(

)

const

Definition at line 432 of file gc-tracer.cc.

                                                            {
  intptr_t bytes = 0;
  double durations = 0.0;
  EventBuffer::const_iterator iter = scavenger_events_.begin();
  while (iter != scavenger_events_.end()) {
    bytes += iter->new_space_object_size;
    durations += iter->end_time - iter->start_time;
    ++iter;
  }
 
  if (durations == 0.0) return 0;
 
  return static_cast<intptr_t>(bytes / durations);
}

References v8::internal::RingBuffer< T, MAX_SIZE >::begin(), v8::internal::RingBuffer< T, MAX_SIZE >::end(), and scavenger_events_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Start()

void v8::internal::GCTracer::Start	(	GarbageCollector	collector,
		const char *	gc_reason,
		const char *	collector_reason
	)

Definition at line 98 of file gc-tracer.cc.

                                                   {
  previous_ = current_;
  double start_time = base::OS::TimeCurrentMillis();
  if (new_space_top_after_gc_ != 0) {
    AddNewSpaceAllocationTime(
        start_time - previous_.end_time,
        reinterpret_cast<intptr_t>((heap_->new_space()->top()) -
                                   new_space_top_after_gc_));
  }
  if (current_.type == Event::MARK_COMPACTOR)
    previous_mark_compactor_event_ = current_;
 
  if (collector == SCAVENGER) {
    current_ = Event(Event::SCAVENGER, gc_reason, collector_reason);
  } else {
    current_ = Event(Event::MARK_COMPACTOR, gc_reason, collector_reason);
  }
 
  current_.start_time = start_time;
  current_.start_object_size = heap_->SizeOfObjects();
  current_.start_memory_size = heap_->isolate()->memory_allocator()->Size();
  current_.start_holes_size = CountTotalHolesSize(heap_);
  current_.new_space_object_size =
      heap_->new_space()->top() - heap_->new_space()->bottom();
 
  current_.cumulative_incremental_marking_steps =
      cumulative_incremental_marking_steps_;
  current_.cumulative_incremental_marking_bytes =
      cumulative_incremental_marking_bytes_;
  current_.cumulative_incremental_marking_duration =
      cumulative_incremental_marking_duration_;
  current_.cumulative_pure_incremental_marking_duration =
      cumulative_pure_incremental_marking_duration_;
  current_.longest_incremental_marking_step = longest_incremental_marking_step_;
 
  for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
    current_.scopes[i] = 0;
  }
}

References AddNewSpaceAllocationTime(), v8::internal::NewSpace::bottom(), v8::internal::CountTotalHolesSize(), v8::internal::GCTracer::Event::cumulative_incremental_marking_bytes, cumulative_incremental_marking_bytes_, v8::internal::GCTracer::Event::cumulative_incremental_marking_duration, cumulative_incremental_marking_duration_, v8::internal::GCTracer::Event::cumulative_incremental_marking_steps, cumulative_incremental_marking_steps_, v8::internal::GCTracer::Event::cumulative_pure_incremental_marking_duration, cumulative_pure_incremental_marking_duration_, current_, v8::internal::GCTracer::Event::end_time, heap_, v8::internal::Heap::isolate(), v8::internal::GCTracer::Event::longest_incremental_marking_step, longest_incremental_marking_step_, v8::internal::GCTracer::Event::MARK_COMPACTOR, v8::internal::Isolate::memory_allocator(), v8::internal::Heap::new_space(), v8::internal::GCTracer::Event::new_space_object_size, new_space_top_after_gc_, v8::internal::GCTracer::Scope::NUMBER_OF_SCOPES, previous_, previous_mark_compactor_event_, v8::internal::SCAVENGER, v8::internal::GCTracer::Event::SCAVENGER, v8::internal::GCTracer::Event::scopes, v8::internal::MemoryAllocator::Size(), v8::internal::Heap::SizeOfObjects(), v8::internal::GCTracer::Event::start_holes_size, v8::internal::GCTracer::Event::start_memory_size, v8::internal::GCTracer::Event::start_object_size, v8::internal::GCTracer::Event::start_time, v8::base::OS::TimeCurrentMillis(), v8::internal::NewSpace::top(), and v8::internal::GCTracer::Event::type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void v8::internal::GCTracer::Stop

(

)

Definition at line 140 of file gc-tracer.cc.

                    {
  current_.end_time = base::OS::TimeCurrentMillis();
  current_.end_object_size = heap_->SizeOfObjects();
  current_.end_memory_size = heap_->isolate()->memory_allocator()->Size();
  current_.end_holes_size = CountTotalHolesSize(heap_);
  new_space_top_after_gc_ =
      reinterpret_cast<intptr_t>(heap_->new_space()->top());
 
  if (current_.type == Event::SCAVENGER) {
    current_.incremental_marking_steps =
        current_.cumulative_incremental_marking_steps -
        previous_.cumulative_incremental_marking_steps;
    current_.incremental_marking_bytes =
        current_.cumulative_incremental_marking_bytes -
        previous_.cumulative_incremental_marking_bytes;
    current_.incremental_marking_duration =
        current_.cumulative_incremental_marking_duration -
        previous_.cumulative_incremental_marking_duration;
    current_.pure_incremental_marking_duration =
        current_.cumulative_pure_incremental_marking_duration -
        previous_.cumulative_pure_incremental_marking_duration;
    scavenger_events_.push_front(current_);
  } else {
    current_.incremental_marking_steps =
        current_.cumulative_incremental_marking_steps -
        previous_mark_compactor_event_.cumulative_incremental_marking_steps;
    current_.incremental_marking_bytes =
        current_.cumulative_incremental_marking_bytes -
        previous_mark_compactor_event_.cumulative_incremental_marking_bytes;
    current_.incremental_marking_duration =
        current_.cumulative_incremental_marking_duration -
        previous_mark_compactor_event_.cumulative_incremental_marking_duration;
    current_.pure_incremental_marking_duration =
        current_.cumulative_pure_incremental_marking_duration -
        previous_mark_compactor_event_
            .cumulative_pure_incremental_marking_duration;
    longest_incremental_marking_step_ = 0.0;
    mark_compactor_events_.push_front(current_);
  }
 
  // TODO(ernstm): move the code below out of GCTracer.
 
  if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
 
  double duration = current_.end_time - current_.start_time;
  double spent_in_mutator = Max(current_.start_time - previous_.end_time, 0.0);
 
  heap_->UpdateCumulativeGCStatistics(duration, spent_in_mutator,
                                      current_.scopes[Scope::MC_MARK]);
 
  if (current_.type == Event::SCAVENGER && FLAG_trace_gc_ignore_scavenger)
    return;
 
  if (FLAG_trace_gc) {
    if (FLAG_trace_gc_nvp)
      PrintNVP();
    else
      Print();
 
    heap_->PrintShortHeapStatistics();
  }
}

References v8::internal::CountTotalHolesSize(), v8::internal::GCTracer::Event::cumulative_incremental_marking_bytes, v8::internal::GCTracer::Event::cumulative_incremental_marking_duration, v8::internal::GCTracer::Event::cumulative_incremental_marking_steps, v8::internal::GCTracer::Event::cumulative_pure_incremental_marking_duration, current_, v8::internal::GCTracer::Event::end_holes_size, v8::internal::GCTracer::Event::end_memory_size, v8::internal::GCTracer::Event::end_object_size, v8::internal::GCTracer::Event::end_time, heap_, v8::internal::GCTracer::Event::incremental_marking_bytes, v8::internal::GCTracer::Event::incremental_marking_duration, v8::internal::GCTracer::Event::incremental_marking_steps, v8::internal::Heap::isolate(), longest_incremental_marking_step_, mark_compactor_events_, v8::internal::Max(), v8::internal::GCTracer::Scope::MC_MARK, v8::internal::Isolate::memory_allocator(), v8::internal::Heap::new_space(), new_space_top_after_gc_, previous_, previous_mark_compactor_event_, Print(), PrintNVP(), v8::internal::Heap::PrintShortHeapStatistics(), v8::internal::GCTracer::Event::pure_incremental_marking_duration, v8::internal::RingBuffer< T, MAX_SIZE >::push_front(), v8::internal::GCTracer::Event::SCAVENGER, scavenger_events_, v8::internal::GCTracer::Event::scopes, v8::internal::MemoryAllocator::Size(), v8::internal::Heap::SizeOfObjects(), v8::internal::GCTracer::Event::start_time, v8::base::OS::TimeCurrentMillis(), v8::internal::NewSpace::top(), v8::internal::GCTracer::Event::type, and v8::internal::Heap::UpdateCumulativeGCStatistics().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

allocation_events_

AllocationEventBuffer v8::internal::GCTracer::allocation_events_

private

Definition at line 360 of file gc-tracer.h.

Referenced by AddNewSpaceAllocationTime(), and NewSpaceAllocationThroughputInBytesPerMillisecond().

cumulative_incremental_marking_bytes_

intptr_t v8::internal::GCTracer::cumulative_incremental_marking_bytes_

private

Definition at line 367 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), IncrementalMarkingSpeedInBytesPerMillisecond(), and Start().

cumulative_incremental_marking_duration_

double v8::internal::GCTracer::cumulative_incremental_marking_duration_

private

Definition at line 370 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), IncrementalMarkingSpeedInBytesPerMillisecond(), MeanIncrementalMarkingDuration(), and Start().

cumulative_incremental_marking_steps_

int v8::internal::GCTracer::cumulative_incremental_marking_steps_

private

Definition at line 363 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), MeanIncrementalMarkingDuration(), and Start().

cumulative_marking_duration_

double v8::internal::GCTracer::cumulative_marking_duration_

private

Definition at line 381 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), AddMarkingTime(), and cumulative_marking_duration().

cumulative_pure_incremental_marking_duration_

double v8::internal::GCTracer::cumulative_pure_incremental_marking_duration_

private

Definition at line 374 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), IncrementalMarkingSpeedInBytesPerMillisecond(), and Start().

cumulative_sweeping_duration_

double v8::internal::GCTracer::cumulative_sweeping_duration_

private

Definition at line 390 of file gc-tracer.h.

Referenced by AddSweepingTime(), and cumulative_sweeping_duration().

current_

Event v8::internal::GCTracer::current_

private

Definition at line 345 of file gc-tracer.h.

Referenced by GCTracer(), Print(), PrintNVP(), Start(), Stop(), and v8::internal::GCTracer::Scope::~Scope().

heap_

Heap* v8::internal::GCTracer::heap_

private

Definition at line 341 of file gc-tracer.h.

Referenced by Print(), PrintNVP(), Start(), and Stop().

kRingBufferMaxSize

const int v8::internal::GCTracer::kRingBufferMaxSize = 10

static

Definition at line 238 of file gc-tracer.h.

longest_incremental_marking_step_

double v8::internal::GCTracer::longest_incremental_marking_step_

private

Definition at line 377 of file gc-tracer.h.

Referenced by AddIncrementalMarkingStep(), MaxIncrementalMarkingDuration(), Start(), and Stop().

mark_compactor_events_

EventBuffer v8::internal::GCTracer::mark_compactor_events_

private

Definition at line 357 of file gc-tracer.h.

Referenced by IncrementalMarkingSpeedInBytesPerMillisecond(), MarkCompactSpeedInBytesPerMillisecond(), MaxIncrementalMarkingDuration(), MaxMarkCompactorDuration(), MeanIncrementalMarkingDuration(), MeanMarkCompactorDuration(), and Stop().

new_space_top_after_gc_

intptr_t v8::internal::GCTracer::new_space_top_after_gc_

private

Definition at line 394 of file gc-tracer.h.

Referenced by Start(), and Stop().

previous_

Event v8::internal::GCTracer::previous_

private

Definition at line 348 of file gc-tracer.h.

Referenced by GCTracer(), PrintNVP(), Start(), and Stop().

previous_mark_compactor_event_

Event v8::internal::GCTracer::previous_mark_compactor_event_

private

Definition at line 351 of file gc-tracer.h.

Referenced by GCTracer(), Start(), and Stop().

scavenger_events_

EventBuffer v8::internal::GCTracer::scavenger_events_

private

Definition at line 354 of file gc-tracer.h.

Referenced by MaxScavengerDuration(), MeanScavengerDuration(), ScavengeSpeedInBytesPerMillisecond(), and Stop().

---

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

• /mnt/V8SourceCode/src/heap/gc-tracer.h
• /mnt/V8SourceCode/src/heap/gc-tracer.cc