[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_allocation_context_tracker.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_
 
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
+#include "base/debug/debugging_flags.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 
+#if HAVE_TRACE_STACK_FRAME_POINTERS && !defined(OS_NACL) && \
+    (BUILDFLAG(ENABLE_PROFILING) || defined(DEBUG))

[Primiano Tucci (use gerrit), 2016/04/19 20:15:19]

Why do you need the (BUILDFLAG(ENABLE_PROFILING) || defined(DEBUG)) part here?
Isn't the presence of FRAME_POINTERS enough? (And, ok, nacl for whatever reason
I don't even want to know)

[Dmitry Skiba, 2016/04/20 19:19:25]

Actually, you suggested these defines earlier :) But it makes sense - we can
reliably use frame pointers only in debug and profiling builds, so for now this
feature is limited to those configurations.

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

oh right lolz :)

+#define ENABLE_NATIVE_ALLOCATION_TRACES 1
+#else
+#define ENABLE_NATIVE_ALLOCATION_TRACES 0
+#endif
+
 namespace base {
 namespace trace_event {
 
 // The allocation context tracker keeps track of thread-local context for heap
 // profiling. It includes a pseudo stack of trace events. On every allocation
 // the tracker provides a snapshot of its context in the form of an
 // |AllocationContext| that is to be stored together with the allocation
 // details.
 class BASE_EXPORT AllocationContextTracker {
  public:
-  // Globally enables capturing allocation context.
-  // TODO(ruuda): Should this be replaced by |EnableCapturing| in the future?
-  // Or at least have something that guards agains enable -> disable -> enable?
-  static void SetCaptureEnabled(bool enabled);
+  enum class CaptureMode: int {

[Primiano Tucci (use gerrit), 2016/04/19 20:15:19]

s/int/int32_t/

[Dmitry Skiba, 2016/04/20 19:19:24]

Done.

+    DISABLED,       // Don't capture anything
+    PSEUDO_STACK,   // GetContextSnapshot() returns pseudo stack trace
+#if ENABLE_NATIVE_ALLOCATION_TRACES
+    NATIVE_STACK    // GetContextSnapshot() returns native (real) stack trace
+#endif
+  };
+
+  // Globally sets capturing mode.
+  // TODO(primiano): How to guard against *_STACK -> DISABLED -> *_STACK?
+  static void SetCaptureMode(CaptureMode mode);
 
   // Returns whether capturing allocation context is enabled globally.
   inline static bool capture_enabled() {

[Primiano Tucci (use gerrit), 2016/04/19 20:15:19]

I think you want to return a CaptureMode here and change the code in
trace_event.h to do:
 if (UNLIKELY(...capture_enabled()))
to
 if (UNLIKELY(...capture_enabled() == PSEUDO_STACK))

otherwise the pseudo stack will unnecessarily being updated without any need.

(unless you want both stack frames here, but your current code doesn't seem to
support it, so let's not leave the codebase inconsistent)

[Dmitry Skiba, 2016/04/20 19:19:24]

Done.

     // A little lag after heap profiling is enabled or disabled is fine, it is
     // more important that the check is as cheap as possible when capturing is
     // not enabled, so do not issue a memory barrier in the fast path.
-    if (subtle::NoBarrier_Load(&capture_enabled_) == 0)
+    if (subtle::NoBarrier_Load(&capture_mode_) ==
+            static_cast<int>(CaptureMode::DISABLED))
       return false;
 
     // In the slow path, an acquire load is required to pair with the release
-    // store in |SetCaptureEnabled|. This is to ensure that the TLS slot for
+    // store in |SetCaptureMode|. This is to ensure that the TLS slot for
     // the thread-local allocation context tracker has been initialized if
     // |capture_enabled| returns true.
-    return subtle::Acquire_Load(&capture_enabled_) != 0;
+    return subtle::Acquire_Load(&capture_mode_) !=
+        static_cast<int>(CaptureMode::DISABLED);
   }
 
   // Returns the thread-local instance, creating one if necessary. Returns
   // always a valid instance, unless it is called re-entrantly, in which case
   // returns nullptr in the nested calls.
   static AllocationContextTracker* GetInstanceForCurrentThread();
 
   // Set the thread name in the AllocationContextTracker of the current thread
   // if capture is enabled.
   static void SetCurrentThreadName(const char* name);
@@ skipping 10 matching lines @@
   void PopCurrentTaskContext(const char* context);
 
   // Returns a snapshot of the current thread-local context.
   AllocationContext GetContextSnapshot();
 
   ~AllocationContextTracker();
 
  private:
   AllocationContextTracker();
 
-  static subtle::Atomic32 capture_enabled_;
+  static subtle::Atomic32 capture_mode_;
 
   // The pseudo stack where frames are |TRACE_EVENT| names.
   std::vector<const char*> pseudo_stack_;
 
   // The thread name is used as the first entry in the pseudo stack.
   const char* thread_name_;
 
   // Stack of tasks' contexts. Context serves as a different dimension than
   // pseudo stack to cluster allocations.
   std::vector<const char*> task_contexts_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationContextTracker);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_TRACKER_H_