Add process lifetime annotations to stack samples.

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 <utility>
 
@@ skipping 31 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #pragma intrinsic(_ReturnAddress)
 #endif
 
 namespace base {
 
 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 {
 
 // Configuration for the frames that appear on the stack.
 struct StackConfiguration {
   enum Config { NORMAL, WITH_ALLOCA, WITH_OTHER_LIBRARY };
@@ skipping 327 matching lines @@
         reinterpret_cast<const unsigned char*>(offset + 1);
     return next_instruction + *offset;
   }
 #endif
   return function_address;
 }
 
 // Searches through the frames in |sample|, returning an iterator to the first
 // frame that has an instruction pointer within |target_function|. Returns
 // sample.end() if no such frames are found.
-Sample::const_iterator FindFirstFrameWithinFunction(
+Frames::const_iterator FindFirstFrameWithinFunction(
     const Sample& sample,
     TargetFunction target_function) {
   uintptr_t function_start = reinterpret_cast<uintptr_t>(
       MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
           target_function)));
   uintptr_t function_end =
       reinterpret_cast<uintptr_t>(target_function(nullptr, nullptr, nullptr));
-  for (auto it = sample.begin(); it != sample.end(); ++it) {
+  for (auto it = sample.frames.begin(); it != sample.frames.end(); ++it) {
     if ((it->instruction_pointer >= function_start) &&
         (it->instruction_pointer <= function_end))
       return it;
   }
-  return sample.end();
+  return sample.frames.end();
 }
 
 // Formats a sample into a string that can be output for test diagnostics.
 std::string FormatSampleForDiagnosticOutput(
     const Sample& sample,
     const std::vector<Module>& modules) {
   std::string output;
-  for (const Frame& frame : sample) {
+  for (const Frame& frame : sample.frames) {
     output += StringPrintf(
         "0x%p %s\n", reinterpret_cast<const void*>(frame.instruction_pointer),
         modules[frame.module_index].filename.AsUTF8Unsafe().c_str());
   }
   return output;
 }
 
 // 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); }
@@ skipping 80 matching lines @@
   sampling_thread_completed.Wait();
 
   // Look up the sample.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   const Sample& sample = profile.samples[0];
 
   // Check that the stack contains a frame for
   // TargetThread::SignalAndWaitUntilSignaled().
-  Sample::const_iterator end_frame = FindFirstFrameWithinFunction(
+  Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::SignalAndWaitUntilSignaled);
-  ASSERT_TRUE(end_frame != sample.end())
+  ASSERT_TRUE(end_frame != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
           &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   if (wait_until_unloaded) {
     // The stack should look like this, resulting one frame after
     // SignalAndWaitUntilSignaled. The frame in the now-unloaded library is not
     // recorded since we can't get module information.
     //
     // ... WaitableEvent and system frames ...
     // TargetThread::SignalAndWaitUntilSignaled
     // TargetThread::OtherLibraryCallback
-    EXPECT_EQ(2, sample.end() - end_frame)
+    EXPECT_EQ(2, sample.frames.end() - end_frame)
         << "Stack:\n"
         << FormatSampleForDiagnosticOutput(sample, profile.modules);
   } else {
     // We didn't wait for the asynchonous unloading to complete, so the results
     // are non-deterministic: if the library finished unloading we should have
     // the same stack as |wait_until_unloaded|, if not we should have the full
     // stack. The important thing is that we should not crash.
 
-    if ((sample.end() - 1) - end_frame == 2) {
+    if ((sample.frames.end() - 1) - end_frame == 2) {
       // This is the same case as |wait_until_unloaded|.
       return;
     }
 
     // Check that the stack contains a frame for
     // TargetThread::CallThroughOtherLibrary().
-    Sample::const_iterator other_library_frame = FindFirstFrameWithinFunction(
+    Frames::const_iterator other_library_frame = FindFirstFrameWithinFunction(
         sample,
         &TargetThread::CallThroughOtherLibrary);
-    ASSERT_TRUE(other_library_frame != sample.end())
+    ASSERT_TRUE(other_library_frame != sample.frames.end())
         << "Function at "
         << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
             &TargetThread::CallThroughOtherLibrary))
         << " was not found in stack:\n"
         << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
     // The stack should look like this, resulting in three frames between
     // SignalAndWaitUntilSignaled and CallThroughOtherLibrary:
     //
     // ... WaitableEvent and system frames ...
@@ skipping 10 matching lines @@
 }  // namespace
 
 // Checks that the basic expected information is present in a sampled call stack
 // profile.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Basic Basic
 #else
 #define MAYBE_Basic DISABLED_Basic
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_Basic) {
+  StackSamplingProfiler::ResetPhaseAndActivityForTesting();
+
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
 
   // Check that the profile and samples sizes are correct, and the module
   // indices are in range.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& 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) {
+  EXPECT_EQ(0u, sample.process_phases);
+  EXPECT_EQ(0u, sample.current_activities);
+  for (const auto& frame : sample.frames) {
     ASSERT_GE(frame.module_index, 0u);
     ASSERT_LT(frame.module_index, profile.modules.size());
   }
 
   // Check that the stack contains a frame for
   // TargetThread::SignalAndWaitUntilSignaled() and that the frame has this
   // executable's module.
-  Sample::const_iterator loc = FindFirstFrameWithinFunction(
+  Frames::const_iterator loc = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::SignalAndWaitUntilSignaled);
-  ASSERT_TRUE(loc != sample.end())
+  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);
 }
 
+// Checks that annotations are recorded in samples.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_Annotations Annotations
+#else
+#define MAYBE_Annotations DISABLED_Annotations

[Alexei Svitkine (slow), 2016/11/07 23:22:07]

How about just having the full TEST() {} block inside the ifdef? I'm not sure
what the current structure buys over that.

I think DISABLED_ is usually used when a test that's flaky gets disabled but in
this case we just don't want to ever run it if the ifdef is false.

[bcwhite, 2016/11/08 01:02:36]

I've wondered about that but this seems to be the standard way of defining
"conditional" tests throughout the codebase.

[Mike Wittman, 2016/11/16 22:36:09]

This structure keeps the tests compiling on non-Windows platforms.

+#endif
+TEST(StackSamplingProfilerTest, MAYBE_Annotations) {
+  StackSamplingProfiler::ResetPhaseAndActivityForTesting();
+
+  SamplingParams params;
+  params.sampling_interval = TimeDelta::FromMilliseconds(0);
+  params.samples_per_burst = 1;
+
+  // Check that a run picks up annotations.
+  StackSamplingProfiler::SetProcessPhase(1);
+  StackSamplingProfiler::RecordActivityBegin(11);
+  std::vector<CallStackProfile> profiles1;
+  CaptureProfiles(params, AVeryLongTimeDelta(), &profiles1);
+  ASSERT_EQ(1u, profiles1.size());
+  const CallStackProfile& profile1 = profiles1[0];
+  ASSERT_EQ(1u, profile1.samples.size());
+  EXPECT_EQ(params.sampling_interval, profile1.sampling_period);
+  const Sample& sample1 = profile1.samples[0];
+  EXPECT_EQ(1u << 1, sample1.process_phases);
+  EXPECT_EQ(1u << 11, sample1.current_activities);
+
+  // Run it a second time but with changed annotations. These annotations
+  // should appear in the first acquired sample.
+  StackSamplingProfiler::SetProcessPhase(2);
+  StackSamplingProfiler::RecordActivityBegin(12);
+  StackSamplingProfiler::RecordActivityEnd(11);
+  std::vector<CallStackProfile> profiles2;
+  CaptureProfiles(params, AVeryLongTimeDelta(), &profiles2);
+  ASSERT_EQ(1u, profiles2.size());
+  const CallStackProfile& profile2 = profiles2[0];
+  ASSERT_EQ(1u, profile2.samples.size());
+  const Sample& sample2 = profile2.samples[0];
+  EXPECT_EQ(sample1.process_phases | (1u << 2), sample2.process_phases);
+  EXPECT_EQ(1u << 12, sample2.current_activities);
+}
+
 // Checks that the profiler handles stacks containing dynamically-allocated
 // stack memory.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Alloca Alloca
 #else
 #define MAYBE_Alloca DISABLED_Alloca
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_Alloca) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
@@ skipping 15 matching lines @@
       StackConfiguration(StackConfiguration::WITH_ALLOCA));
 
   // Look up the sample.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   const Sample& sample = profile.samples[0];
 
   // Check that the stack contains a frame for
   // TargetThread::SignalAndWaitUntilSignaled().
-  Sample::const_iterator end_frame = FindFirstFrameWithinFunction(
+  Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::SignalAndWaitUntilSignaled);
-  ASSERT_TRUE(end_frame != sample.end())
+  ASSERT_TRUE(end_frame != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
           &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   // Check that the stack contains a frame for TargetThread::CallWithAlloca().
-  Sample::const_iterator alloca_frame = FindFirstFrameWithinFunction(
+  Frames::const_iterator alloca_frame = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::CallWithAlloca);
-  ASSERT_TRUE(alloca_frame != sample.end())
+  ASSERT_TRUE(alloca_frame != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(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);
@@ skipping 235 matching lines @@
   }
 
   // Look up the sample.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   const Sample& sample = profile.samples[0];
 
   // Check that the stack contains a frame for
   // TargetThread::CallThroughOtherLibrary().
-  Sample::const_iterator other_library_frame = FindFirstFrameWithinFunction(
+  Frames::const_iterator other_library_frame = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::CallThroughOtherLibrary);
-  ASSERT_TRUE(other_library_frame != sample.end())
+  ASSERT_TRUE(other_library_frame != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
           &TargetThread::CallThroughOtherLibrary))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   // Check that the stack contains a frame for
   // TargetThread::SignalAndWaitUntilSignaled().
-  Sample::const_iterator end_frame = FindFirstFrameWithinFunction(
+  Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
       sample,
       &TargetThread::SignalAndWaitUntilSignaled);
-  ASSERT_TRUE(end_frame != sample.end())
+  ASSERT_TRUE(end_frame != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
           &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   // The stack should look like this, resulting in three frames between
   // SignalAndWaitUntilSignaled and CallThroughOtherLibrary:
   //
   // ... WaitableEvent and system frames ...
@@ skipping 21 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