Statistical stack profiler for Windows x64

base/profiler/stack_sampling_profiler_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/stack_sampling_profiler.h"
+
+#include <dbghelp.h>
+#include <map>
+#include <utility>
+#include <windows.h>
+
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "base/win/pe_image.h"
+#include "base/win/scoped_handle.h"
+
+namespace base {
+
+namespace {
+
+class NativeStackSamplerWin : public StackSamplingProfiler::NativeStackSampler {
+ public:
+  NativeStackSamplerWin(win::ScopedHandle thread_handle);

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

explicit

[Mike Wittman, 2015/03/17 19:07:38]

Done.

+  ~NativeStackSamplerWin() override;
+
+  void ProfileRecordingStarting(

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Add a comment:

// StackSamplingProfiler::NativeStackSampler:

before this block

[Mike Wittman, 2015/03/17 19:07:38]

Done.

+      StackSamplingProfiler::Profile* profile) override;
+  void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
+  void ProfileRecordingStopped() override;
+
+ private:
+  static bool GetModuleInfo(HMODULE module,
+                            StackSamplingProfiler::Module* module_info);
+
+  void CopyToSample(const void* const instruction_pointers[],
+                    const HMODULE modules[], int stack_depth,
+                    StackSamplingProfiler::Sample* sample,
+                    std::vector<StackSamplingProfiler::Module>* module_infos);
+
+  win::ScopedHandle thread_handle_;
+  StackSamplingProfiler::Profile* current_profile_;

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Please add comments. What's the ownership of this?

[Mike Wittman, 2015/03/17 19:07:38]

Done.

+  std::map<HMODULE, int> profile_module_index_;

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Please add comments, what's this mapping to?

[Mike Wittman, 2015/03/17 19:07:38]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin);
+};
+
+
+// Walk the stack represented by |context| from the current frame downwards,
+// recording the instruction pointers for each frame in |instruction_pointers|.
+int RecordStack(CONTEXT* context, int max_stack_size,
+                const void* instruction_pointers[],
+                bool* last_frame_is_unknown_function) {
+#ifdef _WIN64
+  *last_frame_is_unknown_function = false;
+
+  IMAGEHLP_SYMBOL64 sym;
+  sym.SizeOfStruct  = sizeof(sym);
+  sym.MaxNameLength = 0;
+
+  for (int i = 0; i < max_stack_size; ++i) {
+    // Try to look up unwind metadata for the current function.
+    ULONG64 image_base;
+    PRUNTIME_FUNCTION runtime_function =
+        RtlLookupFunctionEntry(context->Rip, &image_base, nullptr);
+
+    instruction_pointers[i] = reinterpret_cast<void*>(context->Rip);
+
+    if (runtime_function) {
+      KNONVOLATILE_CONTEXT_POINTERS nvcontext = {0};
+      void* handler_data;
+      ULONG64 establisher_frame;
+      RtlVirtualUnwind(0, image_base, context->Rip, runtime_function, context,
+          &handler_data, &establisher_frame, &nvcontext);
+    } else {
+      // If we don't have a RUNTIME_FUNCTION, then we've encountered
+      // a leaf function.  Adjust the stack appropriately.
+      context->Rip = *reinterpret_cast<PDWORD64>(context->Rsp);
+      context->Rsp += 8;
+      *last_frame_is_unknown_function = true;
+    }
+
+    if (!context->Rip)
+      return i;
+  }
+  return max_stack_size;
+#else
+  return 0;
+#endif
+}
+
+// Fills in |modules| corresponding to the pointers to code in |addresses|.
+void FindModulesForAddresses(const void* const addresses[], HMODULE modules[],
+                             int stack_depth,
+                             bool last_frame_is_unknown_function) {
+  const int module_frames = last_frame_is_unknown_function ? stack_depth - 1 :
+      stack_depth;
+  for (int i = 0; i < module_frames; ++i) {
+    HMODULE module = NULL;
+    if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+                          GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+                          reinterpret_cast<LPCTSTR>(addresses[i]),
+                          &module)) {
+      // HMODULE is the base address of the module.
+      DCHECK_LT(reinterpret_cast<const void*>(module), addresses[i]);
+      modules[i] = module;
+    }
+  }
+  for (int i = module_frames; i < stack_depth; ++i)
+    modules[stack_depth - 1] = NULL;
+}
+
+// Suspends the thread with |thread_handle|, records the stack into
+// |instruction_pointers| and the corresponding modules into |modules|, then
+// resumes the thread. Returns the size of the stack.
+int SuspendThreadAndRecordStack(HANDLE thread_handle, int max_stack_size,
+                                const void* instruction_pointers[],
+                                HMODULE modules[]) {
+  if (::SuspendThread(thread_handle) == -1) {
+    LOG(ERROR) << "SuspendThread failed: " << GetLastError();
+    return 0;
+  }
+
+  CONTEXT thread_context = {0};
+  thread_context.ContextFlags = CONTEXT_ALL;
+  if (!::GetThreadContext(thread_handle, &thread_context)) {
+    LOG(ERROR) << "GetThreadContext failed: " << GetLastError();
+  }
+
+  bool last_frame_is_unknown_function = false;
+  int stack_depth = RecordStack(&thread_context, max_stack_size,
+                                instruction_pointers,
+                                &last_frame_is_unknown_function);
+
+  if (::ResumeThread(thread_handle) == -1)
+    LOG(ERROR) << "ResumeThread failed: " << GetLastError();
+
+  FindModulesForAddresses(instruction_pointers, modules, stack_depth,
+                          last_frame_is_unknown_function);
+
+  return stack_depth;
+}
+
+}

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Nit: // namespace base

[Mike Wittman, 2015/03/17 19:07:38]

Done. (This is end of the anonymous namespace.)

+
+scoped_ptr<StackSamplingProfiler::NativeStackSampler>
+    StackSamplingProfiler::NativeStackSampler::Create(
+        PlatformThreadId thread_id) {
+#if _WIN64
+  // Get the thread's handle.
+  HANDLE thread_handle = ::OpenThread(THREAD_ALL_ACCESS, FALSE, thread_id);
+  DCHECK(thread_handle) << "OpenThread failed";
+
+  return scoped_ptr<NativeStackSampler>(new NativeStackSamplerWin(
+      win::ScopedHandle(thread_handle)));
+#else
+  return scoped_ptr<NativeStackSampler>();
+#endif
+}
+
+NativeStackSamplerWin::NativeStackSamplerWin(win::ScopedHandle thread_handle)
+    : thread_handle_(thread_handle.Take()) {
+#ifdef _WIN64
+  if (RtlVirtualUnwind == nullptr && RtlLookupFunctionEntry == nullptr) {
+    const HMODULE nt_dll_handle = ::GetModuleHandle(L"ntdll.dll");
+    reinterpret_cast<void*&>(RtlVirtualUnwind) =
+        ::GetProcAddress(nt_dll_handle, "RtlVirtualUnwind");
+    reinterpret_cast<void*&>(RtlLookupFunctionEntry) =
+        ::GetProcAddress(nt_dll_handle, "RtlLookupFunctionEntry");
+  }
+#endif
+}
+
+NativeStackSamplerWin::~NativeStackSamplerWin() {
+}
+
+void NativeStackSamplerWin::ProfileRecordingStarting(
+    StackSamplingProfiler::Profile* profile) {
+  current_profile_ = profile;
+  profile_module_index_.clear();
+}
+
+void NativeStackSamplerWin::RecordStackSample(
+    StackSamplingProfiler::Sample* sample) {
+  DCHECK(current_profile_);
+
+  const int max_stack_size = 64;
+  const void* instruction_pointers[max_stack_size];
+  HMODULE modules[max_stack_size];
+
+  int stack_depth = SuspendThreadAndRecordStack(
+      thread_handle_.Get(), max_stack_size, instruction_pointers, modules);
+  CopyToSample(instruction_pointers, modules, stack_depth, sample,
+               &current_profile_->modules);
+}
+
+void NativeStackSamplerWin::ProfileRecordingStopped() {
+  current_profile_ = nullptr;
+}
+
+// static
+bool NativeStackSamplerWin::GetModuleInfo(
+    HMODULE module, StackSamplingProfiler::Module* module_info) {
+  wchar_t module_name[MAX_PATH];
+  DWORD result_length =
+      GetModuleFileName(module, module_name, arraysize(module_name));
+  if (result_length == 0)
+    return false;
+
+  module_info->filename = base::FilePath(module_name);
+
+  module_info->base_address = reinterpret_cast<const void*>(module);
+
+  GUID guid;
+  DWORD age;
+  win::PEImage(module).GetDebugId(&guid, &age);
+  module_info->id.insert(module_info->id.end(),
+                         reinterpret_cast<char*>(&guid),
+                         reinterpret_cast<char*>(&guid + 1));
+  module_info->id.insert(module_info->id.end(),
+                         reinterpret_cast<char*>(&age),
+                         reinterpret_cast<char*>(&age + 1));
+
+  return true;
+}
+
+void NativeStackSamplerWin::CopyToSample(
+    const void* const instruction_pointers[], const HMODULE modules[],

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Nit: 1 param per line, when first param is on a separate line in decl. Maybe run
"git cl format"? (assuming it works on Windows)

[Mike Wittman, 2015/03/17 19:07:38]

Done.

+    int stack_depth, StackSamplingProfiler::Sample* sample,
+    std::vector<StackSamplingProfiler::Module>* module_infos) {
+  sample->clear();
+  sample->reserve(stack_depth);
+
+  for (int i = 0; i < stack_depth; ++i) {
+    sample->push_back(StackSamplingProfiler::Frame());
+    StackSamplingProfiler::Frame& frame = sample->back();

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Non-const refs are discouraged. Use a pointer. Or, put it on the stack and push
back at the end of the function.

[Mike Wittman, 2015/03/17 19:07:38]

They are for function parameters, but aliases are a different matter. The Google
C++ Style Guide explicitly recommends this type of usage: "Instead of using a
macro to "abbreviate" a long variable name, use a reference."

It also appears to be not uncommon in the Chrome codebase.

+
+    if (!modules[i])

[Alexei Svitkine (slow), 2015/03/17 13:10:00]

Is it correct to have an entry in |sample| in this case?

[Mike Wittman, 2015/03/17 19:07:38]

Yes. In this case, we saw a frame on the stack but don't know what module it was
from. An empty Frame is the best representation of this state.

Frame's contents weren't being initialized though, so I added a default
constructor. Also added a clarifying comment here.

[Mike Wittman, 2015/03/18 19:17:22]

On second thought, storing the instruction pointer is still useful in this case.
It's only at the UMA level that we need to provide an empty frame since we can't
compute a valid instruction pointer offset.

+      continue;
+
+    auto loc = profile_module_index_.find(modules[i]);
+    if (loc == profile_module_index_.end()) {
+      StackSamplingProfiler::Module module_info;
+      if (!GetModuleInfo(modules[i], &module_info))
+        continue;
+      module_infos->push_back(module_info);
+      loc = profile_module_index_.insert(std::make_pair(
+          modules[i], static_cast<int>(module_infos->size() - 1))).first;
+    }
+
+    frame.module_index = loc->second;
+    frame.instruction_pointer = instruction_pointers[i];
+  }
+}
+
+}  // namespace base