base/profiler/stack_sampling_profiler.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/profiler/stack_sampling_profiler.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/memory/singleton.h"
  12 #include "base/synchronization/lock.h"
  13 #include "base/synchronization/waitable_event.h"
  14 #include "base/timer/elapsed_timer.h"
  15
  16 template <typename T> struct DefaultSingletonTraits;
  17
  18 namespace base {
  19
  20 namespace {
  21
  22 // Thread-safe singleton class that stores collected profiles waiting to be
  23 // processed.
  24 class PendingProfiles {
  25  public:
  26   PendingProfiles();
  27   ~PendingProfiles();
  28
  29   static PendingProfiles* GetInstance();
  30
  31   // Appends |profiles|. This function is thread safe.
  32   void PutProfiles(const std::vector<StackSamplingProfiler::Profile>& profiles);
  33   // Gets the pending profiles into *|profiles|. This function is thread safe.
  34   void GetProfiles(std::vector<StackSamplingProfiler::Profile>* profiles);
  35
  36  private:
  37   Lock profiles_lock_;
  38   std::vector<StackSamplingProfiler::Profile> profiles_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(PendingProfiles);
  41 };
  42
  43 PendingProfiles::PendingProfiles() {}
  44
  45 PendingProfiles::~PendingProfiles() {}
  46
  47 // static
  48 PendingProfiles* PendingProfiles::GetInstance() {
  49   return Singleton<PendingProfiles>::get();
  50 }
  51
  52 void PendingProfiles::PutProfiles(
  53     const std::vector<StackSamplingProfiler::Profile>& profiles) {
  54   AutoLock scoped_lock(profiles_lock_);
  55   profiles_.insert(profiles_.end(), profiles.begin(), profiles.end());
  56 }
  57
  58 void PendingProfiles::GetProfiles(
  59     std::vector<StackSamplingProfiler::Profile>* profiles) {
  60   profiles->clear();
  61
  62   AutoLock scoped_lock(profiles_lock_);
  63   profiles_.swap(*profiles);
  64 }
  65 }  // namespace
  66
  67 StackSamplingProfiler::Module::Module() : base_address(nullptr) {}
  68 StackSamplingProfiler::Module::Module(const void* base_address,
  69                                       const std::string& id,
  70                                       const FilePath& filename)
  71     : base_address(base_address), id(id), filename(filename) {}
  72
  73 StackSamplingProfiler::Module::~Module() {}
  74
  75 StackSamplingProfiler::Frame::Frame()
  76     : instruction_pointer(nullptr),
  77       module_index(-1) {}
  78
  79 StackSamplingProfiler::Frame::Frame(const void* instruction_pointer,
  80                                     int module_index)
  81     : instruction_pointer(instruction_pointer),
  82       module_index(module_index) {}
  83
  84 StackSamplingProfiler::Frame::~Frame() {}
  85
  86 StackSamplingProfiler::Profile::Profile() : preserve_sample_ordering(false) {}
  87
  88 StackSamplingProfiler::Profile::~Profile() {}
  89
  90 class StackSamplingProfiler::SamplingThread : public PlatformThread::Delegate {
  91  public:
  92   // Samples stacks using |native_sampler|. When complete, invokes
  93   // |profiles_callback| with the collected profiles. |profiles_callback| must
  94   // be thread-safe and may consume the contents of the vector.
  95   SamplingThread(
  96       scoped_ptr<NativeStackSampler> native_sampler,
  97       const SamplingParams& params,
  98       Callback<void(const std::vector<Profile>&)> completed_callback);
  99   ~SamplingThread() override;
 100
 101   // Implementation of PlatformThread::Delegate:
 102   void ThreadMain() override;
 103
 104   void Stop();
 105
 106  private:
 107   // Collects a profile from a single burst. Returns true if the profile was
 108   // collected, or false if collection was stopped before it completed.
 109   bool CollectProfile(Profile* profile, TimeDelta* elapsed_time);
 110   // Collects profiles from all bursts, or until the sampling is stopped. If
 111   // stopped before complete, |profiles| will contains only full bursts.
 112   void CollectProfiles(std::vector<Profile>* profiles);
 113
 114   scoped_ptr<NativeStackSampler> native_sampler_;
 115
 116   const SamplingParams params_;
 117
 118   WaitableEvent stop_event_;
 119
 120   Callback<void(const std::vector<Profile>&)> completed_callback_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(SamplingThread);
 123 };
 124
 125 StackSamplingProfiler::SamplingThread::SamplingThread(
 126     scoped_ptr<NativeStackSampler> native_sampler,
 127     const SamplingParams& params,
 128     Callback<void(const std::vector<Profile>&)> completed_callback)
 129     : native_sampler_(native_sampler.Pass()),
 130       params_(params),
 131       stop_event_(false, false),
 132       completed_callback_(completed_callback) {
 133 }
 134
 135 StackSamplingProfiler::SamplingThread::~SamplingThread() {}
 136
 137 void StackSamplingProfiler::SamplingThread::ThreadMain() {
 138   PlatformThread::SetName("Chrome_SamplingProfilerThread");
 139
 140   std::vector<Profile> profiles;
 141   CollectProfiles(&profiles);
 142   completed_callback_.Run(profiles);
 143 }
 144
 145 bool StackSamplingProfiler::SamplingThread::CollectProfile(
 146     Profile* profile,
 147     TimeDelta* elapsed_time) {
 148   ElapsedTimer profile_timer;
 149   Profile current_profile;
 150   native_sampler_->ProfileRecordingStarting(&current_profile);
 151   current_profile.sampling_period = params_.sampling_interval;
 152   bool stopped_early = false;
 153   for (int i = 0; i < params_.samples_per_burst; ++i) {
 154     ElapsedTimer sample_timer;
 155     current_profile.samples.push_back(Sample());
 156     native_sampler_->RecordStackSample(&current_profile.samples.back());
 157     TimeDelta elapsed_sample_time = sample_timer.Elapsed();
 158     if (i != params_.samples_per_burst - 1) {
 159       if (stop_event_.TimedWait(
 160               std::max(params_.sampling_interval - elapsed_sample_time,
 161                        TimeDelta()))) {
 162         stopped_early = true;
 163         break;
 164       }
 165     }
 166   }
 167
 168   *elapsed_time = profile_timer.Elapsed();
 169   current_profile.profile_duration = *elapsed_time;
 170   native_sampler_->ProfileRecordingStopped();
 171
 172   if (!stopped_early)
 173     *profile = current_profile;
 174
 175   return !stopped_early;
 176 }
 177
 178 void StackSamplingProfiler::SamplingThread::CollectProfiles(
 179     std::vector<Profile>* profiles) {
 180   if (stop_event_.TimedWait(params_.initial_delay))
 181     return;
 182
 183   for (int i = 0; i < params_.bursts; ++i) {
 184     Profile profile;
 185     TimeDelta elapsed_profile_time;
 186     if (CollectProfile(&profile, &elapsed_profile_time))
 187       profiles->push_back(profile);
 188     else
 189       return;
 190
 191     if (stop_event_.TimedWait(
 192             std::max(params_.burst_interval - elapsed_profile_time,
 193                      TimeDelta())))
 194       return;
 195   }
 196 }
 197
 198 void StackSamplingProfiler::SamplingThread::Stop() {
 199   stop_event_.Signal();
 200 }
 201
 202 void StackSamplingProfiler::SamplingThreadDeleter::operator()(
 203     SamplingThread* thread) const {
 204   delete thread;
 205 }
 206
 207 StackSamplingProfiler::NativeStackSampler::NativeStackSampler() {}
 208
 209 StackSamplingProfiler::NativeStackSampler::~NativeStackSampler() {}
 210
 211 StackSamplingProfiler::SamplingParams::SamplingParams()
 212     : initial_delay(TimeDelta::FromMilliseconds(0)),
 213       bursts(1),
 214       burst_interval(TimeDelta::FromMilliseconds(10000)),
 215       samples_per_burst(300),
 216       sampling_interval(TimeDelta::FromMilliseconds(100)),
 217       preserve_sample_ordering(false) {
 218 }
 219
 220 StackSamplingProfiler::StackSamplingProfiler(PlatformThreadId thread_id,
 221                                              const SamplingParams& params)
 222     : thread_id_(thread_id), params_(params) {}
 223
 224 StackSamplingProfiler::~StackSamplingProfiler() {}
 225
 226 void StackSamplingProfiler::Start() {
 227   native_sampler_ = NativeStackSampler::Create(thread_id_);
 228   if (!native_sampler_)
 229     return;
 230
 231   sampling_thread_.reset(
 232       new SamplingThread(
 233           native_sampler_.Pass(), params_,
 234           (custom_completed_callback_.is_null() ?
 235            Bind(&PendingProfiles::PutProfiles,
 236                 Unretained(PendingProfiles::GetInstance())) :
 237            custom_completed_callback_)));
 238   if (!PlatformThread::CreateNonJoinable(0, sampling_thread_.get()))
 239     LOG(ERROR) << "failed to create thread";
 240 }
 241
 242 void StackSamplingProfiler::Stop() {
 243   if (sampling_thread_)
 244     sampling_thread_->Stop();
 245 }
 246
 247 // static
 248 void StackSamplingProfiler::GetPendingProfiles(std::vector<Profile>* profiles) {
 249   PendingProfiles::GetInstance()->GetProfiles(profiles);
 250 }
 251
 252 void StackSamplingProfiler::SetCustomCompletedCallback(
 253     Callback<void(const std::vector<Profile>&)> callback) {
 254   custom_completed_callback_ = callback;
 255 }
 256
 257 bool operator==(const StackSamplingProfiler::Frame &a,
 258                 const StackSamplingProfiler::Frame &b) {
 259   return a.instruction_pointer == b.instruction_pointer &&
 260       a.module_index == b.module_index;
 261 }
 262
 263 bool operator<(const StackSamplingProfiler::Frame &a,
 264                const StackSamplingProfiler::Frame &b) {
 265   return (a.module_index < b.module_index) ||
 266       (a.module_index == b.module_index &&
 267        a.instruction_pointer < b.instruction_pointer);
 268 }
 269
 270 }  // namespace base