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/profiler/native_stack_sampler.h"
  13 #include "base/synchronization/lock.h"
  14 #include "base/timer/elapsed_timer.h"
  15
  16 namespace base {
  17
  18 // DefaultProfileProcessor ----------------------------------------------------
  19
  20 namespace {
  21
  22 // Singleton class responsible for providing the default processing for profiles
  23 // (i.e. for profiles generated by profilers without their own completed
  24 // callback).
  25 class DefaultProfileProcessor {
  26  public:
  27   using CompletedCallback = StackSamplingProfiler::CompletedCallback;
  28
  29   ~DefaultProfileProcessor();
  30
  31   static DefaultProfileProcessor* GetInstance();
  32
  33   // Sets the callback to use for processing profiles captured without a
  34   // per-profiler completed callback. Pending completed profiles are stored in
  35   // this object until a non-null callback is provided here. This function is
  36   // thread-safe.
  37   void SetCompletedCallback(CompletedCallback callback);
  38
  39   // Processes |profiles|. This function is thread safe.
  40   void ProcessProfiles(
  41       const StackSamplingProfiler::CallStackProfiles& profiles);
  42
  43  private:
  44   friend struct DefaultSingletonTraits<DefaultProfileProcessor>;
  45
  46   DefaultProfileProcessor();
  47
  48   // Copies the pending profiles from |profiles_| into |profiles|, and clears
  49   // |profiles_|. This function may be called on any thread.
  50   void GetAndClearPendingProfiles(
  51       StackSamplingProfiler::CallStackProfiles* profiles);
  52
  53   // Gets the current completed callback, with proper locking.
  54   CompletedCallback GetCompletedCallback() const;
  55
  56   mutable Lock callback_lock_;
  57   CompletedCallback default_completed_callback_;
  58
  59   Lock profiles_lock_;
  60   StackSamplingProfiler::CallStackProfiles profiles_;
  61
  62   DISALLOW_COPY_AND_ASSIGN(DefaultProfileProcessor);
  63 };
  64
  65 DefaultProfileProcessor::~DefaultProfileProcessor() {}
  66
  67 // static
  68 DefaultProfileProcessor* DefaultProfileProcessor::GetInstance() {
  69   return Singleton<DefaultProfileProcessor>::get();
  70 }
  71
  72 void DefaultProfileProcessor::SetCompletedCallback(CompletedCallback callback) {
  73   {
  74     AutoLock scoped_lock(callback_lock_);
  75     default_completed_callback_ = callback;
  76   }
  77
  78   if (!callback.is_null()) {
  79     // Provide any pending profiles to the callback immediately.
  80     StackSamplingProfiler::CallStackProfiles profiles;
  81     GetAndClearPendingProfiles(&profiles);
  82     if (!profiles.empty())
  83       callback.Run(profiles);
  84   }
  85 }
  86
  87 void DefaultProfileProcessor::ProcessProfiles(
  88     const StackSamplingProfiler::CallStackProfiles& profiles) {
  89   CompletedCallback callback = GetCompletedCallback();
  90
  91   // Store pending profiles if we don't have a valid callback.
  92   if (!callback.is_null()) {
  93     callback.Run(profiles);
  94   } else {
  95     AutoLock scoped_lock(profiles_lock_);
  96     profiles_.insert(profiles_.end(), profiles.begin(), profiles.end());
  97   }
  98 }
  99
 100 DefaultProfileProcessor::DefaultProfileProcessor() {}
 101
 102 void DefaultProfileProcessor::GetAndClearPendingProfiles(
 103     StackSamplingProfiler::CallStackProfiles* profiles) {
 104   profiles->clear();
 105
 106   AutoLock scoped_lock(profiles_lock_);
 107   profiles_.swap(*profiles);
 108 }
 109
 110 DefaultProfileProcessor::CompletedCallback
 111 DefaultProfileProcessor::GetCompletedCallback() const {
 112   AutoLock scoped_lock(callback_lock_);
 113   return default_completed_callback_;
 114 }
 115
 116 }  // namespace
 117
 118 // StackSamplingProfiler::Module ----------------------------------------------
 119
 120 StackSamplingProfiler::Module::Module() : base_address(nullptr) {}
 121 StackSamplingProfiler::Module::Module(const void* base_address,
 122                                       const std::string& id,
 123                                       const FilePath& filename)
 124     : base_address(base_address), id(id), filename(filename) {}
 125
 126 StackSamplingProfiler::Module::~Module() {}
 127
 128 // StackSamplingProfiler::Frame -----------------------------------------------
 129
 130 StackSamplingProfiler::Frame::Frame(const void* instruction_pointer,
 131                                     size_t module_index)
 132     : instruction_pointer(instruction_pointer),
 133       module_index(module_index) {}
 134
 135 StackSamplingProfiler::Frame::~Frame() {}
 136
 137 // StackSamplingProfiler::CallStackProfile ------------------------------------
 138
 139 StackSamplingProfiler::CallStackProfile::CallStackProfile()
 140     : preserve_sample_ordering(false), user_data(0) {}
 141
 142 StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
 143
 144 // StackSamplingProfiler::SamplingThread --------------------------------------
 145
 146 StackSamplingProfiler::SamplingThread::SamplingThread(
 147     scoped_ptr<NativeStackSampler> native_sampler,
 148     const SamplingParams& params,
 149     CompletedCallback completed_callback)
 150     : native_sampler_(native_sampler.Pass()),
 151       params_(params),
 152       stop_event_(false, false),
 153       completed_callback_(completed_callback) {
 154 }
 155
 156 StackSamplingProfiler::SamplingThread::~SamplingThread() {}
 157
 158 void StackSamplingProfiler::SamplingThread::ThreadMain() {
 159   PlatformThread::SetName("Chrome_SamplingProfilerThread");
 160
 161   CallStackProfiles profiles;
 162   CollectProfiles(&profiles);
 163   completed_callback_.Run(profiles);
 164 }
 165
 166 // Depending on how long the sampling takes and the length of the sampling
 167 // interval, a burst of samples could take arbitrarily longer than
 168 // samples_per_burst * sampling_interval. In this case, we (somewhat
 169 // arbitrarily) honor the number of samples requested rather than strictly
 170 // adhering to the sampling intervals. Once we have established users for the
 171 // StackSamplingProfiler and the collected data to judge, we may go the other
 172 // way or make this behavior configurable.
 173 bool StackSamplingProfiler::SamplingThread::CollectProfile(
 174     CallStackProfile* profile,
 175     TimeDelta* elapsed_time) {
 176   ElapsedTimer profile_timer;
 177   CallStackProfile current_profile;
 178   native_sampler_->ProfileRecordingStarting(&current_profile.modules);
 179   current_profile.sampling_period = params_.sampling_interval;
 180   bool burst_completed = true;
 181   TimeDelta previous_elapsed_sample_time;
 182   for (int i = 0; i < params_.samples_per_burst; ++i) {
 183     if (i != 0) {
 184       // Always wait, even if for 0 seconds, so we can observe a signal on
 185       // stop_event_.
 186       if (stop_event_.TimedWait(
 187               std::max(params_.sampling_interval - previous_elapsed_sample_time,
 188                        TimeDelta()))) {
 189         burst_completed = false;
 190         break;
 191       }
 192     }
 193     ElapsedTimer sample_timer;
 194     current_profile.samples.push_back(Sample());
 195     native_sampler_->RecordStackSample(&current_profile.samples.back());
 196     previous_elapsed_sample_time = sample_timer.Elapsed();
 197   }
 198
 199   *elapsed_time = profile_timer.Elapsed();
 200   current_profile.profile_duration = *elapsed_time;
 201   current_profile.preserve_sample_ordering = params_.preserve_sample_ordering;
 202   current_profile.user_data = params_.user_data;
 203   native_sampler_->ProfileRecordingStopped();
 204
 205   if (burst_completed)
 206     *profile = current_profile;
 207
 208   return burst_completed;
 209 }
 210
 211 // In an analogous manner to CollectProfile() and samples exceeding the expected
 212 // total sampling time, bursts may also exceed the burst_interval. We adopt the
 213 // same wait-and-see approach here.
 214 void StackSamplingProfiler::SamplingThread::CollectProfiles(
 215     CallStackProfiles* profiles) {
 216   if (stop_event_.TimedWait(params_.initial_delay))
 217     return;
 218
 219   TimeDelta previous_elapsed_profile_time;
 220   for (int i = 0; i < params_.bursts; ++i) {
 221     if (i != 0) {
 222       // Always wait, even if for 0 seconds, so we can observe a signal on
 223       // stop_event_.
 224       if (stop_event_.TimedWait(
 225               std::max(params_.burst_interval - previous_elapsed_profile_time,
 226                        TimeDelta())))
 227         return;
 228     }
 229
 230     CallStackProfile profile;
 231     if (!CollectProfile(&profile, &previous_elapsed_profile_time))
 232       return;
 233     profiles->push_back(profile);
 234   }
 235 }
 236
 237 void StackSamplingProfiler::SamplingThread::Stop() {
 238   stop_event_.Signal();
 239 }
 240
 241 // StackSamplingProfiler ------------------------------------------------------
 242
 243 StackSamplingProfiler::SamplingParams::SamplingParams()
 244     : initial_delay(TimeDelta::FromMilliseconds(0)),
 245       bursts(1),
 246       burst_interval(TimeDelta::FromMilliseconds(10000)),
 247       samples_per_burst(300),
 248       sampling_interval(TimeDelta::FromMilliseconds(100)),
 249       preserve_sample_ordering(false),
 250       user_data(0) {
 251 }
 252
 253 StackSamplingProfiler::StackSamplingProfiler(PlatformThreadId thread_id,
 254                                              const SamplingParams& params)
 255     : thread_id_(thread_id), params_(params) {}
 256
 257 StackSamplingProfiler::StackSamplingProfiler(PlatformThreadId thread_id,
 258                                              const SamplingParams& params,
 259                                              CompletedCallback callback)
 260     : thread_id_(thread_id), params_(params), completed_callback_(callback) {}
 261
 262 StackSamplingProfiler::~StackSamplingProfiler() {
 263   Stop();
 264   if (!sampling_thread_handle_.is_null())
 265     PlatformThread::Join(sampling_thread_handle_);
 266 }
 267
 268 void StackSamplingProfiler::Start() {
 269   scoped_ptr<NativeStackSampler> native_sampler =
 270       NativeStackSampler::Create(thread_id_);
 271   if (!native_sampler)
 272     return;
 273
 274   CompletedCallback callback =
 275       !completed_callback_.is_null() ? completed_callback_ :
 276       Bind(&DefaultProfileProcessor::ProcessProfiles,
 277            Unretained(DefaultProfileProcessor::GetInstance()));
 278   sampling_thread_.reset(
 279       new SamplingThread(native_sampler.Pass(), params_, callback));
 280   if (!PlatformThread::Create(0, sampling_thread_.get(),
 281                               &sampling_thread_handle_))
 282     sampling_thread_.reset();
 283 }
 284
 285 void StackSamplingProfiler::Stop() {
 286   if (sampling_thread_)
 287     sampling_thread_->Stop();
 288 }
 289
 290 // static
 291 void StackSamplingProfiler::SetDefaultCompletedCallback(
 292     CompletedCallback callback) {
 293   DefaultProfileProcessor::GetInstance()->SetCompletedCallback(callback);
 294 }
 295
 296 // StackSamplingProfiler::Frame global functions ------------------------------
 297
 298 bool operator==(const StackSamplingProfiler::Frame &a,
 299                 const StackSamplingProfiler::Frame &b) {
 300   return a.instruction_pointer == b.instruction_pointer &&
 301       a.module_index == b.module_index;
 302 }
 303
 304 bool operator<(const StackSamplingProfiler::Frame &a,
 305                const StackSamplingProfiler::Frame &b) {
 306   return (a.module_index < b.module_index) ||
 307       (a.module_index == b.module_index &&
 308        a.instruction_pointer < b.instruction_pointer);
 309 }
 310
 311 }  // namespace base