[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/logging.h"
 #include "base/macros.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 
 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 CaptureMode {

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

enum class CaptureMode { DISABLED, PSEUDO_STACK, NATIVE_STACK }

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

Done.

+    DONT_CAPTURE = 0, // must be 0
+    CAPTURE_PSEUDO_STACK,
+    CAPTURE_NATIVE_STACK
+  };
+
+  // Globally sets capturing mode.
+  // TODO: How to guards against CAPTURE_* -> DONT_CAPTURE -> CAPTURE_*?

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

TODO want always a name ;)
you can put mine if you want, as ruuda@ is unlikely to address that TODO you are
removing.

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

Done.

+  static void SetCaptureMode(CaptureMode mode);
 
   // Returns whether capturing allocation context is enabled globally.
   inline static bool capture_enabled() {

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

Hmm I think you want to expose the capture mode here.
My rationale is: this is used by trace_log.cc to figure out if it should push
inside the tracer or not.
Right now with this CL you are letting it push the trace event in the tracker,
but you are never reading those events back in the GetSnapshot().
Is it intended? Is it because you want to later support both native and pseudo
stacks, and just didn't bother now?
Or is this not intended and you just didn't think to that?

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

Yes, this is intended. I want us to still maintain pseudo stack because we might
want to use it as a filter for native traces, i.e. report native stack only if
event X is on the pseudo stack. Basically I consider capturing mode an
implementation detail, which might change, and outside world should care only
about whether we are capturing or not.

Besides, we might need to maintain pseudo stack for other components, like v8.

     // 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_) == DONT_CAPTURE)
       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_) != DONT_CAPTURE;
   }
 
   // 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);
 
   // Pushes a frame onto the thread-local pseudo stack.
+  void PushPseudoStackFrame(const char* frame_symbol_value);

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

s/frame_symbol_value/trace_event_name/ :) it makes clear what the arg is

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

Done.

   void PushPseudoStackFrame(StackFrame frame);

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

Do we really need both versions here?
It seem that you still want the one that takes the char*.
Also, if you take a StackFrame this is not necessarily "pseudo" anymore, as it
could be native.

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

Done.

 
   // Pops a frame from the thread-local pseudo stack.
-  void PopPseudoStackFrame(StackFrame frame);
+  void PopPseudoStackFrame(const void* frame_value);
 
   // Push and pop current task's context. A stack is used to support nested
   // tasks and the top of the stack will be used in allocation context.
   void PushCurrentTaskContext(const char* context);
   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<StackFrame> 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_