Wait for sampling to complete before destructing.

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 10 matching lines @@
 #include "base/profiler/native_stack_sampler.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/elapsed_timer.h"
 
 namespace base {
 
 namespace {
 
-// AsyncRunner ----------------------------------------------------------------
-
-// Helper class to allow a profiler to be run completely asynchronously from the
-// initiator, without being concerned with the profiler's lifetime.
-class AsyncRunner {
- public:
-  // Sets up a profiler and arranges for it to be deleted on its completed
-  // callback.
-  static void Run(PlatformThreadId thread_id,
-                  const StackSamplingProfiler::SamplingParams& params,
-                  const StackSamplingProfiler::CompletedCallback& callback);
-
- private:
-  AsyncRunner();
-
-  // Runs the callback and deletes the AsyncRunner instance. |profiles| is not
-  // const& because it must be passed with std::move.
-  static void RunCallbackAndDeleteInstance(
-      std::unique_ptr<AsyncRunner> object_to_be_deleted,
-      const StackSamplingProfiler::CompletedCallback& callback,
-      scoped_refptr<SingleThreadTaskRunner> task_runner,
-      StackSamplingProfiler::CallStackProfiles profiles);
-
-  std::unique_ptr<StackSamplingProfiler> profiler_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncRunner);
-};
-
-// static
-void AsyncRunner::Run(
-    PlatformThreadId thread_id,
-    const StackSamplingProfiler::SamplingParams& params,
-    const StackSamplingProfiler::CompletedCallback &callback) {
-  std::unique_ptr<AsyncRunner> runner(new AsyncRunner);
-  AsyncRunner* temp_ptr = runner.get();
-  temp_ptr->profiler_.reset(
-      new StackSamplingProfiler(thread_id, params,
-                                Bind(&AsyncRunner::RunCallbackAndDeleteInstance,
-                                     Passed(&runner), callback,
-                                     ThreadTaskRunnerHandle::Get())));
-  // The callback won't be called until after Start(), so temp_ptr will still
-  // be valid here.
-  temp_ptr->profiler_->Start();
-}
-
-AsyncRunner::AsyncRunner() {}
-
-void AsyncRunner::RunCallbackAndDeleteInstance(
-    std::unique_ptr<AsyncRunner> object_to_be_deleted,
-    const StackSamplingProfiler::CompletedCallback& callback,
-    scoped_refptr<SingleThreadTaskRunner> task_runner,
-    StackSamplingProfiler::CallStackProfiles profiles) {
-  callback.Run(std::move(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);
@@ skipping 111 matching lines @@
   // Starts the thread.
   void Start();
 
   // 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);
 
   // Removes an active collection based on its ID, forcing it to run its
   // callback if any data has been collected. This can be called externally
-  // from any thread.
-  void Remove(int id);
+  // from any thread. The |done| event, if not null, will be signaled upon
+  // completion. |done| must live until after it has been signaled.
+  void Remove(int id, WaitableEvent* done);
 
   // Removes all active collections and stops the underlying thread.
   void Shutdown();
 
   // Begins an idle shutdown as if the idle-timer had expired.
   void ShutdownIfIdle();
 
   // Undoes the "permanent" effect of Shutdown() so the thread can restart.
   void UndoShutdown();
 
@@ skipping 17 matching lines @@
   void FinishCollection(CollectionContext* collection);
 
   // Records a single sample of a collection.
   void RecordSample(CollectionContext* collection);
 
   // Check if the sampling thread is idle.
   void CheckForIdle();
 
   // These methods are tasks that get posted to the internal message queue.
   void AddCollectionTask(std::unique_ptr<CollectionContext> collection_ptr);
-  void RemoveCollectionTask(int id);
+  void RemoveCollectionTask(int id, WaitableEvent* done);
   void PerformCollectionTask(int id);
   void ShutdownTask();
 
   // Updates the |next_sample_time| time based on configured parameters.
   bool UpdateNextSampleTime(CollectionContext* collection);
 
   // Thread:
   void CleanUp() override;
 
   // The task-runner for the sampling thread and some information about it.
@@ skipping 44 matching lines @@
   // There may be no task-runner if the sampling thread has been permanently
   // shut down.
   if (task_runner) {
     task_runner->PostTask(
         FROM_HERE, Bind(&SamplingThread::AddCollectionTask, Unretained(this),
                         Passed(&collection)));
   }
   return id;
 }
 
-void StackSamplingProfiler::SamplingThread::Remove(int id) {
+void StackSamplingProfiler::SamplingThread::Remove(int id,
+                                                   WaitableEvent* done) {
   scoped_refptr<SingleThreadTaskRunner> task_runner = GetTaskRunner();
-  if (!task_runner)
-    return;  // Everything has already stopped.
+  if (task_runner) {
+    // This can fail if the thread were to exit between acquisition of the task
+    // runner above and the call below. Because there may be something waiting
+    // for a signal on the |done| event, return only if the task was success-
+    // fully posted.
+    if (task_runner->PostTask(FROM_HERE,
+                              Bind(&SamplingThread::RemoveCollectionTask,
+                                   Unretained(this), id, Unretained(done)))) {
+      return;
+    }
+  }
 
-  // This can fail if the thread were to exit between acquisition of the task
-  // runner above and the call below. In that case, however, everything has
-  // stopped so there's no need to try to stop it.
-  task_runner->PostTask(FROM_HERE, Bind(&SamplingThread::RemoveCollectionTask,
-                                        Unretained(this), id));
+  // The sampling thread has already exited so signal the event here.
+  if (done)
+    done->Signal();
 }
 
 void StackSamplingProfiler::SamplingThread::Shutdown() {
   // Record that a shutdown has been requested so nothing can cause it to
   // start up again.
   {
     AutoLock lock(task_runner_lock_);
     task_runner_forced_shutdown_ = true;
   }
 
@@ skipping 164 matching lines @@
   CollectionContext* collection = collection_ptr.get();
   active_collections_.insert(
       std::make_pair(collection->collection_id, std::move(collection_ptr)));
 
   GetTaskRunnerOnSamplingThread()->PostDelayedTask(
       FROM_HERE, Bind(&SamplingThread::PerformCollectionTask, Unretained(this),
                       collection->collection_id),
       collection->params.initial_delay);
 }
 
-void StackSamplingProfiler::SamplingThread::RemoveCollectionTask(int id) {
+void StackSamplingProfiler::SamplingThread::RemoveCollectionTask(
+    int id,
+    WaitableEvent* done) {
   auto found = active_collections_.find(id);
-  if (found == active_collections_.end())
-    return;
+  if (found != active_collections_.end()) {
+    FinishCollection(found->second.get());
+    CheckForIdle();
+  }
 
-  FinishCollection(found->second.get());
-  CheckForIdle();
+  if (done)
+    done->Signal();
 }
 
 void StackSamplingProfiler::SamplingThread::PerformCollectionTask(int id) {
   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();
@@ skipping 117 matching lines @@
     const SamplingParams& params,
     const CompletedCallback& callback,
     NativeStackSamplerTestDelegate* test_delegate)
     : thread_id_(thread_id), params_(params), completed_callback_(callback),
       test_delegate_(test_delegate) {
   native_sampler_ = NativeStackSampler::Create(thread_id_, &RecordAnnotations,
                                                test_delegate_);
 }
 
 StackSamplingProfiler::~StackSamplingProfiler() {
-  Stop();
-
-#if !defined(OS_WIN)
-  // This is to prevent use of this object on non-Windows builds until such
-  // time as the following race condition is addressed:
-  //   Thread A creates a local (stack) StackSamplingProfiler.
-  //   Sampling is initiated against thread A ("A samples A").
-  //   The StackSamplingProfiler is destructed and thread A exits.
-  //   Sampling continues briefly until the async Stop() gets through.
-  //   Another thread with the same ID replaces the first one.
-  //   Sampling access the new thread and Bad Things(tm) happen.
-  // Windows is immune to this because the thread handle held internally
-  // prevents re-use of the thread-ID but this may not be the case on other
-  // platforms.
-  NOTREACHED();
-#endif
-}
-
-// static
-void StackSamplingProfiler::StartAndRunAsync(
-    PlatformThreadId thread_id,
-    const SamplingParams& params,
-    const CompletedCallback& callback) {
-  CHECK(ThreadTaskRunnerHandle::Get());
-  AsyncRunner::Run(thread_id, params, callback);
+  WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
+                     WaitableEvent::InitialState::NOT_SIGNALED);
+  Stop(&done);
+  done.Wait();
 }
 
 void StackSamplingProfiler::Start() {
   if (completed_callback_.is_null())
     return;
 
   if (!native_sampler_)
     return;
 
   collection_id_ = SamplingThread::GetInstance()->Add(
       MakeUnique<SamplingThread::CollectionContext>(
           thread_id_, params_, completed_callback_,
           std::move(native_sampler_)));
 }
 
-void StackSamplingProfiler::Stop() {
-  SamplingThread::GetInstance()->Remove(collection_id_);
+void StackSamplingProfiler::Stop(WaitableEvent* done) {
+  SamplingThread::GetInstance()->Remove(collection_id_, done);
 }
 
 // static
 void StackSamplingProfiler::Shutdown() {
   SamplingThread::GetInstance()->Shutdown();
 }
 
 // static
 void StackSamplingProfiler::UndoShutdownForTesting() {
   SamplingThread::GetInstance()->UndoShutdown();
@@ skipping 71 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