Add process lifetime annotations to stack samples.

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 {
@@ skipping 76 matching lines @@
     Frame();
 
     // The sampled instruction pointer within the function.
     uintptr_t instruction_pointer;
 
     // Index of the module in CallStackProfile::modules. We don't represent
     // module state directly here to save space.
     size_t module_index;
   };
 
-  // Sample represents a set of stack frames.
-  using Sample = std::vector<Frame>;
+  // Sample represents a set of stack frames with some extra information.
+  struct BASE_EXPORT Sample {
+    Sample();
+    Sample(const Sample& sample);
+    ~Sample();
+
+    // These constructors are used only during testing.
+    Sample(const Frame& frame);
+    Sample(const std::vector<Frame>& frames);
+
+    // The entire stack frame when the sample is taken.
+    std::vector<Frame> frames;
+
+    // A bit-field indicating which process phases have passed. This can be
+    // used to tell where in the process lifetime the samples are taken. See
+    // ProcessPhase, above.
+    uint32_t process_phases = 0;
+
+    // A bit-field indicating activities which were active when the frame was
+    // captured. See ProcessActivity, above.
+    uint32_t current_activities = 0;
+  };
 
   // CallStackProfile represents a set of samples.
   struct BASE_EXPORT CallStackProfile {
     CallStackProfile();
     CallStackProfile(CallStackProfile&& other);
     ~CallStackProfile();
 
     CallStackProfile& operator=(CallStackProfile&& other);
 
     CallStackProfile CopyForTesting() const;
@@ skipping 72 matching lines @@
 
   // 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();
 
+  // Set the current system state that is recorded with each captured stack
+  // frame. These are all thread-safe so can be called from anywhere. The
+  // parameter values should be from an enumeration of the appropriate type

[Mike Wittman, 2016/11/02 21:44:04]

We should also specify that these functions set/clear the corresponding bits in
the Sample fields, and that the meaning of the bits is user-defined.

[bcwhite, 2016/11/03 18:29:50]

Done.

+  // with values ranging from 0 to 31, inclusive.
+  static void SetProcessPhase(int phase);
+  static void RecordActivityBegin(int activity);
+  static void RecordActivityEnd(int activity);
+  static void ResetPhaseAndActivityForTesting();
+
  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,
@@ skipping 22 matching lines @@
 
     // 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);
   };
 
+  // Adds "phases" and "activities" annotations to a Sample.
+  static void RecordAnnotations(Sample* sample);
+
+  // These global variables hold current system state. These values are
+  // recorded with every captured sample, done on a separate thread which is
+  // why updates to these 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_phases_;
+  static subtle::Atomic32 current_activities_;
+
   // 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_;
 
   // 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_