Add process lifetime annotations to stack samples.

base/profiler/stack_sampling_profiler.cc

 // 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.
 
 #include "base/profiler/stack_sampling_profiler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 63 matching lines @@
 void AsyncRunner::RunCallbackAndDeleteInstance(
     std::unique_ptr<AsyncRunner> object_to_be_deleted,
     const StackSamplingProfiler::CompletedCallback& callback,
     scoped_refptr<SingleThreadTaskRunner> task_runner,
     const StackSamplingProfiler::CallStackProfiles& profiles) {
   callback.Run(profiles);
   // Delete the instance on the original calling thread.
   task_runner->DeleteSoon(FROM_HERE, object_to_be_deleted.release());
 }
 
+void ChangeAtomicFlags(volatile subtle::Atomic32* flags,

[Mike Wittman, 2016/10/24 22:28:14]

Same comment about volatile.

[bcwhite, 2016/10/25 14:45:23]

Done.

+                       subtle::Atomic32 set,
+                       subtle::Atomic32 clear) {
+  DCHECK(set != 0 || clear != 0);
+  DCHECK_EQ(0, set & clear);
+
+  subtle::Atomic32 bits = subtle::NoBarrier_Load(flags);
+  while (true) {
+    subtle::Atomic32 existing =
+        subtle::NoBarrier_CompareAndSwap(flags, bits, (bits | set) & ~clear);
+    if (existing == bits)
+      break;
+    bits = existing;
+  }
+}
+
 }  // namespace
 
 // StackSamplingProfiler::Module ----------------------------------------------
 
 StackSamplingProfiler::Module::Module() : base_address(0u) {}
 StackSamplingProfiler::Module::Module(uintptr_t base_address,
                                       const std::string& id,
                                       const FilePath& filename)
     : base_address(base_address), id(id), filename(filename) {}
 
@@ skipping 70 matching lines @@
       // stop_event_.
       if (stop_event_.TimedWait(
               std::max(params_.sampling_interval - previous_elapsed_sample_time,
                        TimeDelta()))) {
         *was_stopped = true;
         break;
       }
     }
     ElapsedTimer sample_timer;
     profile->samples.push_back(Sample());
-    native_sampler_->RecordStackSample(&profile->samples.back());
+    Sample& sample = profile->samples.back();
+    sample.process_phases = subtle::NoBarrier_Load(&process_phases_);
+    sample.current_activities = subtle::NoBarrier_Load(&current_activities_);

[Mike Wittman, 2016/10/24 22:28:14]

The SuspendThread call in the native stack sampler implementation is reportedly
fairly expensive, so to maximize accuracy it's probably worth saving the state
off after that occurs.

[bcwhite, 2016/10/25 14:45:23]

Done.

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

Sorry for not being specific: I was intending to suggest that this should happen
within SuspendThreadAndRecordStack within ScopedSuspendThread. There's a fair
amount of work being done both before and after that point, so this would place
the recording of the state as close as possible to the actual stack capture.

We could probably pass a bare function pointer callback so that the native stack
sampler doesn't have to know about the details of obtaining the state.

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

Done.  Ya know...  Callbacks only _look_ simple...  :-)

[Mike Wittman, 2016/10/26 16:28:17]

Thanks. But it gets even more complicated. :) (See next comment.)

+    native_sampler_->RecordStackSample(&sample);
     previous_elapsed_sample_time = sample_timer.Elapsed();
   }
 
   *elapsed_time = profile_timer.Elapsed();
   profile->profile_duration = *elapsed_time;
   native_sampler_->ProfileRecordingStopped();
 }
 
 // In an analogous manner to CollectProfile() and samples exceeding the expected
 // total sampling time, bursts may also exceed the burst_interval. We adopt the
@@ skipping 22 matching lines @@
 
     if (was_stopped)
       return;
   }
 }
 
 void StackSamplingProfiler::SamplingThread::Stop() {
   stop_event_.Signal();
 }
 
+// static
+void StackSamplingProfiler::SetProcessPhase(ProcessPhase phase) {
+  DCHECK_EQ(0, subtle::NoBarrier_Load(&process_phases_) & (1 << phase));
+  ChangeAtomicFlags(&process_phases_, 1 << phase, 0);
+}
+
+// static
+void StackSamplingProfiler::RecordActivityBegin(ProcessActivity activity) {
+  ChangeAtomicFlags(&current_activities_, 1 << activity, 0);
+}
+
+// static
+void StackSamplingProfiler::RecordActivityEnd(ProcessActivity activity) {
+  ChangeAtomicFlags(&current_activities_, 0, 1 << activity);
+}
+
 // StackSamplingProfiler ------------------------------------------------------
 
+volatile subtle::Atomic32 StackSamplingProfiler::process_phases_ = 0;
+volatile subtle::Atomic32 StackSamplingProfiler::current_activities_ = 0;
+
 StackSamplingProfiler::SamplingParams::SamplingParams()
     : initial_delay(TimeDelta::FromMilliseconds(0)),
       bursts(1),
       burst_interval(TimeDelta::FromMilliseconds(10000)),
       samples_per_burst(300),
       sampling_interval(TimeDelta::FromMilliseconds(100)) {
 }
 
 StackSamplingProfiler::StackSamplingProfiler(
     PlatformThreadId thread_id,
@@ skipping 47 matching lines @@
 }
 
 // StackSamplingProfiler::Frame global functions ------------------------------
 
 bool operator==(const StackSamplingProfiler::Module& a,
                 const StackSamplingProfiler::Module& b) {
   return a.base_address == b.base_address && a.id == b.id &&
       a.filename == b.filename;
 }
 
+bool operator==(const StackSamplingProfiler::Sample& a,
+                const StackSamplingProfiler::Sample& b) {
+  return a.process_phases == b.process_phases &&
+         a.current_activities == b.current_activities && a.frames == b.frames;
+}
+
+bool operator!=(const StackSamplingProfiler::Sample& a,
+                const StackSamplingProfiler::Sample& b) {
+  return !(a == b);
+}
+
+bool operator<(const StackSamplingProfiler::Sample& a,
+               const StackSamplingProfiler::Sample& b) {
+  if (a.process_phases < b.process_phases)
+    return true;
+  if (a.process_phases > b.process_phases)
+    return false;
+
+  if (a.current_activities < b.current_activities)
+    return true;
+  if (a.current_activities > b.current_activities)
+    return false;
+
+  return a.frames < b.frames;
+}
+
 bool operator==(const StackSamplingProfiler::Frame &a,
                 const StackSamplingProfiler::Frame &b) {
   return a.instruction_pointer == b.instruction_pointer &&
       a.module_index == b.module_index;
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base