dart::Profiler Class Reference

#include <profiler.h>

Inheritance diagram for dart::Profiler:

Static Public Member Functions
static void	Init ()
static void	Cleanup ()
static void	SetSampleDepth (intptr_t depth)
static void	SetSamplePeriod (intptr_t period)
static void	UpdateSamplePeriod ()
static void	UpdateRunningState ()
static SampleBlockBuffer *	sample_block_buffer ()
static void	set_sample_block_buffer (SampleBlockBuffer *buffer)
static void	DumpStackTrace (void *context)
static void	DumpStackTrace (bool for_crash=true)
static void	SampleAllocation (Thread *thread, intptr_t cid, uint32_t identity_hash)
static void	SampleThread (Thread *thread, const InterruptedThreadState &state)
static ProfilerCounters	counters ()
static intptr_t	Size ()
static void	ProcessCompletedBlocks (Isolate *isolate)
static void	IsolateShutdown (Thread *thread)

Friends
class	Thread

Detailed Description

Definition at line 53 of file profiler.h.

Member Function Documentation

Cleanup()

void dart::Profiler::Cleanup ( )

static

Definition at line 605 of file profiler.cc.

                       {
  if (!FLAG_profiler) {
    return;
  }
  ASSERT(initialized_);
  ThreadInterrupter::Cleanup();
  SampleBlockProcessor::Cleanup();
  SampleBlockCleanupVisitor visitor;
  Isolate::VisitIsolates(&visitor);
  initialized_ = false;
}

counters()

static ProfilerCounters dart::Profiler::counters ( )

inlinestatic

Definition at line 91 of file profiler.h.

                                     {
    // Copies the counter values.
    return counters_;
  }

DumpStackTrace() [1/2]

void dart::Profiler::DumpStackTrace ( bool  for_crash = true )

static

Definition at line 458 of file profiler.cc.

                                            {
  uintptr_t sp = OSThread::GetCurrentStackPointer();
  uintptr_t fp = 0;
  uintptr_t pc = OS::GetProgramCounter();
 
  COPY_FP_REGISTER(fp);
 
  DumpStackTrace(sp, fp, pc, for_crash);
}

DumpStackTrace() [2/2]

void dart::Profiler::DumpStackTrace ( void *  context )

static

Definition at line 417 of file profiler.cc.

                                           {
  if (context == nullptr) {
    DumpStackTrace(/*for_crash=*/true);
    return;
  }
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID)
  ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
  mcontext_t mcontext = ucontext->uc_mcontext;
  uword pc = SignalHandler::GetProgramCounter(mcontext);
  uword fp = SignalHandler::GetFramePointer(mcontext);
  uword sp = SignalHandler::GetCStackPointer(mcontext);
  DumpStackTrace(sp, fp, pc, /*for_crash=*/true);
#elif defined(DART_HOST_OS_WINDOWS)
  CONTEXT* ctx = reinterpret_cast<CONTEXT*>(context);
#if defined(HOST_ARCH_IA32)
  uword pc = static_cast<uword>(ctx->Eip);
  uword fp = static_cast<uword>(ctx->Ebp);
  uword sp = static_cast<uword>(ctx->Esp);
#elif defined(HOST_ARCH_X64)
  uword pc = static_cast<uword>(ctx->Rip);
  uword fp = static_cast<uword>(ctx->Rbp);
  uword sp = static_cast<uword>(ctx->Rsp);
#elif defined(HOST_ARCH_ARM)
  uword pc = static_cast<uword>(ctx->Pc);
  uword fp = static_cast<uword>(ctx->R11);
  uword sp = static_cast<uword>(ctx->Sp);
#elif defined(HOST_ARCH_ARM64)
  uword pc = static_cast<uword>(ctx->Pc);
  uword fp = static_cast<uword>(ctx->Fp);
  uword sp = static_cast<uword>(ctx->Sp);
#else
#error Unsupported architecture.
#endif
  DumpStackTrace(sp, fp, pc, /*for_crash=*/true);
#else
// TODO(fschneider): Add support for more platforms.
// Do nothing on unsupported platforms.
#endif
}

Init()

void dart::Profiler::Init ( )

static

Definition at line 573 of file profiler.cc.

                    {
  // Place some sane restrictions on user controlled flags.
  SetSampleDepth(FLAG_max_profile_depth);
  if (!FLAG_profiler) {
    return;
  }
  ASSERT(!initialized_);
  SetSamplePeriod(FLAG_profile_period);
  // The profiler may have been shutdown previously, in which case the sample
  // buffer will have already been initialized.
  if (sample_block_buffer_ == nullptr) {
    intptr_t num_blocks = CalculateSampleBufferCapacity();
    sample_block_buffer_ = new SampleBlockBuffer(num_blocks);
  }
  ThreadInterrupter::Init();
  ThreadInterrupter::Startup();
  SampleBlockProcessor::Init();
  SampleBlockProcessor::Startup();
  initialized_ = true;
}

IsolateShutdown()

void dart::Profiler::IsolateShutdown ( Thread *  thread )

static

Definition at line 1854 of file profiler.cc.

                                             {
  FlushSampleBlocks(thread->isolate());
  ProcessCompletedBlocks(thread->isolate());
}

ProcessCompletedBlocks()

void dart::Profiler::ProcessCompletedBlocks ( Isolate *  isolate )

static

Definition at line 1837 of file profiler.cc.

                                                      {
  if (!Service::profiler_stream.enabled()) return;
  auto thread = Thread::Current();
  if (Isolate::IsSystemIsolate(isolate)) return;
 
  TIMELINE_DURATION(thread, Isolate, "Profiler::ProcessCompletedBlocks")
  DisableThreadInterruptsScope dtis(thread);
  StackZone zone(thread);
  HandleScope handle_scope(thread);
  StreamableSampleFilter filter(isolate->main_port(), isolate);
  Profile profile;
  profile.Build(thread, isolate, &filter, Profiler::sample_block_buffer());
  ServiceEvent event(isolate, ServiceEvent::kCpuSamples);
  event.set_cpu_profile(&profile);
  Service::HandleEvent(&event);
}

sample_block_buffer()

static SampleBlockBuffer * dart::Profiler::sample_block_buffer ( )

inlinestatic

Definition at line 67 of file profiler.h.

                                                  {
    return sample_block_buffer_;
  }

SampleAllocation()

void dart::Profiler::SampleAllocation ( Thread *  thread, intptr_t  cid, uint32_t  identity_hash  )

static

Definition at line 1271 of file profiler.cc.

                                                        {
  ASSERT(thread != nullptr);
  OSThread* os_thread = thread->os_thread();
  ASSERT(os_thread != nullptr);
  Isolate* isolate = thread->isolate();
  if (!CheckIsolate(isolate)) {
    return;
  }
  const bool exited_dart_code = thread->HasExitedDartCode();
 
  SampleBlockBuffer* buffer = Profiler::sample_block_buffer();
  if (buffer == nullptr) {
    // Profiler not initialized.
    return;
  }
 
  uintptr_t sp = OSThread::GetCurrentStackPointer();
  uintptr_t fp = 0;
  uintptr_t pc = OS::GetProgramCounter();
  uintptr_t lr = 0;
 
  COPY_FP_REGISTER(fp);
 
  uword stack_lower = 0;
  uword stack_upper = 0;
 
  if (!GetAndValidateThreadStackBounds(os_thread, thread, fp, sp, &stack_lower,
                                       &stack_upper)) {
    // Could not get stack boundary.
    return;
  }
 
  Sample* sample =
      SetupSample(thread, /*allocation_block*/ true, os_thread->trace_id());
  if (sample == nullptr) {
    // We were unable to assign a sample for this allocation.
    counters_.sample_allocation_failure++;
    return;
  }
  sample->SetAllocationCid(cid);
  sample->set_allocation_identity_hash(identity_hash);
 
  if (FLAG_profile_vm_allocation) {
    ProfilerNativeStackWalker native_stack_walker(
        &counters_, (isolate != nullptr) ? isolate->main_port() : ILLEGAL_PORT,
        sample, isolate->current_allocation_sample_block(), stack_lower,
        stack_upper, pc, fp, sp);
    native_stack_walker.walk();
  } else if (exited_dart_code) {
    ProfilerDartStackWalker dart_exit_stack_walker(
        thread, sample, isolate->current_allocation_sample_block(), pc, fp, sp,
        lr, /* allocation_sample*/ true);
    dart_exit_stack_walker.walk();
  } else {
    // Fall back.
    uintptr_t pc = OS::GetProgramCounter();
    sample->SetAt(0, pc);
  }
}

SampleThread()

void dart::Profiler::SampleThread ( Thread *  thread, const InterruptedThreadState &  state  )

static

Definition at line 1354 of file profiler.cc.

                                                                 {
  ASSERT(thread != nullptr);
  OSThread* os_thread = thread->os_thread();
  ASSERT(os_thread != nullptr);
  Isolate* isolate = thread->isolate();
 
  // Thread is not doing VM work.
  if (thread->task_kind() == Thread::kUnknownTask) {
    counters_.bail_out_unknown_task.fetch_add(1);
    return;
  }
 
  if (StubCode::HasBeenInitialized() && StubCode::InJumpToFrameStub(state.pc)) {
    // The JumpToFrame stub manually adjusts the stack pointer, frame
    // pointer, and some isolate state.  It is not safe to walk the
    // stack when executing this stub.
    counters_.bail_out_jump_to_exception_handler.fetch_add(1);
    return;
  }
 
  const bool in_dart_code = thread->IsExecutingDartCode();
 
  uintptr_t sp = 0;
  uintptr_t fp = state.fp;
  uintptr_t pc = state.pc;
  uintptr_t lr = state.lr;
#if defined(USING_SIMULATOR)
  Simulator* simulator = nullptr;
#endif
 
  if (in_dart_code) {
// If we're in Dart code, use the Dart stack pointer.
#if defined(USING_SIMULATOR)
    simulator = isolate->simulator();
    sp = simulator->get_register(SPREG);
    fp = simulator->get_register(FPREG);
    pc = simulator->get_pc();
    lr = simulator->get_lr();
#else
    sp = state.dsp;
#endif
  } else {
    // If we're in runtime code, use the C stack pointer.
    sp = state.csp;
  }
 
  if (!CheckIsolate(isolate)) {
    counters_.bail_out_check_isolate.fetch_add(1);
    return;
  }
 
  SampleBlockBuffer* sample_block_buffer = Profiler::sample_block_buffer();
  if (sample_block_buffer == nullptr) {
    // Profiler not initialized.
    return;
  }
 
  // Setup sample.
  Sample* sample =
      SetupSample(thread, /*allocation_block*/ false, os_thread->trace_id());
  if (sample == nullptr) {
    // We were unable to assign a sample for this profiler tick.
    counters_.sample_allocation_failure++;
    return;
  }
 
  if (thread->IsDartMutatorThread()) {
    if (isolate->IsDeoptimizing()) {
      counters_.single_frame_sample_deoptimizing.fetch_add(1);
      SampleThreadSingleFrame(thread, sample, pc);
      return;
    }
  }
 
  uword stack_lower = 0;
  uword stack_upper = 0;
  if (!GetAndValidateThreadStackBounds(os_thread, thread, fp, sp, &stack_lower,
                                       &stack_upper)) {
    counters_.single_frame_sample_get_and_validate_stack_bounds.fetch_add(1);
    // Could not get stack boundary.
    SampleThreadSingleFrame(thread, sample, pc);
    return;
  }
 
  // At this point we have a valid stack boundary for this isolate and
  // know that our initial stack and frame pointers are within the boundary.
 
  // Increment counter for vm tag.
  VMTagCounters* counters = isolate->vm_tag_counters();
  ASSERT(counters != nullptr);
  if (thread->IsDartMutatorThread()) {
    counters->Increment(sample->vm_tag());
  }
 
  ProfilerNativeStackWalker native_stack_walker(
      &counters_, (isolate != nullptr) ? isolate->main_port() : ILLEGAL_PORT,
      sample, isolate->current_sample_block(), stack_lower, stack_upper, pc, fp,
      sp);
  const bool exited_dart_code = thread->HasExitedDartCode();
  ProfilerDartStackWalker dart_stack_walker(
      thread, sample, isolate->current_sample_block(), pc, fp, sp, lr,
      /* allocation_sample*/ false);
 
  // All memory access is done inside CollectSample.
  CollectSample(isolate, exited_dart_code, in_dart_code, sample,
                &native_stack_walker, &dart_stack_walker, pc, fp, sp,
                &counters_);
}

set_sample_block_buffer()

static void dart::Profiler::set_sample_block_buffer ( SampleBlockBuffer *  buffer )

inlinestatic

Definition at line 70 of file profiler.h.

                                                                 {
    sample_block_buffer_ = buffer;
  }

SetSampleDepth()

void dart::Profiler::SetSampleDepth ( intptr_t  depth )

static

Definition at line 625 of file profiler.cc.

                                            {
  const int kMinimumDepth = 2;
  const int kMaximumDepth = 255;
  if (depth < kMinimumDepth) {
    FLAG_max_profile_depth = kMinimumDepth;
  } else if (depth > kMaximumDepth) {
    FLAG_max_profile_depth = kMaximumDepth;
  } else {
    FLAG_max_profile_depth = depth;
  }
}

SetSamplePeriod()

void dart::Profiler::SetSamplePeriod ( intptr_t  period )

static

Definition at line 656 of file profiler.cc.

                                              {
  const int kMinimumProfilePeriod = 50;
  if (period < kMinimumProfilePeriod) {
    FLAG_profile_period = kMinimumProfilePeriod;
  } else {
    FLAG_profile_period = period;
  }
  ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
}

Size()

intptr_t dart::Profiler::Size ( )

inlinestatic

Definition at line 787 of file profiler.h.

                        {
  intptr_t size = 0;
  if (sample_block_buffer_ != nullptr) {
    size += sample_block_buffer_->Size();
  }
  return size;
}

UpdateRunningState()

void dart::Profiler::UpdateRunningState ( )

static

Definition at line 617 of file profiler.cc.

                                  {
  if (!FLAG_profiler && initialized_) {
    Cleanup();
  } else if (FLAG_profiler && !initialized_) {
    Init();
  }
}

UpdateSamplePeriod()

void dart::Profiler::UpdateSamplePeriod ( )

static

Definition at line 666 of file profiler.cc.

                                  {
  SetSamplePeriod(FLAG_profile_period);
}

Friends And Related Function Documentation

Thread

friend class Thread

friend

Definition at line 120 of file profiler.h.

---

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

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