Add process lifetime annotations to stack samples.

base/profiler/native_stack_sampler_win.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/native_stack_sampler.h"
 
 #include <objbase.h>
 #include <windows.h>
 #include <stddef.h>
 #include <winternl.h>
 
 #include <cstdlib>
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/profiler/win32_stack_frame_unwinder.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
@@ skipping 284 matching lines @@
 // IMPORTANT NOTE: No allocations from the default heap may occur in the
 // ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
 // other logging statements. Otherwise this code can deadlock on heap locks in
 // the default heap acquired by the target thread before it was suspended.
 void SuspendThreadAndRecordStack(
     HANDLE thread_handle,
     const void* base_address,
     void* stack_copy_buffer,
     size_t stack_copy_buffer_size,
     std::vector<RecordedFrame>* stack,
+    Closure annotator,
     NativeStackSamplerTestDelegate* test_delegate) {
   DCHECK(stack->empty());
 
   CONTEXT thread_context = {0};
   thread_context.ContextFlags = CONTEXT_FULL;
   // The stack bounds are saved to uintptr_ts for use outside
   // ScopedSuspendThread, as the thread's memory is not safe to dereference
   // beyond that point.
   const uintptr_t top = reinterpret_cast<uintptr_t>(base_address);
   uintptr_t bottom = 0u;
@@ skipping 14 matching lines @@
 
     if ((top - bottom) > stack_copy_buffer_size)
       return;
 
     // Dereferencing a pointer in the guard page in a thread that doesn't own
     // the stack results in a STATUS_GUARD_PAGE_VIOLATION exception and a crash.
     // This occurs very rarely, but reliably over the population.
     if (PointsToGuardPage(bottom))
       return;
 
+    annotator.Run();

[Mike Wittman, 2016/10/26 16:28:17]

Invoking Callback::Run while the thread is suspended is risky. If the
implementation of Run ever allocates memory, including indirectly via things
like LOG/CHECK/DCHECK, it risks deadlock. I don't know if this is the case now,
but even if not, we shouldn't depend on it for correctness.

I suggest passing a raw function pointer instead. Something like:

using GetAnnotationCallback = void(*)(uint32_t*, uint32_t*);

...

uint32_t phases = 0
uint32_t activities = 0;
get_annotation(&phases, &activities);

...

RecordStack(&thread_context, stack, phases, activities);

[bcwhite, 2016/10/26 18:30:43]

Good point.  We can document this code to say what isn't allowed but we can't
control what the intermediate code may do.

This section of the code doesn't know anything about the Sample instance which
is where those annotations are recorded.  I could pass it and use that as the
parameter to the function-pointer so the called function knows where to write
the fields.  But...

Right now the context is global so if we're not using official "callback"
objects and have to pass in an opaque "sample" pointer just for a parameter to
the function pointer, then we might as well skip the function pointer altogether
and just call the static method.

  StackSamplingProfiler::RecordAnnotations(sample);

[Mike Wittman, 2016/10/26 19:41:14]

That would work, but it would couple the implementation of this class and
StackSamplingProfiler, which I'd rather not do. That would make it difficult to
test this class in isolation, and we may want to do that as we add more
complexity to StackSamplingProfiler.

If the callback is solely responsible for returning the current phases and
activities, rather than copying them to the Sample, then two values could be
recorded here and threaded through to CopyToSample, which could assign them to
the Sample. In that case there would be no need to pass a Sample pointer.

[bcwhite, 2016/10/26 20:02:10]

It might be possible to just make it testable via static methods on the
StackSamplingProfiler... but global state could be a problem if tests were to
run in parallel.  <sigh>  Okay, scratch that idea.
Yes, but I don't think that's a good idea.  I think annotations should be solely
the domain of the StackSamplingProfiler; we should avoid having the Native part
know anything about them.  We don't want future changes to in the former to
require changes to the latter.  Thus, an opaque sample* seems the best way to
me.

[Mike Wittman, 2016/10/26 20:20:36]

That's reasonable, although I feel like this may be less of a concern once the
details of the phases and activity state are moved to components/metrics and the
StackSamplingProfiler is no longer dealing with them. Perhaps it's worth leaving
this question until then.

I guess another option would be to treat the entire annotation state as an
opaque blob of bits (e.g. std::bitset<64>) at the Native level, where it just
knows how to copy the bits around, and the interpretation of the bits is done at
a higher level.

+
     std::memcpy(stack_copy_buffer, reinterpret_cast<const void*>(bottom),
                 top - bottom);
   }
 
   if (test_delegate)
     test_delegate->OnPreStackWalk();
 
   RewritePointersToStackMemory(top, bottom, &thread_context, stack_copy_buffer);
 
   RecordStack(&thread_context, stack);
 }
 
 // NativeStackSamplerWin ------------------------------------------------------
 
 class NativeStackSamplerWin : public NativeStackSampler {
  public:
   NativeStackSamplerWin(win::ScopedHandle thread_handle,
+                        StackSamplingProfiler::AnnotateCallback annotator,
                         NativeStackSamplerTestDelegate* test_delegate);
   ~NativeStackSamplerWin() override;
 
   // StackSamplingProfiler::NativeStackSampler:
   void ProfileRecordingStarting(
       std::vector<StackSamplingProfiler::Module>* modules) override;
   void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
   void ProfileRecordingStopped() override;
 
  private:
@@ skipping 18 matching lines @@
   size_t GetModuleIndex(HMODULE module_handle,
                         std::vector<StackSamplingProfiler::Module>* modules);
 
   // Copies the information represented by |stack| into |sample| and |modules|.
   void CopyToSample(const std::vector<RecordedFrame>& stack,
                     StackSamplingProfiler::Sample* sample,
                     std::vector<StackSamplingProfiler::Module>* modules);
 
   win::ScopedHandle thread_handle_;
 
+  StackSamplingProfiler::AnnotateCallback annotator_;
+
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   // The stack base address corresponding to |thread_handle_|.
   const void* const thread_stack_base_address_;
 
   // Buffer to use for copies of the stack. We use the same buffer for all the
   // samples to avoid the overhead of multiple allocations and frees.
   const std::unique_ptr<unsigned char[]> stack_copy_buffer_;
 
   // Weak. Points to the modules associated with the profile being recorded
   // between ProfileRecordingStarting() and ProfileRecordingStopped().
   std::vector<StackSamplingProfiler::Module>* current_modules_;
 
   // Maps a module handle to the corresponding Module's index within
   // current_modules_.
   std::map<HMODULE, size_t> profile_module_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin);
 };
 
 NativeStackSamplerWin::NativeStackSamplerWin(
     win::ScopedHandle thread_handle,
+    StackSamplingProfiler::AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate)
-    : thread_handle_(thread_handle.Take()), test_delegate_(test_delegate),
+    : thread_handle_(thread_handle.Take()),
+      annotator_(annotator),
+      test_delegate_(test_delegate),
       thread_stack_base_address_(
           GetThreadEnvironmentBlock(thread_handle_.Get())->Tib.StackBase),
       stack_copy_buffer_(new unsigned char[kStackCopyBufferSize]) {
 }
 
 NativeStackSamplerWin::~NativeStackSamplerWin() {
 }
 
 void NativeStackSamplerWin::ProfileRecordingStarting(
     std::vector<StackSamplingProfiler::Module>* modules) {
   current_modules_ = modules;
   profile_module_index_.clear();
 }
 
 void NativeStackSamplerWin::RecordStackSample(
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
   if (!stack_copy_buffer_)
     return;
 
   std::vector<RecordedFrame> stack;
   SuspendThreadAndRecordStack(thread_handle_.Get(), thread_stack_base_address_,
                               stack_copy_buffer_.get(), kStackCopyBufferSize,
-                              &stack, test_delegate_);
+                              &stack, Bind(annotator_, sample), test_delegate_);
   CopyToSample(stack, sample, current_modules_);
 }
 
 void NativeStackSamplerWin::ProfileRecordingStopped() {
   current_modules_ = nullptr;
 }
 
 // static
 bool NativeStackSamplerWin::GetModuleForHandle(
     HMODULE module_handle,
@@ skipping 31 matching lines @@
         module_handle, modules->size() - 1)).first;
   }
 
   return loc->second;
 }
 
 void NativeStackSamplerWin::CopyToSample(
     const std::vector<RecordedFrame>& stack,
     StackSamplingProfiler::Sample* sample,
     std::vector<StackSamplingProfiler::Module>* modules) {
-  sample->clear();
-  sample->reserve(stack.size());
+  sample->frames.clear();
+  sample->frames.reserve(stack.size());
 
   for (const RecordedFrame& frame : stack) {
-    sample->push_back(StackSamplingProfiler::Frame(
+    sample->frames.push_back(StackSamplingProfiler::Frame(
         reinterpret_cast<uintptr_t>(frame.instruction_pointer),
         GetModuleIndex(frame.module.Get(), modules)));
   }
 }
 
 }  // namespace
 
 std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
     PlatformThreadId thread_id,
+    StackSamplingProfiler::AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate) {
 #if _WIN64
   // Get the thread's handle.
   HANDLE thread_handle = ::OpenThread(
       THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
       FALSE,
       thread_id);
 
   if (thread_handle) {
     return std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
-        win::ScopedHandle(thread_handle), test_delegate));
+        win::ScopedHandle(thread_handle), annotator, test_delegate));
   }
 #endif
   return std::unique_ptr<NativeStackSampler>();
 }
 
 }  // namespace base