base/profiler/stack_sampling_profiler_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <sstream>
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/path_service.h"
  10 #include "base/profiler/stack_sampling_profiler.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/threading/platform_thread.h"
  13 #include "base/time/time.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace base {
  17
  18 using Frame = StackSamplingProfiler::Frame;
  19 using Module = StackSamplingProfiler::Module;
  20 using Sample = StackSamplingProfiler::Sample;
  21 using Profile = StackSamplingProfiler::Profile;
  22
  23 namespace {
  24 // A thread to target for profiling, whose stack is guaranteed to contain
  25 // SignalAndWaitUntilSignaled() when coordinated with the main thread.
  26 class TargetThread : public PlatformThread::Delegate {
  27  public:
  28   TargetThread();
  29
  30   // Implementation of PlatformThread::Delegate:
  31   void ThreadMain() override;
  32
  33   // Wait for the thread to have started and be executing in
  34   // SignalAndWaitUntilSignaled().
  35   void WaitForThreadStart();
  36   // Allow the thread to return from SignalAndWaitUntilSignaled() and finish
  37   // execution.
  38   void SignalThreadToFinish();
  39
  40   // This function is guaranteed to be executing between calls to
  41   // WaitForThreadStart() and SignalThreadToFinish().
  42   static void SignalAndWaitUntilSignaled(WaitableEvent* thread_started_event,
  43                                          WaitableEvent* finish_event);
  44
  45   PlatformThreadId id() const { return id_; }
  46
  47  private:
  48   WaitableEvent thread_started_event_;
  49   WaitableEvent finish_event_;
  50   PlatformThreadId id_;
  51
  52   DISALLOW_COPY_AND_ASSIGN(TargetThread);
  53 };
  54
  55 TargetThread::TargetThread()
  56     : thread_started_event_(false, false), finish_event_(false, false),
  57       id_(0) {}
  58
  59 void TargetThread::ThreadMain() {
  60   id_ = PlatformThread::CurrentId();
  61   SignalAndWaitUntilSignaled(&thread_started_event_, &finish_event_);
  62 }
  63
  64 void TargetThread::WaitForThreadStart() {
  65   thread_started_event_.Wait();
  66 }
  67
  68 void TargetThread::SignalThreadToFinish() {
  69   finish_event_.Signal();
  70 }
  71
  72 // static
  73 // Disable inlining for this function so that it gets its own stack frame.
  74 NOINLINE void TargetThread::SignalAndWaitUntilSignaled(
  75     WaitableEvent* thread_started_event,
  76     WaitableEvent* finish_event) {
  77   thread_started_event->Signal();
  78   volatile int x = 1;
  79   finish_event->Wait();
  80   x = 0;  // Prevent tail call to WaitableEvent::Wait().
  81   ALLOW_UNUSED_LOCAL(x);
  82 }
  83
  84 // Called on the profiler thread when complete. Collects profiles produced by
  85 // the profiler, and signals an event to allow the main thread to know that that
  86 // the profiler is done.
  87 void SaveProfilesAndSignalEvent(std::vector<Profile>* profiles,
  88                                 WaitableEvent* event,
  89                                 const std::vector<Profile>& pending_profiles) {
  90   *profiles = pending_profiles;
  91   event->Signal();
  92 }
  93
  94 // Captures profiles as specified by |params| on the TargetThread, and returns
  95 // them in |profiles|. Waits up to |profiler_wait_time| for the profiler to
  96 // complete.
  97 void CaptureProfiles(const StackSamplingProfiler::SamplingParams& params,
  98                      std::vector<Profile>* profiles,
  99                      TimeDelta profiler_wait_time) {
 100   TargetThread target_thread;
 101   PlatformThreadHandle target_thread_handle;
 102   EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
 103
 104   target_thread.WaitForThreadStart();
 105
 106   WaitableEvent sampling_thread_completed(true, false);
 107   profiles->clear();
 108   StackSamplingProfiler profiler(target_thread.id(), params);
 109   profiler.SetCustomCompletedCallback(
 110       Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
 111            Unretained(&sampling_thread_completed)));
 112   profiler.Start();
 113   sampling_thread_completed.TimedWait(profiler_wait_time);
 114   profiler.Stop();
 115   sampling_thread_completed.Wait();
 116
 117   target_thread.SignalThreadToFinish();
 118
 119   PlatformThread::Join(target_thread_handle);
 120 }
 121
 122 // If this executable was linked with /INCREMENTAL (the default for non-official
 123 // debug and release builds on Windows), function addresses do not correspond to
 124 // function code itself, but instead to instructions in the Incremental Link
 125 // Table that jump to the functions. Check for a jump instruction and if present
 126 // do a little decompilation to find the function's actual starting address.
 127 const void* MaybeFixupFunctionAddressForILT(const void* function_address) {
 128 #if defined(_WIN64)
 129   const unsigned char* opcode =
 130       reinterpret_cast<const unsigned char*>(function_address);
 131   if (*opcode == 0xe9) {
 132     // This is a relative jump instruction. Assume we're in the ILT and compute
 133     // the function start address from the instruction offset.
 134     const unsigned char* offset = opcode + 1;
 135     const unsigned char* next_instruction = opcode + 5;
 136     return next_instruction +
 137         static_cast<int64>(*reinterpret_cast<const int32*>(offset));
 138   }
 139 #endif
 140   return function_address;
 141 }
 142
 143 // Searches through the frames in |sample|, returning an iterator to the first
 144 // frame that has an instruction pointer between |function_address| and
 145 // |function_address| + |size|. Returns sample.end() if no such frames are
 146 // found.
 147 Sample::const_iterator FindFirstFrameWithinFunction(
 148     const Sample& sample,
 149     const void* function_address,
 150     int function_size) {
 151   function_address = MaybeFixupFunctionAddressForILT(function_address);
 152   for (auto it = sample.begin(); it != sample.end(); ++it) {
 153     if ((reinterpret_cast<const unsigned char*>(it->instruction_pointer) >=
 154          reinterpret_cast<const unsigned char*>(function_address)) &&
 155         (reinterpret_cast<const unsigned char*>(it->instruction_pointer) <
 156          (reinterpret_cast<const unsigned char*>(function_address) +
 157           function_size)))
 158       return it;
 159   }
 160   return sample.end();
 161 }
 162
 163 // Formats a sample into a string that can be output for test diagnostics.
 164 std::string FormatSampleForDiagnosticOutput(
 165     const Sample& sample,
 166     const std::vector<Module>& modules) {
 167   std::ostringstream stream;
 168   for (const Frame& frame: sample) {
 169     stream << frame.instruction_pointer << " "
 170            << modules[frame.module_index].filename.value() << std::endl;
 171   }
 172   return stream.str();
 173 }
 174
 175 // Returns a duration that is longer than the test timeout. We would use
 176 // TimeDelta::Max() but https://crbug.com/465948.
 177 TimeDelta AVeryLongTimeDelta() { return TimeDelta::FromDays(1); }
 178 }  // namespace
 179
 180
 181 // The tests below are enabled for Win x64 only, pending implementation of the
 182 // tested functionality on other platforms/architectures.
 183
 184 // Checks that the basic expected information is present in a sampled profile.
 185 #if defined(_WIN64)
 186 #define MAYBE_Basic Basic
 187 #else
 188 #define MAYBE_Basic DISABLED_Basic
 189 #endif
 190 TEST(StackSamplingProfilerTest, MAYBE_Basic) {
 191   StackSamplingProfiler::SamplingParams params;
 192   params.initial_delay = params.burst_interval = params.sampling_interval =
 193       TimeDelta::FromMilliseconds(0);
 194   params.bursts = 1;
 195   params.samples_per_burst = 1;
 196
 197   std::vector<Profile> profiles;
 198   CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
 199
 200   // Check that the profile and samples sizes are correct, and the module
 201   // indices are in range.
 202
 203   ASSERT_EQ(1u, profiles.size());
 204   const Profile& profile = profiles[0];
 205   ASSERT_EQ(1u, profile.samples.size());
 206   EXPECT_EQ(params.sampling_interval, profile.sampling_period);
 207   const Sample& sample = profile.samples[0];
 208   for (const auto& frame : sample) {
 209     ASSERT_GE(frame.module_index, 0);
 210     ASSERT_LT(frame.module_index, static_cast<int>(profile.modules.size()));
 211   }
 212
 213   // Check that the stack contains a frame for
 214   // TargetThread::SignalAndWaitUntilSignaled() and that the frame has this
 215   // executable's module.
 216
 217   // Since we don't have a good way to know the function size, use 100 bytes as
 218   // a reasonable window to locate the instruction pointer.
 219   Sample::const_iterator loc = FindFirstFrameWithinFunction(
 220       sample,
 221       reinterpret_cast<const void*>(&TargetThread::SignalAndWaitUntilSignaled),
 222       100);
 223   ASSERT_TRUE(loc != sample.end())
 224       << "Function at "
 225       << MaybeFixupFunctionAddressForILT(
 226           reinterpret_cast<const void*>(
 227               &TargetThread::SignalAndWaitUntilSignaled))
 228       << " was not found in stack:" << std::endl
 229       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 230
 231   FilePath executable_path;
 232   bool got_executable_path = PathService::Get(FILE_EXE, &executable_path);
 233   EXPECT_TRUE(got_executable_path);
 234   EXPECT_EQ(executable_path, profile.modules[loc->module_index].filename);
 235 }
 236
 237 // Checks that the expected number of profiles and samples are present in the
 238 // profiles produced.
 239 #if defined(_WIN64)
 240 #define MAYBE_MultipleProfilesAndSamples MultipleProfilesAndSamples
 241 #else
 242 #define MAYBE_MultipleProfilesAndSamples DISABLED_MultipleProfilesAndSamples
 243 #endif
 244 TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
 245   StackSamplingProfiler::SamplingParams params;
 246   params.initial_delay = params.burst_interval = params.sampling_interval =
 247       TimeDelta::FromMilliseconds(0);
 248   params.bursts = 2;
 249   params.samples_per_burst = 3;
 250
 251   std::vector<Profile> profiles;
 252   CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
 253
 254   ASSERT_EQ(2u, profiles.size());
 255   EXPECT_EQ(3u, profiles[0].samples.size());
 256   EXPECT_EQ(3u, profiles[1].samples.size());
 257 }
 258
 259 // Checks that no profiles are captured if the profiling is stopped during the
 260 // initial delay.
 261 #if defined(_WIN64)
 262 #define MAYBE_StopDuringInitialDelay StopDuringInitialDelay
 263 #else
 264 #define MAYBE_StopDuringInitialDelay DISABLED_StopDuringInitialDelay
 265 #endif
 266 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
 267   StackSamplingProfiler::SamplingParams params;
 268   params.burst_interval = params.sampling_interval =
 269       TimeDelta::FromMilliseconds(0);
 270   params.initial_delay = TimeDelta::FromSeconds(60);
 271   params.bursts = params.samples_per_burst = 1;
 272
 273   std::vector<Profile> profiles;
 274   CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(0));
 275
 276   EXPECT_TRUE(profiles.empty());
 277 }
 278
 279 // Checks that the single completed profile is captured if the profiling is
 280 // stopped between bursts.
 281 #if defined(_WIN64)
 282 #define MAYBE_StopDuringInterBurstInterval StopDuringInterBurstInterval
 283 #else
 284 #define MAYBE_StopDuringInterBurstInterval DISABLED_StopDuringInterBurstInterval
 285 #endif
 286 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
 287   StackSamplingProfiler::SamplingParams params;
 288   params.initial_delay = params.sampling_interval =
 289       TimeDelta::FromMilliseconds(0);
 290   params.burst_interval = TimeDelta::FromSeconds(60);
 291   params.bursts = 2;
 292   params.samples_per_burst = 1;
 293
 294   std::vector<Profile> profiles;
 295   CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
 296
 297   ASSERT_EQ(1u, profiles.size());
 298   EXPECT_EQ(1u, profiles[0].samples.size());
 299 }
 300
 301 // Checks that only completed profiles are captured.
 302 #if defined(_WIN64)
 303 #define MAYBE_StopDuringInterSampleInterval StopDuringInterSampleInterval
 304 #else
 305 #define MAYBE_StopDuringInterSampleInterval \
 306   DISABLED_StopDuringInterSampleInterval
 307 #endif
 308 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
 309   StackSamplingProfiler::SamplingParams params;
 310   params.initial_delay = params.burst_interval = TimeDelta::FromMilliseconds(0);
 311   params.sampling_interval = TimeDelta::FromSeconds(60);
 312   params.bursts = 1;
 313   params.samples_per_burst = 2;
 314
 315   std::vector<Profile> profiles;
 316   CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
 317
 318   EXPECT_TRUE(profiles.empty());
 319 }
 320
 321 }  // namespace tracked_objects