StackSamplingProfiler: collect partial bursts if the profiler is stopped early

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 123 matching lines @@
   completed_callback_.Run(profiles);
 }
 
 // Depending on how long the sampling takes and the length of the sampling
 // interval, a burst of samples could take arbitrarily longer than
 // samples_per_burst * sampling_interval. In this case, we (somewhat
 // arbitrarily) honor the number of samples requested rather than strictly
 // adhering to the sampling intervals. Once we have established users for the
 // StackSamplingProfiler and the collected data to judge, we may go the other
 // way or make this behavior configurable.
-bool StackSamplingProfiler::SamplingThread::CollectProfile(
+void StackSamplingProfiler::SamplingThread::CollectProfile(
     CallStackProfile* profile,
-    TimeDelta* elapsed_time) {
+    TimeDelta* elapsed_time,
+    bool* was_stopped) {
   ElapsedTimer profile_timer;
-  CallStackProfile current_profile;
-  native_sampler_->ProfileRecordingStarting(&current_profile.modules);
-  current_profile.sampling_period = params_.sampling_interval;
-  bool burst_completed = true;
+  native_sampler_->ProfileRecordingStarting(&profile->modules);
+  profile->sampling_period = params_.sampling_interval;
+  *was_stopped = false;
   TimeDelta previous_elapsed_sample_time;
   for (int i = 0; i < params_.samples_per_burst; ++i) {
     if (i != 0) {
       // Always wait, even if for 0 seconds, so we can observe a signal on
       // stop_event_.
       if (stop_event_.TimedWait(
               std::max(params_.sampling_interval - previous_elapsed_sample_time,
                        TimeDelta()))) {
-        burst_completed = false;
+        *was_stopped = true;
         break;
       }
     }
     ElapsedTimer sample_timer;
-    current_profile.samples.push_back(Sample());
-    native_sampler_->RecordStackSample(&current_profile.samples.back());
+    profile->samples.push_back(Sample());
+    native_sampler_->RecordStackSample(&profile->samples.back());
     previous_elapsed_sample_time = sample_timer.Elapsed();
   }
 
   *elapsed_time = profile_timer.Elapsed();
-  current_profile.profile_duration = *elapsed_time;
+  profile->profile_duration = *elapsed_time;
   native_sampler_->ProfileRecordingStopped();
-
-  if (burst_completed)
-    *profile = current_profile;
-
-  return burst_completed;
 }
 
 // In an analogous manner to CollectProfile() and samples exceeding the expected
 // total sampling time, bursts may also exceed the burst_interval. We adopt the
 // same wait-and-see approach here.
 void StackSamplingProfiler::SamplingThread::CollectProfiles(
     CallStackProfiles* profiles) {
   if (stop_event_.TimedWait(params_.initial_delay))
     return;
 
   TimeDelta previous_elapsed_profile_time;
   for (int i = 0; i < params_.bursts; ++i) {
     if (i != 0) {
       // Always wait, even if for 0 seconds, so we can observe a signal on
       // stop_event_.
       if (stop_event_.TimedWait(
               std::max(params_.burst_interval - previous_elapsed_profile_time,
                        TimeDelta())))
         return;
     }
 
     CallStackProfile profile;
-    if (!CollectProfile(&profile, &previous_elapsed_profile_time))
+    bool was_stopped = false;
+    CollectProfile(&profile, &previous_elapsed_profile_time, &was_stopped);
+    if (!profile.samples.empty())
+      profiles->push_back(profile);
+
+    if (was_stopped)
       return;
-    profiles->push_back(profile);
   }
 }
 
 void StackSamplingProfiler::SamplingThread::Stop() {
   stop_event_.Signal();
 }
 
 // StackSamplingProfiler ------------------------------------------------------
 
 StackSamplingProfiler::SamplingParams::SamplingParams()
@@ skipping 54 matching lines @@
 }
 
 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