OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ | 5 #ifndef BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ |
6 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ | 6 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 | 9 |
10 #include <memory> | 10 #include <memory> |
11 #include <string> | 11 #include <string> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "base/atomicops.h" | 14 #include "base/atomicops.h" |
15 #include "base/base_export.h" | 15 #include "base/base_export.h" |
16 #include "base/callback.h" | 16 #include "base/callback.h" |
17 #include "base/files/file_path.h" | 17 #include "base/files/file_path.h" |
18 #include "base/macros.h" | 18 #include "base/macros.h" |
19 #include "base/strings/string16.h" | 19 #include "base/strings/string16.h" |
20 #include "base/synchronization/waitable_event.h" | 20 #include "base/synchronization/waitable_event.h" |
21 #include "base/threading/platform_thread.h" | 21 #include "base/threading/platform_thread.h" |
22 #include "base/time/time.h" | 22 #include "base/time/time.h" |
23 | 23 |
24 namespace base { | 24 namespace base { |
25 | 25 |
26 class NativeStackSampler; | 26 class NativeStackSampler; |
27 class NativeStackSamplerTestDelegate; | 27 class NativeStackSamplerTestDelegate; |
28 class WaitableEvent; | |
28 | 29 |
29 // StackSamplingProfiler periodically stops a thread to sample its stack, for | 30 // StackSamplingProfiler periodically stops a thread to sample its stack, for |
30 // the purpose of collecting information about which code paths are | 31 // the purpose of collecting information about which code paths are |
31 // executing. This information is used in aggregate by UMA to identify hot | 32 // executing. This information is used in aggregate by UMA to identify hot |
32 // and/or janky code paths. | 33 // and/or janky code paths. |
33 // | 34 // |
34 // Sample StackSamplingProfiler usage: | 35 // Sample StackSamplingProfiler usage: |
35 // | 36 // |
36 // // Create and customize params as desired. | 37 // // Create and customize params as desired. |
37 // base::StackStackSamplingProfiler::SamplingParams params; | 38 // base::StackStackSamplingProfiler::SamplingParams params; |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
176 // Number of samples to record per burst. Defaults to 300. | 177 // Number of samples to record per burst. Defaults to 300. |
177 int samples_per_burst; | 178 int samples_per_burst; |
178 | 179 |
179 // Interval between samples during a sampling burst. This is the desired | 180 // Interval between samples during a sampling burst. This is the desired |
180 // duration from the start of one sample to the start of the next | 181 // duration from the start of one sample to the start of the next |
181 // sample. Defaults to 100ms. | 182 // sample. Defaults to 100ms. |
182 TimeDelta sampling_interval; | 183 TimeDelta sampling_interval; |
183 }; | 184 }; |
184 | 185 |
185 // The callback type used to collect completed profiles. The passed |profiles| | 186 // The callback type used to collect completed profiles. The passed |profiles| |
186 // are move-only. | 187 // are move-only. This should run quickly as possible that another thread, |
Mike Wittman
2017/02/15 03:26:44
I'm having trouble parsing this. How about:
Other
bcwhite
2017/02/15 16:17:35
Done.
| |
188 // even the UI thread, to block awaiting its completion. | |
187 // | 189 // |
188 // IMPORTANT NOTE: the callback is invoked on a thread the profiler | 190 // IMPORTANT NOTE: The callback is invoked on a thread the profiler |
189 // constructs, rather than on the thread used to construct the profiler and | 191 // constructs, rather than on the thread used to construct the profiler and |
190 // set the callback, and thus the callback must be callable on any thread. For | 192 // set the callback, and thus the callback must be callable on any thread. For |
191 // threads with message loops that create StackSamplingProfilers, posting a | 193 // threads with message loops that create StackSamplingProfilers, posting a |
192 // task to the message loop with a copy of the profiles is the recommended | 194 // task to the message loop with the moved (i.e. std::move) profiles is the |
193 // thread-safe callback implementation. | 195 // thread-safe callback implementation. |
194 using CompletedCallback = Callback<void(CallStackProfiles)>; | 196 using CompletedCallback = Callback<void(CallStackProfiles)>; |
195 | 197 |
196 // Creates a profiler that sends completed profiles to |callback|. The second | 198 // Creates a profiler for the CURRENT thread that sends completed profiles |
197 // constructor is for test purposes. | 199 // to |callback|. An optional |test_delegate| can be supplied by tests. |
198 StackSamplingProfiler(PlatformThreadId thread_id, | 200 // Ensure that this object gets destroyed before the current thread exits. |
Mike Wittman
2017/02/15 03:26:44
nit: The caller must ensure ...
Comments with imp
bcwhite
2017/02/15 16:17:35
Done.
| |
199 const SamplingParams& params, | 201 StackSamplingProfiler( |
200 const CompletedCallback& callback); | 202 const SamplingParams& params, |
201 StackSamplingProfiler(PlatformThreadId thread_id, | 203 const CompletedCallback& callback, |
202 const SamplingParams& params, | 204 NativeStackSamplerTestDelegate* test_delegate = nullptr); |
203 const CompletedCallback& callback, | 205 |
204 NativeStackSamplerTestDelegate* test_delegate); | 206 // Creates a profiler for ANOTHER thread that sends completed profiles to |
207 // |callback|. An optional |test_delegate| can be supplied by tests. | |
208 // | |
209 // IMPORTANT: Ensure that the thread being sampled does not exit before this | |
Mike Wittman
2017/02/15 03:26:44
Same here.
bcwhite
2017/02/15 16:17:35
Done.
| |
210 // object gets destructed or Bad Things(tm) may occur. | |
211 StackSamplingProfiler( | |
212 PlatformThreadId thread_id, | |
213 const SamplingParams& params, | |
214 const CompletedCallback& callback, | |
215 NativeStackSamplerTestDelegate* test_delegate = nullptr); | |
216 | |
205 // Stops any profiling currently taking place before destroying the profiler. | 217 // Stops any profiling currently taking place before destroying the profiler. |
218 // This will block until the callback has been run. | |
206 ~StackSamplingProfiler(); | 219 ~StackSamplingProfiler(); |
207 | 220 |
208 // The fire-and-forget interface: starts a profiler and allows it to complete | |
209 // without the caller needing to manage the profiler lifetime. May be invoked | |
210 // from any thread, but requires that the calling thread has a message loop. | |
211 static void StartAndRunAsync(PlatformThreadId thread_id, | |
212 const SamplingParams& params, | |
213 const CompletedCallback& callback); | |
214 | |
215 // Initializes the profiler and starts sampling. | 221 // Initializes the profiler and starts sampling. |
216 void Start(); | 222 void Start(); |
217 | 223 |
218 // Stops the profiler and any ongoing sampling. Calling this function is | 224 // Stops the profiler and any ongoing sampling. This method will return |
219 // optional; if not invoked profiling terminates when all the profiling bursts | 225 // immediately with the callback being run asynchronously. At most one |
220 // specified in the SamplingParams are completed or the profiler is destroyed, | 226 // more stack sample will be taken after this method returns. Calling this |
221 // whichever occurs first. | 227 // function is optional; if not invoked profiling terminates when all the |
228 // profiling bursts specified in the SamplingParams are completed or the | |
229 // profiler object is destroyed, whichever occurs first. | |
222 void Stop(); | 230 void Stop(); |
223 | 231 |
232 // Returns whether the sampling thread is currently running or not. | |
233 static bool IsSamplingThreadRunningForTesting(); | |
Mike Wittman
2017/02/15 03:26:44
Can we move these three functions into an internal
bcwhite
2017/02/15 16:17:35
Done. Let me know if it's what you were thinking.
Mike Wittman
2017/02/15 21:56:00
Looks good. Can you add a TestAPI to SamplingThrea
bcwhite
2017/02/16 17:39:49
I didn't think it was necessary since that class i
Mike Wittman
2017/02/17 16:10:19
Segregating test support code all the way down mak
bcwhite
2017/02/21 16:21:19
Done.
| |
234 | |
235 // Sets the auto-shutdown delay time for the sampling thread, in ms. Set this | |
236 // to zero to disable it. | |
237 static void SetSamplingThreadIdleShutdownTimeForTesting(int shutdown_ms); | |
238 | |
239 // Initiates an idle shutdown task, as though the idle timer had expired, | |
240 // causing the thread to exit if there are no more sampling tasks pending. | |
241 // This returns immediately. Watch IsSamplingThreadRunningForTesting() to | |
242 // know when the thread has exited, though it will never do so if it is | |
243 // not idle. | |
244 static void InitiateSamplingThreadIdleShutdownForTesting(); | |
245 | |
224 // Set the current system state that is recorded with each captured stack | 246 // Set the current system state that is recorded with each captured stack |
225 // frame. This is thread-safe so can be called from anywhere. The parameter | 247 // frame. This is thread-safe so can be called from anywhere. The parameter |
226 // value should be from an enumeration of the appropriate type with values | 248 // value should be from an enumeration of the appropriate type with values |
227 // ranging from 0 to 31, inclusive. This sets bits within Sample field of | 249 // ranging from 0 to 31, inclusive. This sets bits within Sample field of |
228 // |process_milestones|. The actual meanings of these bits are defined | 250 // |process_milestones|. The actual meanings of these bits are defined |
229 // (globally) by the caller(s). | 251 // (globally) by the caller(s). |
230 static void SetProcessMilestone(int milestone); | 252 static void SetProcessMilestone(int milestone); |
231 static void ResetAnnotationsForTesting(); | 253 static void ResetAnnotationsForTesting(); |
232 | 254 |
233 private: | 255 private: |
234 // SamplingThread is a separate thread used to suspend and sample stacks from | 256 // SamplingThread is a separate thread used to suspend and sample stacks from |
235 // the target thread. | 257 // the target thread. |
236 class SamplingThread : public PlatformThread::Delegate { | 258 class SamplingThread; |
237 public: | |
238 // Samples stacks using |native_sampler|. When complete, invokes | |
239 // |completed_callback| with the collected call stack profiles. | |
240 // |completed_callback| must be callable on any thread. | |
241 SamplingThread(std::unique_ptr<NativeStackSampler> native_sampler, | |
242 const SamplingParams& params, | |
243 const CompletedCallback& completed_callback); | |
244 ~SamplingThread() override; | |
245 | |
246 // PlatformThread::Delegate: | |
247 void ThreadMain() override; | |
248 | |
249 void Stop(); | |
250 | |
251 private: | |
252 // Collects |profile| from a single burst. If the profiler was stopped | |
253 // during collection, sets |was_stopped| and provides the set of samples | |
254 // collected up to that point. | |
255 void CollectProfile(CallStackProfile* profile, TimeDelta* elapsed_time, | |
256 bool* was_stopped); | |
257 | |
258 // Collects call stack profiles from all bursts, or until the sampling is | |
259 // stopped. If stopped before complete, the last profile in | |
260 // |call_stack_profiles| may contain a partial burst. | |
261 void CollectProfiles(CallStackProfiles* profiles); | |
262 | |
263 std::unique_ptr<NativeStackSampler> native_sampler_; | |
264 const SamplingParams params_; | |
265 | |
266 // If Stop() is called, it signals this event to force the sampling to | |
267 // terminate before all the samples specified in |params_| are collected. | |
268 WaitableEvent stop_event_; | |
269 | |
270 const CompletedCallback completed_callback_; | |
271 | |
272 DISALLOW_COPY_AND_ASSIGN(SamplingThread); | |
273 }; | |
274 | 259 |
275 // Adds annotations to a Sample. | 260 // Adds annotations to a Sample. |
276 static void RecordAnnotations(Sample* sample); | 261 static void RecordAnnotations(Sample* sample); |
277 | 262 |
278 // This global variables holds the current system state and is recorded with | 263 // This global variables holds the current system state and is recorded with |
279 // every captured sample, done on a separate thread which is why updates to | 264 // every captured sample, done on a separate thread which is why updates to |
280 // this must be atomic. A PostTask to move the the updates to that thread | 265 // this must be atomic. A PostTask to move the the updates to that thread |
281 // would skew the timing and a lock could result in deadlock if the thread | 266 // would skew the timing and a lock could result in deadlock if the thread |
282 // making a change was also being profiled and got stopped. | 267 // making a change was also being profiled and got stopped. |
283 static subtle::Atomic32 process_milestones_; | 268 static subtle::Atomic32 process_milestones_; |
284 | 269 |
285 // The thread whose stack will be sampled. | 270 // The thread whose stack will be sampled. |
286 PlatformThreadId thread_id_; | 271 PlatformThreadId thread_id_; |
287 | 272 |
288 const SamplingParams params_; | 273 const SamplingParams params_; |
289 | 274 |
290 std::unique_ptr<SamplingThread> sampling_thread_; | 275 const CompletedCallback completed_callback_; |
291 PlatformThreadHandle sampling_thread_handle_; | |
292 | 276 |
293 const CompletedCallback completed_callback_; | 277 // An event signaled when all sampling is complete and the callback done. |
278 WaitableEvent finished_event_; | |
279 | |
280 // Object that does the native sampling. This is created during construction | |
281 // and later passed to the sampling thread when profiling is started. | |
282 std::unique_ptr<NativeStackSampler> native_sampler_; | |
283 | |
284 // An ID uniquely identifying this collection to the sampling thread. | |
285 int collection_id_ = -1; | |
294 | 286 |
295 // Stored until it can be passed to the NativeStackSampler created in Start(). | 287 // Stored until it can be passed to the NativeStackSampler created in Start(). |
296 NativeStackSamplerTestDelegate* const test_delegate_; | 288 NativeStackSamplerTestDelegate* const test_delegate_; |
297 | 289 |
298 DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler); | 290 DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler); |
299 }; | 291 }; |
300 | 292 |
301 // These operators permit types to be compared and used in a map of Samples, as | 293 // These operators permit types to be compared and used in a map of Samples, as |
302 // done in tests and by the metrics provider code. | 294 // done in tests and by the metrics provider code. |
303 BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a, | 295 BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a, |
304 const StackSamplingProfiler::Module& b); | 296 const StackSamplingProfiler::Module& b); |
305 BASE_EXPORT bool operator==(const StackSamplingProfiler::Sample& a, | 297 BASE_EXPORT bool operator==(const StackSamplingProfiler::Sample& a, |
306 const StackSamplingProfiler::Sample& b); | 298 const StackSamplingProfiler::Sample& b); |
307 BASE_EXPORT bool operator!=(const StackSamplingProfiler::Sample& a, | 299 BASE_EXPORT bool operator!=(const StackSamplingProfiler::Sample& a, |
308 const StackSamplingProfiler::Sample& b); | 300 const StackSamplingProfiler::Sample& b); |
309 BASE_EXPORT bool operator<(const StackSamplingProfiler::Sample& a, | 301 BASE_EXPORT bool operator<(const StackSamplingProfiler::Sample& a, |
310 const StackSamplingProfiler::Sample& b); | 302 const StackSamplingProfiler::Sample& b); |
311 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a, | 303 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a, |
312 const StackSamplingProfiler::Frame& b); | 304 const StackSamplingProfiler::Frame& b); |
313 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a, | 305 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a, |
314 const StackSamplingProfiler::Frame& b); | 306 const StackSamplingProfiler::Frame& b); |
315 | 307 |
316 } // namespace base | 308 } // namespace base |
317 | 309 |
318 #endif // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ | 310 #endif // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_ |
OLD | NEW |