[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_allocation_context_tracker.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/trace_event/heap_profiler_allocation_context_tracker.h"
 
 #include <algorithm>
 #include <iterator>
 
+#include "base/allocator/features.h"
 #include "base/atomicops.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 
 namespace base {
 namespace trace_event {
 
-subtle::Atomic32 AllocationContextTracker::capture_enabled_ = 0;
+subtle::Atomic32 AllocationContextTracker::capture_mode_ =
+    AllocationContextTracker::DONT_CAPTURE;
 
 namespace {
 
 const size_t kMaxStackDepth = 128u;
 const size_t kMaxTaskDepth = 16u;
 AllocationContextTracker* const kInitializingSentinel =
     reinterpret_cast<AllocationContextTracker*>(-1);
 
 ThreadLocalStorage::StaticSlot g_tls_alloc_ctx_tracker = TLS_INITIALIZER;
 
 // This function is added to the TLS slot to clean up the instance when the
 // thread exits.
 void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
   delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
 }
 
+// Walks stack frames and collects a trace. Unlike base::debug::StackTrace
+// (which uses unwinding) this function uses frame pointers and is fast.
+// However, by default frame pointers are not enabled in optimized builds
+// unless -fno-omit-frame-pointer flag is specified.
+// Adapted from TCMalloc's stacktrace_x86-inl.h
+size_t WalkStackFrames(const void** trace,
+                       size_t max_depth,
+                       size_t skip_count) {
+  uintptr_t sp = reinterpret_cast<uintptr_t>(

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

Should this have a 
#if !BUILDFLAG(ENABLE_PROFILING) || defined(NDEBUG)
NOTREACHED()
return 0;
#endif

to avoid end up using this when we shouldn't?

+      __builtin_frame_address(0));
+
+  size_t n = 0;
+  while (sp && n < max_depth) {
+    if (reinterpret_cast<void**>(sp)[1] == nullptr) {
+      // In 64-bit code, we often see a frame that
+      // points to itself and has a return address of 0.
+      break;
+    }
+
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      trace[n] = reinterpret_cast<void**>(sp)[1];
+      n++;
+    }
+
+    {
+      uintptr_t next_sp = reinterpret_cast<uintptr_t*>(sp)[0];
+
+      // With the stack growing downwards, older stack frame must be
+      // at a greater address that the current one.
+      if (next_sp <= sp) break;
+
+      // Assume stack frames larger than 100,000 bytes are bogus.
+      if (next_sp - sp > 100000) break;
+
+      // Check alignment.
+      if (next_sp & (sizeof(void*) - 1)) break;
+
+#ifdef __i386__
+      // On 64-bit machines, the stack pointer can be very close to
+      // 0xffffffff, so we explicitly check for a pointer into the
+      // last two pages in the address space
+      if (next_sp >= 0xffffe000) break;
+#endif
+
+      sp = next_sp;
+    }
+  }
+
+  return n;
+}
+
 }  // namespace
 
 // static
 AllocationContextTracker*
 AllocationContextTracker::GetInstanceForCurrentThread() {
   AllocationContextTracker* tracker =
       static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
   if (tracker == kInitializingSentinel)
     return nullptr;  // Re-entrancy case.
 
@@ skipping 13 matching lines @@
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
 void AllocationContextTracker::SetCurrentThreadName(const char* name) {
   if (name && capture_enabled()) {
     GetInstanceForCurrentThread()->thread_name_ = name;
   }
 }
 
 // static
-void AllocationContextTracker::SetCaptureEnabled(bool enabled) {
+void AllocationContextTracker::SetCaptureMode(CaptureMode mode) {
   // When enabling capturing, also initialize the TLS slot. This does not create
   // a TLS instance yet.
-  if (enabled && !g_tls_alloc_ctx_tracker.initialized())
+  if (mode != DONT_CAPTURE && !g_tls_alloc_ctx_tracker.initialized())
     g_tls_alloc_ctx_tracker.Initialize(DestructAllocationContextTracker);
 
-  // Release ordering ensures that when a thread observes |capture_enabled_| to
+  // Release ordering ensures that when a thread observes |capture_mode_| to
   // be true through an acquire load, the TLS slot has been initialized.
-  subtle::Release_Store(&capture_enabled_, enabled);
+  subtle::Release_Store(&capture_mode_, mode);
+}
+
+void AllocationContextTracker::PushPseudoStackFrame(const char* frame_value) {
+  PushPseudoStackFrame(StackFrame::FromSymbol(frame_value));
 }
 
 void AllocationContextTracker::PushPseudoStackFrame(StackFrame frame) {
   // Impose a limit on the height to verify that every push is popped, because
   // in practice the pseudo stack never grows higher than ~20 frames.
   if (pseudo_stack_.size() < kMaxStackDepth)
     pseudo_stack_.push_back(frame);
   else
     NOTREACHED();
 }
 
-// static
-void AllocationContextTracker::PopPseudoStackFrame(StackFrame frame) {
+void AllocationContextTracker::PopPseudoStackFrame(const void* frame_value) {
   // Guard for stack underflow. If tracing was started with a TRACE_EVENT in
   // scope, the frame was never pushed, so it is possible that pop is called
   // on an empty stack.
   if (pseudo_stack_.empty())
     return;
 
   // Assert that pushes and pops are nested correctly. This DCHECK can be
   // hit if some TRACE_EVENT macro is unbalanced (a TRACE_EVENT_END* call
   // without a corresponding TRACE_EVENT_BEGIN).
-  DCHECK_EQ(frame, pseudo_stack_.back())
+  DCHECK_EQ(frame_value, pseudo_stack_.back().value)
       << "Encountered an unmatched TRACE_EVENT_END";
 
   pseudo_stack_.pop_back();
 }
 
 void AllocationContextTracker::PushCurrentTaskContext(const char* context) {
   DCHECK(context);
   if (task_contexts_.size() < kMaxTaskDepth)
     task_contexts_.push_back(context);
   else
     NOTREACHED();
 }
 
 void AllocationContextTracker::PopCurrentTaskContext(const char* context) {
   DCHECK_EQ(context, task_contexts_.back())
       << "Encountered an unmatched context end";
   task_contexts_.pop_back();
 }
 
-// static
 AllocationContext AllocationContextTracker::GetContextSnapshot() {
   AllocationContext ctx;
 
-  // Fill the backtrace.
-  {
-    auto src = pseudo_stack_.begin();
-    auto dst = std::begin(ctx.backtrace.frames);
-    auto src_end = pseudo_stack_.end();
-    auto dst_end = std::end(ctx.backtrace.frames);
+  CaptureMode mode = static_cast<CaptureMode>(
+      subtle::Acquire_Load(&capture_mode_));

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

We are going to call this on each malloc. I'd keep this a NoBarrier_Load and
don't NOTREACHD() below if DONT_CAPTURE (just return an empty context)

[Dmitry Skiba, 2016/04/12 18:22:11]

Done.

 
-    // Add the thread name as the first enrty in the backtrace.
-    if (thread_name_) {
-      DCHECK(dst < dst_end);
-      *dst = thread_name_;
-      ++dst;
-    }
+  switch (mode) {
+    case DONT_CAPTURE:
+      {
+        NOTREACHED();
+        return AllocationContext::Empty();
+      }
+    case CAPTURE_PSEUDO_STACK:
+      {
+        auto src = pseudo_stack_.begin();

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

I think there is some duplicated logic between this and the next state.
I think you could move up the auto src... auto dst block outside of the switch,
and also do the if(thread_name_) check outside of the switch,
and then just populated the dst pointers in the two cases

[Dmitry Skiba, 2016/04/12 18:22:11]

Done.

+        auto dst = std::begin(ctx.backtrace.frames);
+        auto src_end = pseudo_stack_.end();
+        auto dst_end = std::end(ctx.backtrace.frames);
 
-    // Copy as much of the bottom of the pseudo stack into the backtrace as
-    // possible.
-    for (; src != src_end && dst != dst_end; src++, dst++)
-      *dst = *src;
+        // Add the thread name as the first enrty in the backtrace.
+        if (thread_name_) {
+          DCHECK(dst < dst_end);
+          *dst = StackFrame::FromThreadName(thread_name_);
+          ++dst;
+        }
 
-    // If there is room for more, fill the remaining slots with empty frames.
-    std::fill(dst, dst_end, nullptr);
+        // Copy as much of the bottom of the pseudo stack into the
+        // backtrace as possible.
+        for (; src != src_end && dst != dst_end; src++, dst++)
+          *dst = *src;
+
+        // If there is room for more, fill the remaining slots with
+        // empty frames.
+        std::fill(dst, dst_end, StackFrame::Empty());
+
+        break;
+      }
+    case CAPTURE_NATIVE_STACK:
+      {
+        // WalkStackFrames()
+        // base::trace_event::AllocationContextTracker::GetContextSnapshot()
+        const size_t known_frame_count = 2;
+
+        const size_t max_frame_count = arraysize(ctx.backtrace.frames);
+        const void* frames[max_frame_count];
+        size_t frame_count = WalkStackFrames(frames,
+                                                 max_frame_count,
+                                                 known_frame_count);
+
+        size_t frame_shift = 0;
+        if (thread_name_) {
+          ctx.backtrace.frames[frame_shift++] =
+              StackFrame::FromThreadName(thread_name_);
+        }
+
+        if (frame_count + frame_shift > max_frame_count) {
+          frame_count = max_frame_count - frame_shift;
+        }
+
+        // Copy frames backwards
+        for (size_t i = 0; i != frame_count; ++i) {
+          ctx.backtrace.frames[i + frame_shift] =
+              StackFrame::FromPC(frames[frame_count - 1 - i]);
+        }
+
+        // Fill remainder with empty frames
+        std::fill(ctx.backtrace.frames + frame_shift + frame_count,
+                  ctx.backtrace.frames + max_frame_count,
+                  StackFrame::Empty());
+        break;
+      }
   }
 
   // TODO(ssid): Fix crbug.com/594803 to add file name as 3rd dimension
   // (component name) in the heap profiler and not piggy back on the type name.
   ctx.type_name = task_contexts_.empty() ? nullptr : task_contexts_.back();
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base