Make stack sampling profiler sample beyond startup.

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 <map>
 #include <utility>
 
@@ skipping 139 matching lines @@
           callback(callback),
           finished(finished),
           native_sampler(std::move(sampler)) {}
     ~CollectionContext() {}
 
     // An identifier for this collection, used to uniquely identify it to
     // outside interests.
     const int collection_id;
 
     const PlatformThreadId target;     // ID of The thread being sampled.
-    const SamplingParams params;       // Information about how to sample.
+
+    // Information about how to sample. Not const because they can be updated
+    // upon collection completion by |callback|.
+    SamplingParams params;
+
     const CompletedCallback callback;  // Callback made when sampling complete.
     WaitableEvent* const finished;     // Signaled when all sampling complete.
 
     // Platform-specific module that does the actual sampling.
     std::unique_ptr<NativeStackSampler> native_sampler;
 
     // The absolute time for the next sample.
     Time next_sample_time;
 
     // The time that a profile was started, for calculating the total duration.
@@ skipping 50 matching lines @@
   ~SamplingThread() override;
 
   // Get task runner that is usable from the outside.
   scoped_refptr<SingleThreadTaskRunner> GetOrCreateTaskRunnerForAdd();
   scoped_refptr<SingleThreadTaskRunner> GetTaskRunner(
       ThreadExecutionState* out_state);
 
   // Get task runner that is usable from the sampling thread itself.
   scoped_refptr<SingleThreadTaskRunner> GetTaskRunnerOnSamplingThread();
 
-  // Finishes a collection and reports collected data via callback.
-  void FinishCollection(CollectionContext* collection);
+  // Finishes a collection and reports collected data via callback. Returns
+  // whether collection should be restarted per the callback.
+  bool FinishCollection(CollectionContext* collection);
 
   // Records a single sample of a collection.
   void RecordSample(CollectionContext* collection);
 
   // Check if the sampling thread is idle and begin a shutdown if it is.
   void ScheduleShutdownIfIdle();
 
   // These methods are tasks that get posted to the internal message queue.
   void AddCollectionTask(std::unique_ptr<CollectionContext> collection);
   void RemoveCollectionTask(int id);
@@ skipping 225 matching lines @@
 
 scoped_refptr<SingleThreadTaskRunner>
 StackSamplingProfiler::SamplingThread::GetTaskRunnerOnSamplingThread() {
   // This should be called only from the sampling thread as it has limited
   // accessibility.
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   return Thread::task_runner();
 }
 
-void StackSamplingProfiler::SamplingThread::FinishCollection(
+bool StackSamplingProfiler::SamplingThread::FinishCollection(
     CollectionContext* collection) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   // If there is no duration for the final profile (because it was stopped),
   // calculate it now.
   if (!collection->profiles.empty() &&
       collection->profiles.back().profile_duration == TimeDelta()) {
     collection->profiles.back().profile_duration =
         Time::Now() - collection->profile_start_time;
   }
 
   // Extract some information so callback and event-signalling can still be
   // done after the collection has been removed from the list of "active" ones.
   // This allows the the controlling object (and tests using it) to be confident
   // that collection is fully finished when those things occur.
   const CompletedCallback callback = collection->callback;
   CallStackProfiles profiles = std::move(collection->profiles);
   WaitableEvent* finished = collection->finished;
 
-  // Remove this collection from the map of known ones.  The |collection|
-  // parameter is invalid after this point.
-  size_t count = active_collections_.erase(collection->collection_id);
-  DCHECK_EQ(1U, count);
-
   // Run the associated callback, passing the collected profiles.
-  callback.Run(std::move(profiles));
+  bool restart_collection =
+      callback.Run(std::move(profiles), &collection->params);
 
   // Signal that this collection is finished.
   finished->Signal();
+
+  return restart_collection;
 }
 
 void StackSamplingProfiler::SamplingThread::RecordSample(
     CollectionContext* collection) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
   DCHECK(collection->native_sampler);
 
   // If this is the first sample of a burst, a new Profile needs to be created
   // and filled.
   if (collection->sample == 0) {
@@ skipping 64 matching lines @@
   }
 }
 
 void StackSamplingProfiler::SamplingThread::RemoveCollectionTask(int id) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   auto found = active_collections_.find(id);
   if (found == active_collections_.end())
     return;
 
-  FinishCollection(found->second.get());
+  auto* collection = found->second.get();
+  FinishCollection(collection);
+
+  // Remove this collection from the map of known ones.  The |collection|
+  // parameter is invalid after this point.
+  size_t count = active_collections_.erase(collection->collection_id);
+  DCHECK_EQ(1U, count);
+
   ScheduleShutdownIfIdle();
 }
 
 void StackSamplingProfiler::SamplingThread::PerformCollectionTask(int id) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   auto found = active_collections_.find(id);
 
   // The task won't be found if it has been stopped.
   if (found == active_collections_.end())
     return;
 
   CollectionContext* collection = found->second.get();
 
   // Handle first-run with no "next time".
   if (collection->next_sample_time == Time())
     collection->next_sample_time = Time::Now();
 
   // Do the collection of a single sample.
   RecordSample(collection);
 
   // Update the time of the next sample recording.
-  if (UpdateNextSampleTime(collection)) {
-    bool success = GetTaskRunnerOnSamplingThread()->PostDelayedTask(
-        FROM_HERE,
-        BindOnce(&SamplingThread::PerformCollectionTask, Unretained(this), id),
-        std::max(collection->next_sample_time - Time::Now(), TimeDelta()));
-    DCHECK(success);
-  } else {
-    // All capturing has completed so finish the collection. By not re-adding
-    // it to the task queue, the collection will "expire" (i.e. no further work
-    // will be done). The |collection| variable will be invalid after this call.
-    FinishCollection(collection);
+  bool collection_finished = !UpdateNextSampleTime(collection);
+  if (collection_finished) {
+    // All capturing has completed so finish the collection.
+    collection_finished = !FinishCollection(collection);
+    if (!collection_finished) {
+      // Attempt to restart the collection with the new params.
+      collection->next_sample_time =

[Mike Wittman, 2017/07/01 02:44:06]

I'd prefer to create a new CollectionContext and set its state from the current
one, to make clear which state is being reused between collections. You'll
likely need to preserve the collection_id so that the Stop operation continues
to work.

[Alexei Svitkine (slow), 2017/07/06 15:51:09]

Done.

+          Time::Now() + collection->params.initial_delay;
+      collection->burst = 0;
+      collection->sample = 0;
+    }
+  }
+
+  if (collection_finished) {
+    // Remove this collection from the map of known ones.  The |collection|
+    // parameter is invalid after this point.
+    size_t count = active_collections_.erase(collection->collection_id);
+    DCHECK_EQ(1U, count);
+
+    // By not adding it to the task queue, the collection will "expire" (i.e.
+    // no further work will be done). The |collection| variable will be invalid
+    // after this call.
     ScheduleShutdownIfIdle();
+    return;
   }
+
+  bool success = GetTaskRunnerOnSamplingThread()->PostDelayedTask(
+      FROM_HERE,
+      BindOnce(&SamplingThread::PerformCollectionTask, Unretained(this), id),
+      std::max(collection->next_sample_time - Time::Now(), TimeDelta()));
+  DCHECK(success);
 }
 
 void StackSamplingProfiler::SamplingThread::ShutdownTask(int add_events) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   // Holding this lock ensures that any attempt to start another job will
   // get postponed until |thread_execution_state_| is updated, thus eliminating
   // the race in starting a new thread while the previous one is exiting.
   AutoLock lock(thread_execution_state_lock_);
 
@@ skipping 207 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