[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_ =
+    static_cast<int32_t>(AllocationContextTracker::CaptureMode::DISABLED);
 
 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;
 
@@ skipping 23 matching lines @@
 }
 
 AllocationContextTracker::AllocationContextTracker() : thread_name_(nullptr) {
   pseudo_stack_.reserve(kMaxStackDepth);
   task_contexts_.reserve(kMaxTaskDepth);
 }
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
 void AllocationContextTracker::SetCurrentThreadName(const char* name) {
-  if (name && capture_enabled()) {
+  if (name && capture_mode() != CaptureMode::DISABLED) {
     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 != CaptureMode::DISABLED && !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_, static_cast<int32_t>(mode));
 }
 
 void AllocationContextTracker::PushPseudoStackFrame(
     const char* trace_event_name) {
   // 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(trace_event_name);
   else
     NOTREACHED();
@@ skipping 23 matching lines @@
   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 backtrace = std::begin(ctx.backtrace.frames);
-    auto backtrace_end = std::end(ctx.backtrace.frames);
+  CaptureMode mode = static_cast<CaptureMode>(
+      subtle::NoBarrier_Load(&capture_mode_));
 
-    // Add the thread name as the first entry
-    if (thread_name_) {
-      *backtrace++ = StackFrame::FromThreadName(thread_name_);
-    }
+  auto backtrace = std::begin(ctx.backtrace.frames);
+  auto backtrace_end = std::end(ctx.backtrace.frames);
 
-    for (const auto& event_name: pseudo_stack_) {
-      if (backtrace == backtrace_end) {
+  // Add the thread name as the first entry
+  if (thread_name_) {
+    *backtrace++ = StackFrame::FromThreadName(thread_name_);
+  }
+
+  switch (mode) {
+    case CaptureMode::DISABLED:
+      {
         break;
       }
-      *backtrace++ = StackFrame::FromTraceEventName(event_name);
-    }
+    case CaptureMode::PSEUDO_STACK:
+      {
+        for (const auto& event_name: pseudo_stack_) {
+          if (backtrace == backtrace_end) {
+            break;
+          }
+          *backtrace++ = StackFrame::FromTraceEventName(event_name);
+        }
+        break;
+      }
+#if ENABLE_NATIVE_ALLOCATION_TRACES
+    case CaptureMode::NATIVE_STACK:
+      {
+        // base::trace_event::AllocationContextTracker::GetContextSnapshot()
+        const size_t kKnownFrameCount = 1;
 
-    ctx.backtrace.frame_count = backtrace - std::begin(ctx.backtrace.frames);
+        const void* frames[Backtrace::kMaxFrameCount];
+        size_t frame_count = debug::TraceStackFramePointers(
+            frames,
+            backtrace_end - backtrace,

[Primiano Tucci (use gerrit), 2016/04/21 20:08:21]

this will still return only the stack frames closest to malloc() not main right?
if you have main() -> a() -> b() -> c() -> malloc(), and your backtrace size is
3, you will get here [a,b,c], not [main,a,b] right?
Which seems the opposite of what the pseudo stack does.
can we guarantee that we always saturate in the bottom, in other words that
main() is always tehre and eventually lose the frames close to malloc().
In this way the clustering will always work, just lose details.

(or probably I am just reading all this in reverse, in which case, ignore this ,
too late here)

[Dmitry Skiba, 2016/04/22 06:31:15]

No, you are right, I'm returning N bottom frames, and that is different from
what pseudo stack returns. However, I think that this way it's more useful,
because we can see who exactly allocating memory. With just top N frames, in
most cases we won't see the full trace, and won't know exactly who is
responsible. And I think that's the whole goal of native stack tracing. Because
pseudo stack traces already give us high level overview.

[Primiano Tucci (use gerrit), 2016/04/22 09:02:46]

I understand this but I believe that all the clustering logic will be screwed
from this, as it matches frames from top (main) to bottom (malloc).
Which means now that when the heap profiler will tell you that
main->RunLopo->RunTaskFoo used X mb of memory it will be a lie, because will
count separately instances of  RunTaskFoo(), as if they were a different
entrypoint.

Really, if the problem that you have is that 12 is too shallow as a depth just
increase the depth to 24 or whatever. If we start returning lies is the end.

+            kKnownFrameCount);

[Primiano Tucci (use gerrit), 2016/04/21 20:08:21]

you can just s|kKnownFrameCount|1 /* skip_initial */|

+
+        // Copy frames backwards
+        for (ssize_t i = frame_count - 1; i >= 0; --i) {
+          const void* frame = frames[i];
+          *backtrace++ = StackFrame::FromProgramCounter(frame);
+        }
+        break;
+      }
+#endif  // ENABLE_NATIVE_ALLOCATION_TRACES
   }
 
+  ctx.backtrace.frame_count = backtrace - std::begin(ctx.backtrace.frames);
+
   // 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