Support parallel captures from the StackSamplingProfiler.

base/profiler/stack_sampling_profiler_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 #include <memory>
 #include <utility>
@@ skipping 41 matching lines @@
 using SamplingParams = StackSamplingProfiler::SamplingParams;
 using Frame = StackSamplingProfiler::Frame;
 using Frames = std::vector<StackSamplingProfiler::Frame>;
 using Module = StackSamplingProfiler::Module;
 using Sample = StackSamplingProfiler::Sample;
 using CallStackProfile = StackSamplingProfiler::CallStackProfile;
 using CallStackProfiles = StackSamplingProfiler::CallStackProfiles;
 
 namespace {
 
+// Test delegate that signals when the thread-under-test has exited.
+class ThreadLifetimeSignaler : public NativeStackSamplerTestDelegate {
+ public:
+  ThreadLifetimeSignaler(WaitableEvent* thread_started,
+                         WaitableEvent* thread_sampled,
+                         WaitableEvent* thread_exited)
+      : thread_started_(thread_started),
+        thread_sampled_(thread_sampled),
+        thread_exited_(thread_exited) {}
+
+  void OnPostRecordSample(NativeStackSampler::ThreadState state) override {
+    if (state == NativeStackSampler::THREAD_RUNNING) {
+      if (thread_started_) {
+        thread_started_->Signal();
+        thread_started_ = nullptr;
+      }
+    }
+    if (thread_sampled_)
+      thread_sampled_->Signal();
+    if (state == NativeStackSampler::THREAD_EXITED) {
+      if (thread_exited_) {
+        thread_exited_->Signal();
+        thread_exited_ = nullptr;
+      }
+    }
+  }
+
+ private:
+  WaitableEvent* thread_started_;
+  WaitableEvent* thread_sampled_;
+  WaitableEvent* thread_exited_;
+};
+
 // Configuration for the frames that appear on the stack.
 struct StackConfiguration {
   enum Config { NORMAL, WITH_ALLOCA, WITH_OTHER_LIBRARY };
 
   explicit StackConfiguration(Config config)
       : StackConfiguration(config, nullptr) {
     EXPECT_NE(config, WITH_OTHER_LIBRARY);
   }
 
   StackConfiguration(Config config, NativeLibrary library)
@@ skipping 365 matching lines @@
 // asynchronous library loading has completed before walking the stack. If
 // false, the unloading may still be occurring during the stack walk.
 void TestLibraryUnload(bool wait_until_unloaded) {
   // Test delegate that supports intervening between the copying of the stack
   // and the walking of the stack.
   class StackCopiedSignaler : public NativeStackSamplerTestDelegate {
    public:
     StackCopiedSignaler(WaitableEvent* stack_copied,
                         WaitableEvent* start_stack_walk,
                         bool wait_to_walk_stack)
-        : stack_copied_(stack_copied), start_stack_walk_(start_stack_walk),
-          wait_to_walk_stack_(wait_to_walk_stack) {
-    }
+        : stack_copied_(stack_copied),
+          start_stack_walk_(start_stack_walk),
+          wait_to_walk_stack_(wait_to_walk_stack) {}
 
     void OnPreStackWalk() override {
       stack_copied_->Signal();
       if (wait_to_walk_stack_)
         start_stack_walk_->Wait();
     }
 
    private:
     WaitableEvent* const stack_copied_;
     WaitableEvent* const start_stack_walk_;
@@ skipping 156 matching lines @@
       sample, &TargetThread::SignalAndWaitUntilSignaled);
   ASSERT_TRUE(loc != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
              &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
   FilePath executable_path;
   EXPECT_TRUE(PathService::Get(FILE_EXE, &executable_path));
   EXPECT_EQ(executable_path, profile.modules[loc->module_index].filename);
+
+  // Ensure the sampling thread is still running at this point.
+  ASSERT_TRUE(StackSamplingProfiler::IsSamplingThreadRunningForTesting());
+
+  // Shutdown the sampler as though the process were about to exit.
+  StackSamplingProfiler::Shutdown();
+  EXPECT_FALSE(StackSamplingProfiler::IsSamplingThreadRunningForTesting());
+
+  // Shutdown is a permanent thing in general but this needs to be undone so
+  // other tests can run.
+  StackSamplingProfiler::UndoShutdownForTesting();
+  EXPECT_FALSE(StackSamplingProfiler::IsSamplingThreadRunningForTesting());
 }
 
 // Checks that annotations are recorded in samples.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Annotations Annotations
 #else
 #define MAYBE_Annotations DISABLED_Annotations
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_Annotations) {
   StackSamplingProfiler::ResetAnnotationsForTesting();
@@ skipping 77 matching lines @@
              reinterpret_cast<const void*>(&TargetThread::CallWithAlloca))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   // These frames should be adjacent on the stack.
   EXPECT_EQ(1, alloca_frame - end_frame)
       << "Stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 }
 
-// Checks that the fire-and-forget interface works.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
-#define MAYBE_StartAndRunAsync StartAndRunAsync
-#else
-#define MAYBE_StartAndRunAsync DISABLED_StartAndRunAsync
-#endif
-TEST(StackSamplingProfilerTest, MAYBE_StartAndRunAsync) {
-  // StartAndRunAsync requires the caller to have a message loop.
-  MessageLoop message_loop;
-
-  SamplingParams params;
-  params.samples_per_burst = 1;
-
-  CallStackProfiles profiles;
-  WithTargetThread([&params, &profiles](PlatformThreadId target_thread_id) {
-    WaitableEvent sampling_thread_completed(
-        WaitableEvent::ResetPolicy::AUTOMATIC,
-        WaitableEvent::InitialState::NOT_SIGNALED);
-    const StackSamplingProfiler::CompletedCallback callback =
-        Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
-             Unretained(&sampling_thread_completed));
-    StackSamplingProfiler::StartAndRunAsync(target_thread_id, params, callback);
-    RunLoop().RunUntilIdle();
-    sampling_thread_completed.Wait();
-  });
-
-  ASSERT_EQ(1u, profiles.size());
-}
-
 // Checks that the expected number of profiles and samples are present in the
 // call stack profiles produced.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_MultipleProfilesAndSamples MultipleProfilesAndSamples
 #else
 #define MAYBE_MultipleProfilesAndSamples DISABLED_MultipleProfilesAndSamples
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
   SamplingParams params;
   params.burst_interval = params.sampling_interval =
@@ skipping 84 matching lines @@
         target_thread_id, params, Bind(&SaveProfiles, Unretained(&profiles))));
     profiler->Start();
     profiler.reset();
 
     // Wait longer than a sample interval to catch any use-after-free actions by
     // the profiler thread.
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
   });
 }
 
+// Checks that we can destroy the thread under test while profiling.
+// This isn't officially supported but is expected to work under Windows.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && defined(OS_WIN)
+#define MAYBE_DestroyThreadWhileProfiling DestroyThreadWhileProfiling
+#else
+#define MAYBE_DestroyThreadWhileProfiling DISABLED_DestroyThreadWhileProfiling
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_DestroyThreadWhileProfiling) {

[Mike Wittman, 2017/02/13 22:35:57]

This test can be removed since it's no longer the responsibility of the
StackSamplingProfiler to manage thread exit.

[bcwhite, 2017/02/14 14:33:02]

Done.

+  // Set up a thread for testing.
+  StackConfiguration stack_config(StackConfiguration::NORMAL);
+  TargetThread target_thread(stack_config);
+  PlatformThreadHandle target_thread_handle;
+  ASSERT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
+
+  // Set up the sampler: 5 samples, 1 second apart
+  SamplingParams params;
+  params.sampling_interval = TimeDelta::FromSeconds(1);
+  params.samples_per_burst = 5;
+  std::vector<CallStackProfile> profiles;
+  WaitableEvent sampling_thread_completed(
+      WaitableEvent::ResetPolicy::MANUAL,
+      WaitableEvent::InitialState::NOT_SIGNALED);
+  const StackSamplingProfiler::CompletedCallback callback =
+      Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
+           Unretained(&sampling_thread_completed));
+
+  // Set up events to detect thread lifetime.
+  WaitableEvent thread_started(WaitableEvent::ResetPolicy::MANUAL,
+                               WaitableEvent::InitialState::NOT_SIGNALED);
+  WaitableEvent thread_sampled(WaitableEvent::ResetPolicy::MANUAL,
+                               WaitableEvent::InitialState::NOT_SIGNALED);
+  WaitableEvent thread_exited(WaitableEvent::ResetPolicy::MANUAL,
+                              WaitableEvent::InitialState::NOT_SIGNALED);
+  ThreadLifetimeSignaler test_delegate(&thread_started, &thread_sampled,
+                                       &thread_exited);
+
+  // Start the thread and the sampler and wait a short while.
+  target_thread.WaitForThreadStart();
+  StackSamplingProfiler profiler(target_thread.id(), params, callback,
+                                 &test_delegate);
+  profiler.Start();
+
+  // Delay until the thread gets started and a sample is collected.
+  thread_started.Wait();
+
+  // Stop the target thread.
+  target_thread.SignalThreadToFinish();
+  PlatformThread::Join(target_thread_handle);
+
+  // Wait for one more sampling attempt.
+  thread_sampled.Reset();
+  thread_sampled.Wait();
+
+  // Stop sampling and wait for it to finish.
+  profiler.Stop();
+  sampling_thread_completed.Wait();
+
+  // There should be one profile in which the first sample has frames and
+  // the last does not.
+  ASSERT_EQ(1U, profiles.size());
+  EXPECT_NE(0U, profiles[0].samples.front().frames.size());
+  EXPECT_EQ(0U, profiles[0].samples.back().frames.size());
+}
+
 // Checks that the same profiler may be run multiple times.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_CanRunMultipleTimes CanRunMultipleTimes
 #else
 #define MAYBE_CanRunMultipleTimes DISABLED_CanRunMultipleTimes
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_CanRunMultipleTimes) {
+  StackSamplingProfiler::SetSamplingThreadIdleShutdownTimeForTesting(0);
+
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
   ASSERT_EQ(1u, profiles.size());
 
   profiles.clear();
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
   ASSERT_EQ(1u, profiles.size());
+
+  // Capture thread should still be running at this point.
+  ASSERT_TRUE(StackSamplingProfiler::IsSamplingThreadRunningForTesting());
+
+  // Initiate an "idle" shutdown.  The task will be run immediately but on
+  // another thread so wait for it to complete.
+  StackSamplingProfiler::InitiateSamplingThreadIdleShutdownForTesting();
+  while (StackSamplingProfiler::IsSamplingThreadRunningForTesting())
+    PlatformThread::YieldCurrentThread();
+
+  // Ensure another capture will start the sampling thread and run.
+  profiles.clear();
+  CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
+  ASSERT_EQ(1u, profiles.size());
+  EXPECT_TRUE(StackSamplingProfiler::IsSamplingThreadRunningForTesting());
 }
 
 // Checks that requests to start profiling while another profile is taking place

[Mike Wittman, 2017/02/13 22:35:57]

This comment needs updating.

[bcwhite, 2017/02/14 14:33:02]

Done.

 // are ignored.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_ConcurrentProfiling ConcurrentProfiling
 #else
 #define MAYBE_ConcurrentProfiling DISABLED_ConcurrentProfiling
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_ConcurrentProfiling) {
   WithTargetThread([](PlatformThreadId target_thread_id) {
     SamplingParams params[2];
     params[0].initial_delay = TimeDelta::FromMilliseconds(10);
-    params[0].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[0].samples_per_burst = 1;
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[0].samples_per_burst = 10;
 
-    params[1].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[1].samples_per_burst = 1;
+    params[0].initial_delay = TimeDelta::FromMilliseconds(10);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 10;
 
     CallStackProfiles profiles[2];
     std::vector<std::unique_ptr<WaitableEvent>> sampling_completed(2);
     std::vector<std::unique_ptr<StackSamplingProfiler>> profiler(2);
     for (int i = 0; i < 2; ++i) {
       sampling_completed[i] =
           MakeUnique<WaitableEvent>(WaitableEvent::ResetPolicy::AUTOMATIC,
                                     WaitableEvent::InitialState::NOT_SIGNALED);
       const StackSamplingProfiler::CompletedCallback callback =
           Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles[i]),
@@ skipping 10 matching lines @@
     std::transform(
         sampling_completed.begin(), sampling_completed.end(),
         sampling_completed_rawptrs.begin(),
         [](const std::unique_ptr<WaitableEvent>& elem) { return elem.get(); });
     // Wait for one profiler to finish.
     size_t completed_profiler =
         WaitableEvent::WaitMany(sampling_completed_rawptrs.data(), 2);
     EXPECT_EQ(1u, profiles[completed_profiler].size());
 
     size_t other_profiler = 1 - completed_profiler;
-    // Give the other profiler a chance to run and observe that it hasn't.
-    EXPECT_FALSE(sampling_completed[other_profiler]->TimedWait(
-        TimeDelta::FromMilliseconds(25)));
-
-    // Start the other profiler again and it should run.
-    profiler[other_profiler]->Start();
-    sampling_completed[other_profiler]->Wait();
-    EXPECT_EQ(1u, profiles[other_profiler].size());
+    // Give the other profiler a chance to finish and verify it does no.

[Mike Wittman, 2017/02/13 22:35:57]

nit: does so

[bcwhite, 2017/02/14 14:33:02]

Done.

+    EXPECT_TRUE(sampling_completed[other_profiler]->TimedWait(
+        TimeDelta::FromMilliseconds(250)));
   });
 }
 
 // Checks that a stack that runs through another library produces a stack with
 // the expected functions.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_OtherLibrary OtherLibrary
 #else
 #define MAYBE_OtherLibrary DISABLED_OtherLibrary
 #endif
@@ skipping 77 matching lines @@
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
   TestLibraryUnload(true);
 }
 
 }  // namespace base