Statistical stack profiler for Windows x64

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 "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/path_service.h"
+#include "base/profiler/stack_sampling_profiler.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/platform_thread.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+using Module = StackSamplingProfiler::Module;
+using Sample = StackSamplingProfiler::Sample;
+using Profile = StackSamplingProfiler::Profile;
+
+namespace {
+// A thread to target for profiling, whose stack is guaranteed to contain
+// SignalAndWaitUntilSignaled() when coordinated with the main thread.
+class TargetThread : public PlatformThread::Delegate {
+ public:
+  TargetThread();
+
+  // Implementation of PlatformThread::Delegate:
+  void ThreadMain() override;
+
+  // Wait for the thread to have started and be executing in
+  // SignalAndWaitUntilSignaled().
+  void WaitForThreadStart();
+  // Allow the thread to return from SignalAndWaitUntilSignaled() and finish
+  // execution.
+  void SignalThreadToFinish();
+
+  // This function is guaranteed to be executing between calls to
+  // WaitForThreadStart() and SignalThreadToFinish().
+  static void SignalAndWaitUntilSignaled(WaitableEvent* thread_started_event,
+                                         WaitableEvent* finish_event);
+
+  PlatformThreadId id() const { return id_; }
+
+ private:
+  WaitableEvent thread_started_event_;
+  WaitableEvent finish_event_;
+  PlatformThreadId id_;
+
+  DISALLOW_COPY_AND_ASSIGN(TargetThread);
+};
+
+TargetThread::TargetThread()
+    : thread_started_event_(false, false), finish_event_(false, false),
+      id_(0) {}
+
+void TargetThread::ThreadMain() {
+  id_ = PlatformThread::CurrentId();
+  SignalAndWaitUntilSignaled(&thread_started_event_, &finish_event_);
+}
+
+void TargetThread::WaitForThreadStart() {
+  thread_started_event_.Wait();
+}
+
+void TargetThread::SignalThreadToFinish() {
+  finish_event_.Signal();
+}
+
+// static
+#if defined(_WIN64)
+// Disable optimizations for this function so that it gets its own stack frame.
+#pragma optimize("", off)
+#endif
+void TargetThread::SignalAndWaitUntilSignaled(
+    WaitableEvent* thread_started_event,
+    WaitableEvent* finish_event) {
+  thread_started_event->Signal();
+  finish_event->Wait();
+}
+#if defined(_WIN64)
+#pragma optimize("", on)
+#endif
+
+// Called on the profiler thread when complete. Collects profiles produced by
+// the profiler, and signals an event to allow the main thread to know that that
+// the profiler is done.
+void SaveProfilesAndSignalEvent(std::vector<Profile>* profiles,
+                                WaitableEvent* event,
+                                const std::vector<Profile>& pending_profiles) {
+  *profiles = pending_profiles;
+  event->Signal();
+}
+
+// Captures profiles as specified by |params| on the TargetThread, and returns
+// them in |profiles|. Waits up to |profiler_wait_time| for the profiler to
+// complete.
+void CaptureProfiles(const StackSamplingProfiler::SamplingParams& params,
+                     std::vector<Profile>* profiles,
+                     TimeDelta profiler_wait_time) {
+  TargetThread target_thread;
+  PlatformThreadHandle target_thread_handle;
+  EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
+
+  target_thread.WaitForThreadStart();
+
+  WaitableEvent sampling_thread_completed(true, false);
+  profiles->clear();
+  StackSamplingProfiler profiler(target_thread.id(), params);
+  profiler.SetCustomCompletedCallback(
+      Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
+           Unretained(&sampling_thread_completed)));
+  profiler.Start();
+  sampling_thread_completed.TimedWait(profiler_wait_time);
+  profiler.Stop();
+  sampling_thread_completed.Wait();
+
+  target_thread.SignalThreadToFinish();
+
+  PlatformThread::Join(target_thread_handle);
+}
+
+// If this executable was linked with /INCREMENTAL (the default for non-official
+// debug and release builds on Windows), function addresses do not correspond to
+// function code itself, but instead to instructions in the Incremental Link
+// Table that jump to the functions. Check for a jump instruction and if present
+// do a little decompilation to find the function's actual starting address.
+const void* MaybeFixupFunctionAddressForILT(const void* function_address) {
+#if defined(_WIN64)
+  const unsigned char* opcode =
+      reinterpret_cast<const unsigned char*>(function_address);
+  if (*opcode == 0xe9) {
+    // This is a relative jump instruction. Assume we're in the ILT and compute
+    // the function start address from the instruction offset.
+    const unsigned char* offset = opcode + 1;
+    const unsigned char* next_instruction = opcode + 5;
+    return next_instruction +
+        static_cast<int64>(*reinterpret_cast<const int32*>(offset));
+  }
+#endif
+  return function_address;
+}
+
+// Searches through the frames in |sample|, returning an iterator to the first
+// frame that has an instruction pointer between |function_address| and
+// |function_address| + |size|. Returns sample.end() if no such frames are
+// found.
+Sample::const_iterator FindFirstFrameWithinFunction(
+    const Sample& sample,
+    const void* function_address,
+    int function_size) {
+  function_address = MaybeFixupFunctionAddressForILT(function_address);
+  for (auto it = sample.begin(); it != sample.end(); ++it) {
+    if ((reinterpret_cast<const unsigned char*>(it->instruction_pointer) >=
+         reinterpret_cast<const unsigned char*>(function_address)) &&
+        (reinterpret_cast<const unsigned char*>(it->instruction_pointer) <
+         (reinterpret_cast<const unsigned char*>(function_address) +
+          function_size)))
+      return it;
+  }
+  return sample.end();
+}
+
+// Returns a duration that is longer than the test timeout. We would use
+// TimeDelta::Max() but https://crbug.com/465948.
+TimeDelta AVeryLongTimeDelta() { return TimeDelta::FromDays(1); }
+}  // namespace
+
+
+// The tests below are enabled for Win x64 only, pending implementation of the
+// tested functionality on other platforms/architectures.
+
+// Checks that the basic expected information is present in a sampled profile.
+#if defined(_WIN64)
+#define MAYBE_Basic Basic
+#else
+#define MAYBE_Basic DISABLED_Basic
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_Basic) {
+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.burst_interval = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.bursts = 1;
+  params.samples_per_burst = 1;
+
+  std::vector<Profile> profiles;
+  CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
+
+  // Check that the profile and samples sizes are correct, and the module
+  // indices are in range.
+
+  ASSERT_EQ(1u, profiles.size());
+  const Profile& profile = profiles[0];
+  ASSERT_EQ(1u, profile.samples.size());
+  EXPECT_EQ(params.sampling_interval, profile.sampling_period);
+  const Sample& sample = profile.samples[0];
+  for (const auto& frame : sample) {
+    ASSERT_GE(frame.module_index, 0);
+    ASSERT_LT(frame.module_index, static_cast<int>(profile.modules.size()));
+  }
+
+  // Check that the stack contains a frame for
+  // TargetThread::SignalAndWaitUntilSignaled() and that the frame has this
+  // executable's module.
+
+  // Since we don't have a good way to know the function size, use 100 bytes as
+  // a reasonable window to locate the instruction pointer.
+  Sample::const_iterator loc = FindFirstFrameWithinFunction(
+      sample,
+      reinterpret_cast<const void*>(&TargetThread::SignalAndWaitUntilSignaled),
+      100);
+  ASSERT_TRUE(loc != sample.end()) << "function not found in stack";

[cpu_(ooo_6.6-7.5), 2015/03/20 19:34:41]

in the failure case, lets dump what we got to stdout so the people looking at
the bots (sheriffs) get a chance to paste meaninful info on a bug.

[Mike Wittman, 2015/03/20 20:56:20]

Done.

+
+  FilePath executable_path;
+  bool got_executable_path = PathService::Get(FILE_EXE, &executable_path);
+  EXPECT_TRUE(got_executable_path);
+  EXPECT_EQ(executable_path, profile.modules[loc->module_index].filename);
+}
+
+// Checks that the expected number of profiles and samples are present in the
+// profiles produced.
+#if defined(_WIN64)
+#define MAYBE_MultipleProfilesAndSamples MultipleProfilesAndSamples
+#else
+#define MAYBE_MultipleProfilesAndSamples DISABLED_MultipleProfilesAndSamples
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.burst_interval = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.bursts = 2;
+  params.samples_per_burst = 3;
+
+  std::vector<Profile> profiles;
+  CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
+
+  ASSERT_EQ(2u, profiles.size());
+  EXPECT_EQ(3u, profiles[0].samples.size());
+  EXPECT_EQ(3u, profiles[1].samples.size());
+}
+
+// Checks that no profiles are captured if the profiling is stopped during the
+// initial delay.
+#if defined(_WIN64)
+#define MAYBE_StopDuringInitialDelay StopDuringInitialDelay
+#else
+#define MAYBE_StopDuringInitialDelay DISABLED_StopDuringInitialDelay
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
+  StackSamplingProfiler::SamplingParams params;
+  params.burst_interval = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.initial_delay = TimeDelta::FromSeconds(60);
+  params.bursts = params.samples_per_burst = 1;
+
+  std::vector<Profile> profiles;
+  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(0));
+
+  EXPECT_TRUE(profiles.empty());
+}
+
+// Checks that the single completed profile is captured if the profiling is
+// stopped between bursts.
+#if defined(_WIN64)
+#define MAYBE_StopDuringInterBurstInterval StopDuringInterBurstInterval
+#else
+#define MAYBE_StopDuringInterBurstInterval DISABLED_StopDuringInterBurstInterval
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.burst_interval = TimeDelta::FromSeconds(60);
+  params.bursts = 2;
+  params.samples_per_burst = 1;
+
+  std::vector<Profile> profiles;
+  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
+
+  ASSERT_EQ(1u, profiles.size());
+  EXPECT_EQ(1u, profiles[0].samples.size());
+}
+
+// Checks that only completed profiles are captured.
+#if defined(_WIN64)
+#define MAYBE_StopDuringInterSampleInterval StopDuringInterSampleInterval
+#else
+#define MAYBE_StopDuringInterSampleInterval \
+  DISABLED_StopDuringInterSampleInterval
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.burst_interval = TimeDelta::FromMilliseconds(0);
+  params.sampling_interval = TimeDelta::FromSeconds(60);
+  params.bursts = 1;
+  params.samples_per_burst = 2;
+
+  std::vector<Profile> profiles;
+  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
+
+  EXPECT_TRUE(profiles.empty());
+}
+
+}  // namespace tracked_objects