v8::internal::Instrument Class Reference

#include <instrument-arm64.h>

Inheritance diagram for v8::internal::Instrument:

Collaboration diagram for v8::internal::Instrument:

Public Member Functions
	Instrument (const char *datafile=NULL, uint64_t sample_period=kDefaultInstrumentationSamplingPeriod)
	~Instrument ()
Public Member Functions inherited from v8::internal::DecoderVisitor
virtual	~DecoderVisitor ()

Private Member Functions
void	Update ()
void	Enable ()
void	Disable ()
void	DumpCounters ()
void	DumpCounterNames ()
void	DumpEventMarker (unsigned marker)
void	HandleInstrumentationEvent (unsigned event)
Counter *	GetCounter (const char *name)
void	InstrumentLoadStore (Instruction *instr)
void	InstrumentLoadStorePair (Instruction *instr)

Private Attributes
std::list< Counter * >	counters_
FILE *	output_stream_
uint64_t	sample_period_

Detailed Description

Definition at line 53 of file instrument-arm64.h.

Constructor & Destructor Documentation

Instrument()

v8::internal::Instrument::Instrument ( const char *  datafile = NULL, uint64_t  sample_period = kDefaultInstrumentationSamplingPeriod  )

explicit

Definition at line 97 of file instrument-arm64.cc.

    : output_stream_(stderr), sample_period_(sample_period) {
 
  // Set up the output stream. If datafile is non-NULL, use that file. If it
  // can't be opened, or datafile is NULL, use stderr.
  if (datafile != NULL) {
    output_stream_ = fopen(datafile, "w");
    if (output_stream_ == NULL) {
      fprintf(stderr, "Can't open output file %s. Using stderr.\n", datafile);
      output_stream_ = stderr;
    }
  }
 
  static const int num_counters = arraysize(kCounterList);
 
  // Dump an instrumentation description comment at the top of the file.
  fprintf(output_stream_, "# counters=%d\n", num_counters);
  fprintf(output_stream_, "# sample_period=%" PRIu64 "\n", sample_period_);
 
  // Construct Counter objects from counter description array.
  for (int i = 0; i < num_counters; i++) {
    Counter* counter = new Counter(kCounterList[i].name, kCounterList[i].type);
    counters_.push_back(counter);
  }
 
  DumpCounterNames();
}

References arraysize, counters_, DumpCounterNames(), v8::internal::kCounterList, name, NULL, output_stream_, and sample_period_.

Here is the call graph for this function:

~Instrument()

v8::internal::Instrument::~Instrument

(

)

Definition at line 126 of file instrument-arm64.cc.

                        {
  // Dump any remaining instruction data to the output file.
  DumpCounters();
 
  // Free all the counter objects.
  std::list<Counter*>::iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    delete *it;
  }
 
  if (output_stream_ != stderr) {
    fclose(output_stream_);
  }
}

References counters_, DumpCounters(), and output_stream_.

Here is the call graph for this function:

Member Function Documentation

Disable()

void v8::internal::Instrument::Disable ( )

private

Definition at line 225 of file instrument-arm64.cc.

                         {
  std::list<Counter*>::iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    (*it)->Disable();
  }
}

References counters_.

Referenced by HandleInstrumentationEvent().

Here is the caller graph for this function:

DumpCounterNames()

void v8::internal::Instrument::DumpCounterNames ( )

private

Definition at line 167 of file instrument-arm64.cc.

                                  {
  // Iterate through the counter objects, dumping the counter names to the
  // output stream.
  std::list<Counter*>::const_iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    fprintf(output_stream_, "%s,", (*it)->name());
  }
  fprintf(output_stream_, "\n");
  fflush(output_stream_);
}

References counters_, and output_stream_.

Referenced by Instrument().

Here is the caller graph for this function:

DumpCounters()

void v8::internal::Instrument::DumpCounters ( )

private

Definition at line 155 of file instrument-arm64.cc.

                              {
  // Iterate through the counter objects, dumping their values to the output
  // stream.
  std::list<Counter*>::const_iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    fprintf(output_stream_, "%" PRIu64 ",", (*it)->count());
  }
  fprintf(output_stream_, "\n");
  fflush(output_stream_);
}

References counters_, and output_stream_.

Referenced by Update(), and ~Instrument().

Here is the caller graph for this function:

DumpEventMarker()

void v8::internal::Instrument::DumpEventMarker ( unsigned  marker )

private

Definition at line 188 of file instrument-arm64.cc.

                                                {
  // Dumpan event marker to the output stream as a specially formatted comment
  // line.
  static Counter* counter = GetCounter("Instruction");
 
  fprintf(output_stream_, "# %c%c @ %" PRId64 "\n", marker & 0xff,
          (marker >> 8) & 0xff, counter->count());
}

References v8::internal::Counter::count(), GetCounter(), and output_stream_.

Referenced by HandleInstrumentationEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

Enable()

void v8::internal::Instrument::Enable ( )

private

Definition at line 217 of file instrument-arm64.cc.

                        {
  std::list<Counter*>::iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    (*it)->Enable();
  }
}

References counters_.

Referenced by HandleInstrumentationEvent().

Here is the caller graph for this function:

GetCounter()

Counter * v8::internal::Instrument::GetCounter ( const char *  name )

private

Definition at line 198 of file instrument-arm64.cc.

                                                {
  // Get a Counter object by name from the counter list.
  std::list<Counter*>::const_iterator it;
  for (it = counters_.begin(); it != counters_.end(); it++) {
    if (strcmp((*it)->name(), name) == 0) {
      return *it;
    }
  }
 
  // A Counter by that name does not exist: print an error message to stderr
  // and the output file, and exit.
  static const char* error_message =
    "# Error: Unknown counter \"%s\". Exiting.\n";
  fprintf(stderr, error_message, name);
  fprintf(output_stream_, error_message, name);
  exit(1);
}

References counters_, name, and output_stream_.

Referenced by DumpEventMarker(), InstrumentLoadStore(), InstrumentLoadStorePair(), and Update().

Here is the caller graph for this function:

HandleInstrumentationEvent()

void v8::internal::Instrument::HandleInstrumentationEvent ( unsigned  event )

private

Definition at line 179 of file instrument-arm64.cc.

                                                          {
  switch (event) {
    case InstrumentStateEnable: Enable(); break;
    case InstrumentStateDisable: Disable(); break;
    default: DumpEventMarker(event);
  }
}

References Disable(), DumpEventMarker(), Enable(), v8::internal::InstrumentStateDisable, and v8::internal::InstrumentStateEnable.

Here is the call graph for this function:

InstrumentLoadStore()

void v8::internal::Instrument::InstrumentLoadStore ( Instruction *  instr )

private

Definition at line 380 of file instrument-arm64.cc.

                                                       {
  static Counter* load_int_counter = GetCounter("Load Integer");
  static Counter* store_int_counter = GetCounter("Store Integer");
  static Counter* load_fp_counter = GetCounter("Load FP");
  static Counter* store_fp_counter = GetCounter("Store FP");
 
  switch (instr->Mask(LoadStoreOpMask)) {
    case STRB_w:    // Fall through.
    case STRH_w:    // Fall through.
    case STR_w:     // Fall through.
    case STR_x:     store_int_counter->Increment(); break;
    case STR_s:     // Fall through.
    case STR_d:     store_fp_counter->Increment(); break;
    case LDRB_w:    // Fall through.
    case LDRH_w:    // Fall through.
    case LDR_w:     // Fall through.
    case LDR_x:     // Fall through.
    case LDRSB_x:   // Fall through.
    case LDRSH_x:   // Fall through.
    case LDRSW_x:   // Fall through.
    case LDRSB_w:   // Fall through.
    case LDRSH_w:   load_int_counter->Increment(); break;
    case LDR_s:     // Fall through.
    case LDR_d:     load_fp_counter->Increment(); break;
    default: UNREACHABLE();
  }
}

References GetCounter(), v8::internal::Counter::Increment(), v8::internal::LoadStoreOpMask, v8::internal::Instruction::Mask(), and UNREACHABLE.

Here is the call graph for this function:

InstrumentLoadStorePair()

void v8::internal::Instrument::InstrumentLoadStorePair ( Instruction *  instr )

private

Definition at line 338 of file instrument-arm64.cc.

                                                           {
  static Counter* load_pair_counter = GetCounter("Load Pair");
  static Counter* store_pair_counter = GetCounter("Store Pair");
  if (instr->Mask(LoadStorePairLBit) != 0) {
    load_pair_counter->Increment();
  } else {
    store_pair_counter->Increment();
  }
}

References GetCounter(), v8::internal::Counter::Increment(), v8::internal::LoadStorePairLBit, and v8::internal::Instruction::Mask().

Here is the call graph for this function:

Update()

void v8::internal::Instrument::Update ( )

private

Definition at line 142 of file instrument-arm64.cc.

                        {
  // Increment the instruction counter, and dump all counters if a sample period
  // has elapsed.
  static Counter* counter = GetCounter("Instruction");
  DCHECK(counter->type() == Cumulative);
  counter->Increment();
 
  if (counter->IsEnabled() && (counter->count() % sample_period_) == 0) {
    DumpCounters();
  }
}

References v8::internal::Counter::count(), v8::internal::Cumulative, DCHECK, DumpCounters(), GetCounter(), v8::internal::Counter::Increment(), v8::internal::Counter::IsEnabled(), sample_period_, and v8::internal::Counter::type().

Here is the call graph for this function:

Member Data Documentation

counters_

std::list<Counter*> v8::internal::Instrument::counters_

private

Definition at line 77 of file instrument-arm64.h.

Referenced by Disable(), DumpCounterNames(), DumpCounters(), Enable(), GetCounter(), Instrument(), and ~Instrument().

output_stream_

FILE* v8::internal::Instrument::output_stream_

private

Definition at line 79 of file instrument-arm64.h.

Referenced by DumpCounterNames(), DumpCounters(), DumpEventMarker(), GetCounter(), Instrument(), and ~Instrument().

sample_period_

uint64_t v8::internal::Instrument::sample_period_

private

Definition at line 80 of file instrument-arm64.h.

Referenced by Instrument(), and Update().

---

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

• /mnt/V8SourceCode/src/arm64/instrument-arm64.h
• /mnt/V8SourceCode/src/arm64/instrument-arm64.cc