dart::HeapProfileSampler Class Reference

#include <sampler.h>

Public Member Functions
	HeapProfileSampler (Thread *thread)
void	Initialize ()
void	Cleanup ()
void	ScheduleUpdateThreadEnable ()
bool	ShouldUpdateThreadEnable ()
void	UpdateThreadEnable ()
void	ScheduleSetThreadSamplingInterval ()
bool	ShouldSetThreadSamplingInterval ()
void	SetThreadSamplingInterval ()
void	HandleReleasedTLAB (Thread *thread)
void	HandleNewTLAB (intptr_t old_tlab_remaining_space, bool is_first_tlab)
void *	InvokeCallbackForLastSample (intptr_t cid)
bool	HasOutstandingSample () const
void	SampleNewSpaceAllocation (intptr_t allocation_size)
void	SampleOldSpaceAllocation (intptr_t allocation_size)

Static Public Member Functions
static void	Enable (bool enabled)
static bool	enabled ()
static void	SetSamplingInterval (intptr_t bytes_interval)
static void	SetSamplingCallback (Dart_HeapSamplingCreateCallback create_callback, Dart_HeapSamplingDeleteCallback delete_callback)
static Dart_HeapSamplingDeleteCallback	delete_callback ()

Detailed Description

Definition at line 28 of file sampler.h.

Constructor & Destructor Documentation

HeapProfileSampler()

dart::HeapProfileSampler::HeapProfileSampler ( Thread *  thread )

explicit

Definition at line 44 of file sampler.cc.

    : interval_to_next_sample_(kUninitialized), thread_(thread) {}

Member Function Documentation

Cleanup()

void dart::HeapProfileSampler::Cleanup ( )

inline

Definition at line 59 of file sampler.h.

                 {
    ResetState();
    last_sample_size_ = kUninitialized;
  }

delete_callback()

static Dart_HeapSamplingDeleteCallback dart::HeapProfileSampler::delete_callback ( )

inlinestatic

Definition at line 54 of file sampler.h.

                                                           {
    return delete_callback_;
  }

Enable()

void dart::HeapProfileSampler::Enable ( bool  enabled )

static

Definition at line 47 of file sampler.cc.

                                            {
  // Don't try and change enabled state if sampler instances are currently
  // doing work.
  WriteRwLocker locker(Thread::Current(), lock_);
  enabled_ = enabled;
 
  IsolateGroup::ForEach([&](IsolateGroup* group) {
    group->thread_registry()->ForEachThread([&](Thread* thread) {
      thread->heap_sampler().ScheduleUpdateThreadEnable();
    });
  });
}

enabled()

static bool dart::HeapProfileSampler::enabled ( )

inlinestatic

Definition at line 39 of file sampler.h.

{ return enabled_; }

HandleNewTLAB()

void dart::HeapProfileSampler::HandleNewTLAB	(	intptr_t	old_tlab_remaining_space,
		bool	is_first_tlab
	)

Definition at line 162 of file sampler.cc.

                                                           {
  ASSERT_THREAD_STATE(thread_);
  ReadRwLocker locker(thread_, lock_);
  if (!enabled_ || (next_tlab_offset_ == kUninitialized && !is_first_tlab)) {
    return;
  } else if (is_first_tlab) {
    ASSERT(next_tlab_offset_ == kUninitialized);
    if (interval_to_next_sample_ != kUninitialized) {
      intptr_t top = thread_->top();
      intptr_t tlab_size = thread_->true_end() - top;
      if (tlab_size >= interval_to_next_sample_) {
        thread_->set_end(top + interval_to_next_sample_);
        ASSERT_TLAB_BOUNDARIES_VALID(thread_);
      } else {
        next_tlab_offset_ = interval_to_next_sample_ - tlab_size;
        ASSERT_TLAB_BOUNDARIES_VALID(thread_);
      }
    } else {
      SetThreadSamplingIntervalLocked();
    }
    return;
  }
  intptr_t updated_offset = next_tlab_offset_ + old_tlab_remaining_space;
  if (updated_offset + thread_->top() > thread_->true_end()) {
    // The next sampling point isn't in this TLAB.
    next_tlab_offset_ = updated_offset - (thread_->true_end() - thread_->top());
    thread_->set_end(thread_->true_end());
    ASSERT_TLAB_BOUNDARIES_VALID(thread_);
  } else {
    ASSERT(updated_offset <= static_cast<intptr_t>(thread_->true_end()) -
                                 static_cast<intptr_t>(thread_->top()));
    thread_->set_end(updated_offset + thread_->top());
    next_tlab_offset_ = kUninitialized;
    ASSERT_TLAB_BOUNDARIES_VALID(thread_);
  }
}

HandleReleasedTLAB()

void dart::HeapProfileSampler::HandleReleasedTLAB

(

Thread *

thread

)

Definition at line 153 of file sampler.cc.

                                                          {
  ReadRwLocker locker(thread, lock_);
  if (!enabled_) {
    return;
  }
  interval_to_next_sample_ = remaining_TLAB_interval();
  next_tlab_offset_ = kUninitialized;
}

HasOutstandingSample()

bool dart::HeapProfileSampler::HasOutstandingSample ( ) const

inline

Definition at line 124 of file sampler.h.

                                    {
    return last_sample_size_ != kUninitialized;
  }

Initialize()

void dart::HeapProfileSampler::Initialize

(

)

Definition at line 101 of file sampler.cc.

                                    {
  // Don't grab lock_ here as it can cause a deadlock if thread initialization
  // occurs when the profiler state is being changed. Instead, let the thread
  // perform initialization when it's no longer holding the thread registry's
  // thread_lock().
  ScheduleUpdateThreadEnable();
}

InvokeCallbackForLastSample()

void * dart::HeapProfileSampler::InvokeCallbackForLastSample

(

intptr_t

cid

)

Definition at line 200 of file sampler.cc.

                                                                  {
  ASSERT(enabled_);
  ASSERT(create_callback_ != nullptr);
  ReadRwLocker locker(thread_, lock_);
  ClassTable* table = IsolateGroup::Current()->class_table();
  void* result = create_callback_(
      reinterpret_cast<Dart_Isolate>(thread_->isolate()),
      reinterpret_cast<Dart_IsolateGroup>(thread_->isolate_group()),
      table->UserVisibleNameFor(cid), last_sample_size_);
  last_sample_size_ = kUninitialized;
  return result;
}

SampleNewSpaceAllocation()

void dart::HeapProfileSampler::SampleNewSpaceAllocation

(

intptr_t

allocation_size

)

Definition at line 213 of file sampler.cc.

                                                                          {
  ReadRwLocker locker(thread_, lock_);
  if (!enabled_) {
    return;
  }
  // We should never be sampling an allocation that won't fit in the
  // current TLAB.
  ASSERT(allocation_size <=
         static_cast<intptr_t>(thread_->true_end() - thread_->top()));
  ASSERT(sampling_interval_ >= 0);
 
  // Clean up interval state in preparation for a new interval.
  ResetIntervalState();
 
  if (UNLIKELY(allocation_size >= sampling_interval_)) {
    last_sample_size_ = allocation_size;
    // Reset the sampling interval, but only count the sample once.
    NumberOfSamplesLocked(allocation_size);
    return;
  }
  last_sample_size_ =
      sampling_interval_ * NumberOfSamplesLocked(allocation_size);
}

SampleOldSpaceAllocation()

void dart::HeapProfileSampler::SampleOldSpaceAllocation

(

intptr_t

allocation_size

)

Definition at line 237 of file sampler.cc.

                                                                          {
  ASSERT_THREAD_STATE(thread_);
  ReadRwLocker locker(thread_, lock_);
  if (!enabled_) {
    return;
  }
  ASSERT(sampling_interval_ >= 0);
  // Account for any new space allocations that have happened since we last
  // updated the sampling interval statistic.
  intptr_t tlab_interval = remaining_TLAB_interval();
  if (tlab_interval != kUninitialized) {
    interval_to_next_sample_ = tlab_interval;
  }
 
  // If we don't have a TLAB yet simply initialize interval_to_next_sample_
  // from the sampling interval.
  if (interval_to_next_sample_ == kUninitialized) {
    interval_to_next_sample_ = sampling_interval_;
  }
 
  // Check the allocation is large enough to trigger a sample. If not, tighten
  // the interval.
  if (allocation_size < interval_to_next_sample_) {
    intptr_t end = static_cast<intptr_t>(thread_->end());
    const intptr_t orig_end = end;
    const intptr_t true_end = static_cast<intptr_t>(thread_->true_end());
    const intptr_t orig_tlab_offset = next_tlab_offset_;
    USE(orig_tlab_offset);
    USE(orig_end);
    // We may not have a TLAB, don't pull one out of thin air.
    if (end != 0) {
      if (next_tlab_offset_ != kUninitialized) {
        end += next_tlab_offset_;
        next_tlab_offset_ = kUninitialized;
      }
 
      end += allocation_size;
      if (end > true_end) {
        thread_->set_end(true_end);
        next_tlab_offset_ = end - true_end;
        ASSERT_TLAB_BOUNDARIES_VALID(thread_);
      } else {
        thread_->set_end(end);
        ASSERT_TLAB_BOUNDARIES_VALID(thread_);
      }
    }
    interval_to_next_sample_ -= allocation_size;
    ASSERT(interval_to_next_sample_ > 0);
    return;
  }
  // Clean up interval state in preparation for a new interval.
  ResetIntervalState();
 
  // Find a new sampling point and reset TLAB boundaries.
  SetThreadSamplingIntervalLocked();
  last_sample_size_ = allocation_size;
}

ScheduleSetThreadSamplingInterval()

void dart::HeapProfileSampler::ScheduleSetThreadSamplingInterval

(

)

Definition at line 131 of file sampler.cc.

                                                           {
  schedule_thread_set_sampling_interval_ = true;
  thread_->ScheduleInterrupts(Thread::kVMInterrupt);
}

ScheduleUpdateThreadEnable()

void dart::HeapProfileSampler::ScheduleUpdateThreadEnable

(

)

Definition at line 109 of file sampler.cc.

                                                    {
  schedule_thread_enable_ = true;
  thread_->ScheduleInterrupts(Thread::kVMInterrupt);
}

SetSamplingCallback()

void dart::HeapProfileSampler::SetSamplingCallback ( Dart_HeapSamplingCreateCallback  create_callback, Dart_HeapSamplingDeleteCallback  delete_callback  )

static

Definition at line 81 of file sampler.cc.

                                                     {
  // Protect against the callback being changed in the middle of a sample.
  WriteRwLocker locker(Thread::Current(), lock_);
  if ((create_callback_ != nullptr && create_callback == nullptr) ||
      (delete_callback_ != nullptr && delete_callback == nullptr)) {
    FATAL("Clearing sampling callbacks is prohibited.");
  }
  create_callback_ = create_callback;
  delete_callback_ = delete_callback;
}

SetSamplingInterval()

void dart::HeapProfileSampler::SetSamplingInterval ( intptr_t  bytes_interval )

static

Definition at line 60 of file sampler.cc.

                                                                    {
  // Don't try and change sampling interval state if sampler instances are
  // currently doing work.
  WriteRwLocker locker(Thread::Current(), lock_);
  ASSERT(bytes_interval >= 0);
  sampling_interval_ = bytes_interval;
 
  // The sampling interval will be set in each thread once sampling is enabled.
  if (!enabled_) {
    return;
  }
 
  // If sampling is enabled, notify each thread that it should update its
  // sampling interval.
  IsolateGroup::ForEach([&](IsolateGroup* group) {
    group->thread_registry()->ForEachThread([&](Thread* thread) {
      thread->heap_sampler().ScheduleSetThreadSamplingInterval();
    });
  });
}

SetThreadSamplingInterval()

void dart::HeapProfileSampler::SetThreadSamplingInterval

(

)

Definition at line 136 of file sampler.cc.

                                                   {
  ASSERT_THREAD_STATE(thread_);
  ReadRwLocker locker(thread_, lock_);
  SetThreadSamplingIntervalLocked();
}

ShouldSetThreadSamplingInterval()

bool dart::HeapProfileSampler::ShouldSetThreadSamplingInterval ( )

inline

Definition at line 98 of file sampler.h.

                                         {
    return schedule_thread_set_sampling_interval_.exchange(false);
  }

ShouldUpdateThreadEnable()

bool dart::HeapProfileSampler::ShouldUpdateThreadEnable ( )

inline

Definition at line 76 of file sampler.h.

                                  {
    return schedule_thread_enable_.exchange(false);
  }

UpdateThreadEnable()

void dart::HeapProfileSampler::UpdateThreadEnable

(

)

Definition at line 114 of file sampler.cc.

                                            {
  ASSERT_THREAD_STATE(thread_);
  ReadRwLocker locker(Thread::Current(), lock_);
  UpdateThreadEnableLocked();
}

---

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

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