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 13 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/elapsed_timer.h"
 
 namespace base {
 
 namespace {
 
 // This value is used when there is no collection in progress and thus no ID
 // for referencing the active collection to the SamplingThread.
-const int NULL_COLLECTION_ID = -1;
+const int NULL_PROFILER_ID = -1;
 
 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 =
@@ skipping 87 matching lines @@
     static void ShutdownAssumingIdle(bool simulate_intervening_add);
 
    private:
     // Calls the sampling threads ShutdownTask and then signals an event.
     static void ShutdownTaskAndSignalEvent(SamplingThread* sampler,
                                            int add_events,
                                            WaitableEvent* event);
   };
 
   struct CollectionContext {
-    CollectionContext(PlatformThreadId target,
+    CollectionContext(int profiler_id,
+                      PlatformThreadId target,
                       const SamplingParams& params,
                       const CompletedCallback& callback,
                       WaitableEvent* finished,
                       std::unique_ptr<NativeStackSampler> sampler)
-        : collection_id(next_collection_id_.GetNext()),
+        : profiler_id(profiler_id),
           target(target),
           params(params),
           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;
+    // An identifier for the profiler associated with this collection, used to
+    // uniquely identify the collection to outside interests.
+    const int profiler_id;
 
     const PlatformThreadId target;     // ID of The thread being sampled.
     const SamplingParams params;       // Information about how to sample.
     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.
     Time profile_start_time;
 
     // Counters that indicate the current position along the acquisition.
     int burst = 0;
     int sample = 0;
 
     // The collected stack samples. The active profile is always at the back().
     CallStackProfiles profiles;
 
-   private:
-    static StaticAtomicSequenceNumber next_collection_id_;
+    // Sequence number for generating new profiler ids.
+    static StaticAtomicSequenceNumber next_profiler_id;
   };
 
   // Gets the single instance of this class.
   static SamplingThread* GetInstance();
 
   // Adds a new CollectionContext to the thread. This can be called externally
   // from any thread. This returns an ID that can later be used to stop
   // the sampling.
   int Add(std::unique_ptr<CollectionContext> collection);
 
@@ skipping 29 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
+  // the new collection params, if a new collection should be started. The
+  // |collection| should already have been removed from |active_collections_|
+  // by the caller, as this is needed to avoid flakyness in unit tests.
+  Optional<SamplingParams> 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 111 matching lines @@
 
 // static
 void StackSamplingProfiler::SamplingThread::TestAPI::ShutdownTaskAndSignalEvent(
     SamplingThread* sampler,
     int add_events,
     WaitableEvent* event) {
   sampler->ShutdownTask(add_events);
   event->Signal();
 }
 
-StaticAtomicSequenceNumber StackSamplingProfiler::SamplingThread::
-    CollectionContext::next_collection_id_;
+StaticAtomicSequenceNumber
+    StackSamplingProfiler::SamplingThread::CollectionContext::next_profiler_id;
 
 StackSamplingProfiler::SamplingThread::SamplingThread()
     : Thread("StackSamplingProfiler") {}
 
 StackSamplingProfiler::SamplingThread::~SamplingThread() = default;
 
 StackSamplingProfiler::SamplingThread*
 StackSamplingProfiler::SamplingThread::GetInstance() {
   return Singleton<SamplingThread, LeakySingletonTraits<SamplingThread>>::get();
 }
 
 int StackSamplingProfiler::SamplingThread::Add(
     std::unique_ptr<CollectionContext> collection) {
   // This is not to be run on the sampling thread.
 
-  int id = collection->collection_id;
+  int id = collection->profiler_id;
   scoped_refptr<SingleThreadTaskRunner> task_runner =
       GetOrCreateTaskRunnerForAdd();
 
   task_runner->PostTask(
       FROM_HERE, BindOnce(&SamplingThread::AddCollectionTask, Unretained(this),
                           Passed(&collection)));
 
   return id;
 }
 
@@ skipping 76 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(
+Optional<StackSamplingProfiler::SamplingParams>
+StackSamplingProfiler::SamplingThread::FinishCollection(
     CollectionContext* collection) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 

[Mike Wittman, 2017/07/11 21:41:52]

DCHECK_EQ(0u, active_collections_.count(collection->profiler_id));

   // 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;
+        Time::Now() - collection->profile_start_time +
+        collection->params.sampling_interval;
   }
 
   // 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));
+  Optional<SamplingParams> new_params = callback.Run(std::move(profiles));
 
   // Signal that this collection is finished.
   finished->Signal();
+
+  return new_params;
 }
 
 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) {
     collection->profiles.push_back(CallStackProfile());
     CallStackProfile& profile = collection->profiles.back();
     profile.sampling_period = collection->params.sampling_interval;
     collection->profile_start_time = Time::Now();
     collection->native_sampler->ProfileRecordingStarting(&profile.modules);
   }
 
   // The currently active profile being captured.
   CallStackProfile& profile = collection->profiles.back();
 
   // Record a single sample.
   profile.samples.push_back(Sample());
   collection->native_sampler->RecordStackSample(stack_buffer_.get(),
                                                 &profile.samples.back());
 
   // If this is the last sample of a burst, record the total time.
   if (collection->sample == collection->params.samples_per_burst - 1) {
-    profile.profile_duration = Time::Now() - collection->profile_start_time;
+    profile.profile_duration = Time::Now() - collection->profile_start_time +
+                               collection->params.sampling_interval;
     collection->native_sampler->ProfileRecordingStopped(stack_buffer_.get());
   }
 }
 
 void StackSamplingProfiler::SamplingThread::ScheduleShutdownIfIdle() {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   if (!active_collections_.empty())
     return;
 
   int add_events;
   {
     AutoLock lock(thread_execution_state_lock_);
     if (thread_execution_state_disable_idle_shutdown_for_testing_)
       return;
     add_events = thread_execution_state_add_events_;
   }
 
   GetTaskRunnerOnSamplingThread()->PostDelayedTask(
       FROM_HERE,
       BindOnce(&SamplingThread::ShutdownTask, Unretained(this), add_events),
       TimeDelta::FromSeconds(60));
 }
 
 void StackSamplingProfiler::SamplingThread::AddCollectionTask(
     std::unique_ptr<CollectionContext> collection) {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
-  const int collection_id = collection->collection_id;
+  const int profiler_id = collection->profiler_id;
   const TimeDelta initial_delay = collection->params.initial_delay;
 
   active_collections_.insert(
-      std::make_pair(collection_id, std::move(collection)));
+      std::make_pair(profiler_id, std::move(collection)));
 
   GetTaskRunnerOnSamplingThread()->PostDelayedTask(
       FROM_HERE,
       BindOnce(&SamplingThread::PerformCollectionTask, Unretained(this),
-               collection_id),
+               profiler_id),
       initial_delay);
 
   // Another increment of "add events" serves to invalidate any pending
   // shutdown tasks that may have been initiated between the Add() and this
   // task running.
   {
     AutoLock lock(thread_execution_state_lock_);
     ++thread_execution_state_add_events_;
   }
 }
 
 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());
+  // Remove |collection| from |active_collections_|.
+  std::unique_ptr<CollectionContext> collection = std::move(found->second);
+  size_t count = active_collections_.erase(id);
+  DCHECK_EQ(1U, count);
+
+  FinishCollection(collection.get());
   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)) {
+  const bool collection_finished = !UpdateNextSampleTime(collection);
+  if (!collection_finished) {
     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);
+    return;
+  }
+
+  // Take ownership of |collection| and remove it from the map. If collection is
+  // to be restarted, a new collection task will be added below.
+  std::unique_ptr<CollectionContext> owned_collection =
+      std::move(found->second);
+  size_t count = active_collections_.erase(id);
+  DCHECK_EQ(1U, count);
+
+  // All capturing has completed so finish the collection. If no new params
+  // are returned, a new collection should not be started.
+  Optional<SamplingParams> new_params = FinishCollection(collection);
+  if (!new_params.has_value()) {
+    // By not adding it to the task queue, the collection will "expire" (i.e.
+    // no further work will be done).
     ScheduleShutdownIfIdle();
+    return;
   }
+
+  // Restart the collection with the new params. Keep the same id so the
+  // Stop() operation continues to work.
+  auto new_collection = MakeUnique<SamplingThread::CollectionContext>(
+      id, collection->target, new_params.value(), collection->callback,
+      collection->finished, std::move(collection->native_sampler));
+  AddCollectionTask(std::move(new_collection));
 }
 
 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 99 matching lines @@
     const SamplingParams& params,
     const CompletedCallback& callback,
     NativeStackSamplerTestDelegate* test_delegate)
     : thread_id_(thread_id),
       params_(params),
       completed_callback_(callback),
       // The event starts "signaled" so code knows it's safe to start thread
       // and "manual" so that it can be waited in multiple places.
       profiling_inactive_(WaitableEvent::ResetPolicy::MANUAL,
                           WaitableEvent::InitialState::SIGNALED),
-      collection_id_(NULL_COLLECTION_ID),
+      profiler_id_(NULL_PROFILER_ID),
       test_delegate_(test_delegate) {}
 
 StackSamplingProfiler::~StackSamplingProfiler() {
   // Stop returns immediately but the shutdown runs asynchronously. There is a
   // non-zero probability that one more sample will be taken after this call
   // returns.
   Stop();
 
   // The behavior of sampling a thread that has exited is undefined and could
   // cause Bad Things(tm) to occur. The safety model provided by this class is
@@ skipping 16 matching lines @@
       NativeStackSampler::Create(thread_id_, &RecordAnnotations,
                                  test_delegate_);
 
   if (!native_sampler)
     return;
 
   // Wait for profiling to be "inactive", then reset it for the upcoming run.
   profiling_inactive_.Wait();
   profiling_inactive_.Reset();
 
-  DCHECK_EQ(NULL_COLLECTION_ID, collection_id_);
-  collection_id_ = SamplingThread::GetInstance()->Add(
+  DCHECK_EQ(NULL_PROFILER_ID, profiler_id_);
+  profiler_id_ = SamplingThread::GetInstance()->Add(
       MakeUnique<SamplingThread::CollectionContext>(
+          SamplingThread::CollectionContext::next_profiler_id.GetNext(),
           thread_id_, params_, completed_callback_, &profiling_inactive_,
           std::move(native_sampler)));
-  DCHECK_NE(NULL_COLLECTION_ID, collection_id_);
+  DCHECK_NE(NULL_PROFILER_ID, profiler_id_);
 }
 
 void StackSamplingProfiler::Stop() {
-  SamplingThread::GetInstance()->Remove(collection_id_);
-  collection_id_ = NULL_COLLECTION_ID;
+  SamplingThread::GetInstance()->Remove(profiler_id_);
+  profiler_id_ = NULL_PROFILER_ID;
 }
 
 // static
 void StackSamplingProfiler::SetProcessMilestone(int milestone) {
   DCHECK_LE(0, milestone);
   DCHECK_GT(static_cast<int>(sizeof(process_milestones_) * 8), milestone);
   DCHECK_EQ(0, subtle::NoBarrier_Load(&process_milestones_) & (1 << milestone));
   ChangeAtomicFlags(&process_milestones_, 1 << milestone, 0);
 }
 
@@ skipping 40 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