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 33 matching lines @@
 // completed callback is called from a thread created by the profiler with the
 // collected profiles.
 //
 // The results of the profiling are passed to the completed callback and consist
 // of a vector of CallStackProfiles. Each CallStackProfile corresponds to a
 // burst as specified in SamplingParams and contains a set of Samples and
 // Modules. One Sample corresponds to a single recorded stack, and the Modules
 // record those modules associated with the recorded stack frames.
 class BASE_EXPORT StackSamplingProfiler {
  public:
+  enum ProcessPhase : int {
+    // TODO: Expand this.
+    FirstNonEmptyPaint,
+  };
+
+  enum ProcessActivity : int {
+    // TODO: Expand this, too.
+  };
+
   // Module represents the module (DLL or exe) corresponding to a stack frame.
   struct BASE_EXPORT Module {
     Module();
     Module(uintptr_t base_address,
            const std::string& id,
            const FilePath& filename);
     ~Module();
 
     // Points to the base address of the module.
     uintptr_t base_address;
@@ skipping 23 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);
+
+    // These constructors are used 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.
+    int32_t process_phases = 0;
+
+    // A bit-field indicating activities which were active when the frame was
+    // captured. See ProcessActivity, above.
+    int32_t current_activities = 0;
+  };
 
   // CallStackProfile represents a set of samples.
   struct BASE_EXPORT CallStackProfile {
     CallStackProfile();
     CallStackProfile(const CallStackProfile& other);
     ~CallStackProfile();
 
     std::vector<Module> modules;
     std::vector<Sample> samples;
 
@@ skipping 60 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.
+  static void SetProcessPhase(ProcessPhase phase);
+  static void RecordActivityBegin(ProcessActivity activity);
+  static void RecordActivityEnd(ProcessActivity activity);
+
  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);
   };
 
+  // These global variables hold current system state. These values are
+  // recorded with every captured frame.
+  static subtle::Atomic32 process_phases_;
+  static subtle::Atomic32 current_activities_;

[Alexei Svitkine (slow), 2016/10/25 14:49:08]

Do we need to use atomics here?

Can't we just always do modifications to these on the main thread?

[bcwhite, 2016/10/25 15:02:22]

I don't know if we can guarantee that or not but it wouldn't matter since they
must also be read by the sampling thread to be stored alongside the collected
stack frames.

[Alexei Svitkine (slow), 2016/10/25 15:25:58]

In terms of guarantee, I was thinking the code can just do a post task if it's
not on the right thread currently.

If these need to be read on the sampling thread, can we just do a post task to
the sampling thread and always update them there?

I guess the downside of the post task approach is that they may arrive late - so
maybe having these atomic is better. OK, I'm compelled with having them atomic
given the above - but please expand comment above them to mention both the fact
that they're needed on sampling thread and that the alternative of using
posttask has the risk of the updates arriving late which would make the data not
accurate.

[bcwhite, 2016/10/25 16:22:26]

Done.

[Mike Wittman, 2016/10/25 17:24:22]

It's also worth mentioning that these have to be atomics rather than guarded by
a lock, to avoid deadlock during stack collection.

[bcwhite, 2016/10/25 21:10:42]

Done.

+
   // 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_