Support parallel captures from the StackSamplingProfiler.

base/profiler/stack_sampling_profiler.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class NativeStackSampler;
 class NativeStackSamplerTestDelegate;
+class WaitableEvent;
 
 // StackSamplingProfiler periodically stops a thread to sample its stack, for
 // the purpose of collecting information about which code paths are
 // executing. This information is used in aggregate by UMA to identify hot
 // and/or janky code paths.
 //
+// IMPORTANT: Only threads guaranteed to live beyond the lifetime of the
+// profiler object can be safely sampled. Sampling the activity of the current
+// thread within the scope of this object is safe, but sampling any other
+// thread could cause Bad Things(tm) to occur should that thread exit before
+// sampling is complete; ensure the profiler object gets destructed before
+// exit of the thread under test. USE WITH CAUTION!
+//

[Mike Wittman, 2017/02/13 22:35:57]

If we refactor the constructors to:

  StackSamplingProfiler(const SamplingParams& params,
                        const CompletedCallback& callback,
                        NativeStackSamplerTestDelegate* test_delegate =
nullptr);

for the A-samples-A case, and

  StackSamplingProfiler(PlatformThreadId thread_id,
                        const SamplingParams& params,
                        const CompletedCallback& callback,
                        NativeStackSamplerTestDelegate* test_delegate =
nullptr);

for the A-samples-B case, then this comment can go directly on the second
constructor where it's more likely to be noticed.

[bcwhite, 2017/02/14 14:33:02]

I like it.  Done.

 // Sample StackSamplingProfiler usage:
 //
 //   // Create and customize params as desired.
 //   base::StackStackSamplingProfiler::SamplingParams params;
 //   // Any thread's ID may be passed as the target.
 //   base::StackSamplingProfiler profiler(base::PlatformThread::CurrentId()),
 //       params);
 //
 //   // Or, to process the profiles within Chrome rather than via UMA, use a
 //   // custom completed callback:
@@ skipping 154 matching lines @@
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback);
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback,
                         NativeStackSamplerTestDelegate* test_delegate);
   // Stops any profiling currently taking place before destroying the profiler.
   ~StackSamplingProfiler();
 
-  // The fire-and-forget interface: starts a profiler and allows it to complete
-  // without the caller needing to manage the profiler lifetime. May be invoked
-  // from any thread, but requires that the calling thread has a message loop.
-  static void StartAndRunAsync(PlatformThreadId thread_id,
-                               const SamplingParams& params,
-                               const CompletedCallback& callback);
-
   // Initializes the profiler and starts sampling.
   void Start();
 
   // Stops the profiler and any ongoing sampling. Calling this function is
   // optional; if not invoked profiling terminates when all the profiling bursts
   // specified in the SamplingParams are completed or the profiler is destroyed,
   // whichever occurs first.
   void Stop();
 
+  // Stops all active profiles and cleans up any resources in anticipation of
+  // a shutdown of the current process.
+  static void Shutdown();
+
+  // Resets the "shutdown" state so that the sampling thread can be restarted.
+  static void UndoShutdownForTesting();
+
+  // Returns whether the sampling thread is currently running or not.
+  static bool IsSamplingThreadRunningForTesting();
+
+  // Sets the auto-shutdown delay time for the sampling thread, in ms. Set this
+  // to zero to disable it.
+  static void SetSamplingThreadIdleShutdownTimeForTesting(int shutdown_ms);
+
+  // Initiates an idle shutdown task, as though the idle timer had expired,
+  // causing the thread to exit if there are no more sampling tasks pending.
+  // This returns immediately. Watch IsSamplingThreadRunningForTesting() to
+  // know when the thread has exited, though it will never do so if it is
+  // not idle.
+  static void InitiateSamplingThreadIdleShutdownForTesting();
+
   // Set the current system state that is recorded with each captured stack
   // frame. This is thread-safe so can be called from anywhere. The parameter
   // value should be from an enumeration of the appropriate type with values
   // ranging from 0 to 31, inclusive. This sets bits within Sample field of
   // |process_milestones|. The actual meanings of these bits are defined
   // (globally) by the caller(s).
   static void SetProcessMilestone(int milestone);
   static void ResetAnnotationsForTesting();
 
  private:
   // SamplingThread is a separate thread used to suspend and sample stacks from
   // the target thread.
-  class SamplingThread : public PlatformThread::Delegate {
-   public:
-    // Samples stacks using |native_sampler|. When complete, invokes
-    // |completed_callback| with the collected call stack profiles.
-    // |completed_callback| must be callable on any thread.
-    SamplingThread(std::unique_ptr<NativeStackSampler> native_sampler,
-                   const SamplingParams& params,
-                   const CompletedCallback& completed_callback);
-    ~SamplingThread() override;
-
-    // PlatformThread::Delegate:
-    void ThreadMain() override;
-
-    void Stop();
-
-   private:
-    // Collects |profile| from a single burst. If the profiler was stopped
-    // during collection, sets |was_stopped| and provides the set of samples
-    // collected up to that point.
-    void CollectProfile(CallStackProfile* profile, TimeDelta* elapsed_time,
-                        bool* was_stopped);
-
-    // Collects call stack profiles from all bursts, or until the sampling is
-    // stopped. If stopped before complete, the last profile in
-    // |call_stack_profiles| may contain a partial burst.
-    void CollectProfiles(CallStackProfiles* profiles);
-
-    std::unique_ptr<NativeStackSampler> native_sampler_;
-    const SamplingParams params_;
-
-    // If Stop() is called, it signals this event to force the sampling to
-    // terminate before all the samples specified in |params_| are collected.
-    WaitableEvent stop_event_;
-
-    const CompletedCallback completed_callback_;
-
-    DISALLOW_COPY_AND_ASSIGN(SamplingThread);
-  };
+  class SamplingThread;
 
   // Adds annotations to a Sample.
   static void RecordAnnotations(Sample* sample);
 
   // This global variables holds the current system state and is recorded with
   // every captured sample, done on a separate thread which is why updates to
   // this must be atomic. A PostTask to move the the updates to that thread
   // would skew the timing and a lock could result in deadlock if the thread
   // making a change was also being profiled and got stopped.
   static subtle::Atomic32 process_milestones_;
 
   // The thread whose stack will be sampled.
   PlatformThreadId thread_id_;
 
   const SamplingParams params_;
 
-  std::unique_ptr<SamplingThread> sampling_thread_;
-  PlatformThreadHandle sampling_thread_handle_;
+  const CompletedCallback completed_callback_;
 
-  const CompletedCallback completed_callback_;
+  // An event signaled when all sampling is complete and the callback done.
+  WaitableEvent finished_event_;
+
+  // Object that does the native sampling. This is created during construction
+  // and later passed to the sampling thread when profiling is started.
+  std::unique_ptr<NativeStackSampler> native_sampler_;
+
+  // An ID uniquely identifying this collection to the sampling thread.
+  int collection_id_ = -1;
 
   // Stored until it can be passed to the NativeStackSampler created in Start().
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler);
 };
 
 // These operators permit types to be compared and used in a map of Samples, as
 // done in tests and by the metrics provider code.
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a,
                             const StackSamplingProfiler::Module& b);
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Sample& a,
                             const StackSamplingProfiler::Sample& b);
 BASE_EXPORT bool operator!=(const StackSamplingProfiler::Sample& a,
                             const StackSamplingProfiler::Sample& b);
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Sample& a,
                            const StackSamplingProfiler::Sample& b);
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a,
                             const StackSamplingProfiler::Frame& b);
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a,
                            const StackSamplingProfiler::Frame& b);
 
 }  // namespace base
 
 #endif  // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_