OLD | NEW |
(Empty) | |
| 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 |
| 69 StackSamplingProfiler::Module::~Module() {} |
| 70 |
| 71 StackSamplingProfiler::Frame::Frame() |
| 72 : instruction_pointer(nullptr), |
| 73 module_index(-1) {} |
| 74 |
| 75 StackSamplingProfiler::Frame::~Frame() {} |
| 76 |
| 77 StackSamplingProfiler::Profile::Profile() : preserve_sample_ordering(false) {} |
| 78 |
| 79 StackSamplingProfiler::Profile::~Profile() {} |
| 80 |
| 81 class StackSamplingProfiler::SamplingThread : public PlatformThread::Delegate { |
| 82 public: |
| 83 // Samples stacks using |native_sampler|. When complete, invokes |
| 84 // |profiles_callback| with the collected profiles. |profiles_callback| must |
| 85 // be thread-safe and may consume the contents of the vector. |
| 86 SamplingThread( |
| 87 scoped_ptr<NativeStackSampler> native_sampler, |
| 88 const SamplingParams& params, |
| 89 Callback<void(const std::vector<Profile>&)> completed_callback); |
| 90 ~SamplingThread() override; |
| 91 |
| 92 // Implementation of PlatformThread::Delegate: |
| 93 void ThreadMain() override; |
| 94 |
| 95 void Stop(); |
| 96 |
| 97 private: |
| 98 // Collects a profile from a single burst. Returns true if the profile was |
| 99 // collected, or false if collection was stopped before it completed. |
| 100 bool CollectProfile(Profile* profile, TimeDelta* elapsed_time); |
| 101 // Collects profiles from all bursts, or until the sampling is stopped. If |
| 102 // stopped before complete, |profiles| will contains only full bursts. |
| 103 void CollectProfiles(std::vector<Profile>* profiles); |
| 104 |
| 105 scoped_ptr<NativeStackSampler> native_sampler_; |
| 106 |
| 107 const SamplingParams params_; |
| 108 |
| 109 WaitableEvent stop_event_; |
| 110 |
| 111 Callback<void(const std::vector<Profile>&)> completed_callback_; |
| 112 |
| 113 DISALLOW_COPY_AND_ASSIGN(SamplingThread); |
| 114 }; |
| 115 |
| 116 StackSamplingProfiler::SamplingThread::SamplingThread( |
| 117 scoped_ptr<NativeStackSampler> native_sampler, |
| 118 const SamplingParams& params, |
| 119 Callback<void(const std::vector<Profile>&)> completed_callback) |
| 120 : native_sampler_(native_sampler.Pass()), |
| 121 params_(params), |
| 122 stop_event_(false, false), |
| 123 completed_callback_(completed_callback) { |
| 124 } |
| 125 |
| 126 StackSamplingProfiler::SamplingThread::~SamplingThread() {} |
| 127 |
| 128 void StackSamplingProfiler::SamplingThread::ThreadMain() { |
| 129 PlatformThread::SetName("Chrome_SamplingProfilerThread"); |
| 130 |
| 131 std::vector<Profile> profiles; |
| 132 CollectProfiles(&profiles); |
| 133 completed_callback_.Run(profiles); |
| 134 } |
| 135 |
| 136 bool StackSamplingProfiler::SamplingThread::CollectProfile( |
| 137 Profile* profile, |
| 138 TimeDelta* elapsed_time) { |
| 139 ElapsedTimer profile_timer; |
| 140 Profile current_profile; |
| 141 native_sampler_->ProfileRecordingStarting(¤t_profile); |
| 142 current_profile.sampling_period = params_.sampling_interval; |
| 143 bool stopped_early = false; |
| 144 for (int i = 0; i < params_.samples_per_burst; ++i) { |
| 145 ElapsedTimer sample_timer; |
| 146 current_profile.samples.push_back(Sample()); |
| 147 native_sampler_->RecordStackSample(¤t_profile.samples.back()); |
| 148 TimeDelta elapsed_sample_time = sample_timer.Elapsed(); |
| 149 if (i != params_.samples_per_burst - 1) { |
| 150 if (stop_event_.TimedWait( |
| 151 std::max(params_.sampling_interval - elapsed_sample_time, |
| 152 TimeDelta()))) { |
| 153 stopped_early = true; |
| 154 break; |
| 155 } |
| 156 } |
| 157 } |
| 158 |
| 159 *elapsed_time = profile_timer.Elapsed(); |
| 160 current_profile.profile_duration = *elapsed_time; |
| 161 native_sampler_->ProfileRecordingStopped(); |
| 162 |
| 163 if (!stopped_early) |
| 164 *profile = current_profile; |
| 165 |
| 166 return !stopped_early; |
| 167 } |
| 168 |
| 169 void StackSamplingProfiler::SamplingThread::CollectProfiles( |
| 170 std::vector<Profile>* profiles) { |
| 171 if (stop_event_.TimedWait(params_.initial_delay)) |
| 172 return; |
| 173 |
| 174 for (int i = 0; i < params_.bursts; ++i) { |
| 175 Profile profile; |
| 176 TimeDelta elapsed_profile_time; |
| 177 if (CollectProfile(&profile, &elapsed_profile_time)) |
| 178 profiles->push_back(profile); |
| 179 else |
| 180 return; |
| 181 |
| 182 if (stop_event_.TimedWait( |
| 183 std::max(params_.burst_interval - elapsed_profile_time, |
| 184 TimeDelta()))) |
| 185 return; |
| 186 } |
| 187 } |
| 188 |
| 189 void StackSamplingProfiler::SamplingThread::Stop() { |
| 190 stop_event_.Signal(); |
| 191 } |
| 192 |
| 193 void StackSamplingProfiler::SamplingThreadDeleter::operator()( |
| 194 SamplingThread* thread) const { |
| 195 delete thread; |
| 196 } |
| 197 |
| 198 StackSamplingProfiler::NativeStackSampler::NativeStackSampler() {} |
| 199 |
| 200 StackSamplingProfiler::NativeStackSampler::~NativeStackSampler() {} |
| 201 |
| 202 StackSamplingProfiler::SamplingParams::SamplingParams() |
| 203 : initial_delay(TimeDelta::FromMilliseconds(0)), |
| 204 bursts(1), |
| 205 burst_interval(TimeDelta::FromMilliseconds(10000)), |
| 206 samples_per_burst(300), |
| 207 sampling_interval(TimeDelta::FromMilliseconds(100)), |
| 208 preserve_sample_ordering(false) { |
| 209 } |
| 210 |
| 211 StackSamplingProfiler::StackSamplingProfiler(PlatformThreadId thread_id, |
| 212 const SamplingParams& params) |
| 213 : thread_id_(thread_id), params_(params) {} |
| 214 |
| 215 StackSamplingProfiler::~StackSamplingProfiler() {} |
| 216 |
| 217 void StackSamplingProfiler::Start() { |
| 218 native_sampler_ = NativeStackSampler::Create(thread_id_); |
| 219 if (!native_sampler_) |
| 220 return; |
| 221 |
| 222 sampling_thread_.reset( |
| 223 new SamplingThread( |
| 224 native_sampler_.Pass(), params_, |
| 225 (custom_completed_callback_.is_null() ? |
| 226 Bind(&PendingProfiles::PutProfiles, |
| 227 Unretained(PendingProfiles::GetInstance())) : |
| 228 custom_completed_callback_))); |
| 229 if (!PlatformThread::CreateNonJoinable(0, sampling_thread_.get())) |
| 230 LOG(ERROR) << "failed to create thread"; |
| 231 } |
| 232 |
| 233 void StackSamplingProfiler::Stop() { |
| 234 if (sampling_thread_) |
| 235 sampling_thread_->Stop(); |
| 236 } |
| 237 |
| 238 // static |
| 239 void StackSamplingProfiler::GetPendingProfiles(std::vector<Profile>* profiles) { |
| 240 PendingProfiles::GetInstance()->GetProfiles(profiles); |
| 241 } |
| 242 |
| 243 void StackSamplingProfiler::SetCustomCompletedCallback( |
| 244 Callback<void(const std::vector<Profile>&)> callback) { |
| 245 custom_completed_callback_ = callback; |
| 246 } |
| 247 |
| 248 bool operator==(const StackSamplingProfiler::Frame &a, |
| 249 const StackSamplingProfiler::Frame &b) { |
| 250 return a.instruction_pointer == b.instruction_pointer && |
| 251 a.module_index == b.module_index; |
| 252 } |
| 253 |
| 254 bool operator<(const StackSamplingProfiler::Frame &a, |
| 255 const StackSamplingProfiler::Frame &b) { |
| 256 return (a.module_index < b.module_index) || |
| 257 (a.module_index == b.module_index && |
| 258 a.instruction_pointer < b.instruction_pointer); |
| 259 } |
| 260 |
| 261 } // namespace base |
OLD | NEW |