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(subtle::Atomic32* flags,
+                       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) {}
 
 StackSamplingProfiler::Module::~Module() {}
 
 // StackSamplingProfiler::Frame -----------------------------------------------
 
 StackSamplingProfiler::Frame::Frame(uintptr_t instruction_pointer,
                                     size_t module_index)
     : instruction_pointer(instruction_pointer), module_index(module_index) {}
 
 StackSamplingProfiler::Frame::~Frame() {}
 
 StackSamplingProfiler::Frame::Frame()
     : instruction_pointer(0), module_index(kUnknownModuleIndex) {
 }
 
+// StackSamplingProfiler::Sample ----------------------------------------------
+
+StackSamplingProfiler::Sample::Sample() {}
+
+StackSamplingProfiler::Sample::Sample(const Sample& sample) = default;
+
+StackSamplingProfiler::Sample::~Sample() {}
+
+StackSamplingProfiler::Sample::Sample(const Frame& frame) {
+  frames.push_back(std::move(frame));
+}
+
+StackSamplingProfiler::Sample::Sample(const std::vector<Frame>& frames)
+    : frames(frames) {}
+
 // StackSamplingProfiler::CallStackProfile ------------------------------------
 
 StackSamplingProfiler::CallStackProfile::CallStackProfile() {}
 
 StackSamplingProfiler::CallStackProfile::CallStackProfile(
     const CallStackProfile& other) = default;
 
 StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
 
 // StackSamplingProfiler::SamplingThread --------------------------------------
@@ skipping 46 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();
+    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 24 matching lines @@
       return;
   }
 }
 
 void StackSamplingProfiler::SamplingThread::Stop() {
   stop_event_.Signal();
 }
 
 // StackSamplingProfiler ------------------------------------------------------
 
+subtle::Atomic32 StackSamplingProfiler::process_phases_ = 0;
+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 23 matching lines @@
     const CompletedCallback& callback) {
   CHECK(ThreadTaskRunnerHandle::Get());
   AsyncRunner::Run(thread_id, params, callback);
 }
 
 void StackSamplingProfiler::Start() {
   if (completed_callback_.is_null())
     return;
 
   std::unique_ptr<NativeStackSampler> native_sampler =
-      NativeStackSampler::Create(thread_id_, test_delegate_);
+      NativeStackSampler::Create(thread_id_, Bind(&RecordAnnotations),
+                                 test_delegate_);
   if (!native_sampler)
     return;
 
   sampling_thread_.reset(new SamplingThread(std::move(native_sampler), params_,
                                             completed_callback_));
   if (!PlatformThread::Create(0, sampling_thread_.get(),
                               &sampling_thread_handle_))
     sampling_thread_.reset();
 }
 
 void StackSamplingProfiler::Stop() {
   if (sampling_thread_)
     sampling_thread_->Stop();
 }
 
+// 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);
+}
+
+// static
+void StackSamplingProfiler::RecordAnnotations(Sample* sample) {
+  sample->process_phases = subtle::NoBarrier_Load(&process_phases_);
+  sample->current_activities = subtle::NoBarrier_Load(&current_activities_);
+}
+
 // 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