tracing: add dump provider for malloc heap profiler

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/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;
 
 namespace {
 
+const size_t kMaxStackDepth = 128u;
+AllocationContextTracker* const kInitializingSentinel =
+    reinterpret_cast<AllocationContextTracker*>(-1);

[petrcermak, 2016/03/11 11:09:23]

Is this really a safe thing to do? Wouldn't it be better to store an explicit
enum?

[Primiano Tucci (use gerrit), 2016/03/11 13:57:57]

It's extremely unlikely that a pointer would end up @ -1, as that is a
non-aligned address :-)
I can't really put another enum aside, because this is stored in a TLS-slot, and
TLS slots are a scarce resource.

+
 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);
 }
 
 }  // namespace
 
-AllocationContextTracker::AllocationContextTracker() {}
+AllocationContextTracker::AllocationContextTracker() {
+  pseudo_stack_.reserve(kMaxStackDepth);
+}
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
+AllocationContextTracker::InitializationState
+AllocationContextTracker::GetStateForCurrentThread() {
+  auto tracker =
+      static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
+  if (!tracker)
+    return kNotInitialized;
+  if (tracker == kInitializingSentinel)
+    return kInitializing;
+  return kInitialized;
+}
+
+// static
+AllocationContextTracker*
+AllocationContextTracker::InitializeForCurrentThread() {
+  DCHECK_EQ(kNotInitialized, GetStateForCurrentThread());
+  g_tls_alloc_ctx_tracker.Set(kInitializingSentinel);
+  AllocationContextTracker* tracker = new AllocationContextTracker();
+  g_tls_alloc_ctx_tracker.Set(tracker);
+  return tracker;
+}
+
+// static
 AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
   auto tracker =
       static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
-
-  if (!tracker) {
-    tracker = new AllocationContextTracker();
-    g_tls_alloc_ctx_tracker.Set(tracker);
-  }
-
+  DCHECK_NE(kInitializingSentinel, tracker);
+  if (!tracker)
+    tracker = InitializeForCurrentThread();
   return tracker;
 }
 
 // static
 void AllocationContextTracker::SetCaptureEnabled(bool enabled) {
   // When enabling capturing, also initialize the TLS slot. This does not create
   // a TLS instance yet.
   if (enabled && !g_tls_alloc_ctx_tracker.initialized())
     g_tls_alloc_ctx_tracker.Initialize(DestructAllocationContextTracker);
 
   // Release ordering ensures that when a thread observes |capture_enabled_| to
   // be true through an acquire load, the TLS slot has been initialized.
   subtle::Release_Store(&capture_enabled_, enabled);
 }
 
 // static
 void AllocationContextTracker::PushPseudoStackFrame(StackFrame frame) {
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
 
   // 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.
-  DCHECK_LT(tracker->pseudo_stack_.size(), 128u);
-  tracker->pseudo_stack_.push_back(frame);
+  if (tracker->pseudo_stack_.size() < kMaxStackDepth)
+    tracker->pseudo_stack_.push_back(frame);
+  else
+    NOTREACHED();
 }
 
 // static
 void AllocationContextTracker::PopPseudoStackFrame(StackFrame frame) {
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
 
   // 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 (tracker->pseudo_stack_.empty())
@@ skipping 29 matching lines @@
     std::fill(dst, dst_end, nullptr);
   }
 
   ctx.type_name = nullptr;
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base