[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_allocation_context.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_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 // The number of stack frames stored in the backtrace is a trade off between
 // memory used for tracing and accuracy. Measurements done on a prototype
 // revealed that:
 //
 // - In 60 percent of the cases, stack depth <= 7.
 // - In 87 percent of the cases, stack depth <= 9.
 // - In 95 percent of the cases, stack depth <= 11.
 //
 // See the design doc (https://goo.gl/4s7v7b) for more details.
 
-using StackFrame = const char*;
+using StackFrame = const void*;
+
+enum StackFrameType {

[Primiano Tucci (use gerrit), 2016/04/01 15:56:28]

do we really need this run-time information per each frame?
In other words, do we ever want to support the case where some stack frames are
native and others are pseudo?
Or should that be just a global setting?

[Dmitry Skiba, 2016/04/04 22:38:33]

It's called that way, but it's used per backtrace, not per frame. I think that
we should go another direction - introduce it per-frame, so that we could for
example add things like thread names to native stack traces. And other way
around too - Sid has an idea to add addresses of task functions to pseudo stack
traces. Those addresses always available, and provide precise place where
task-related allocations stem from.

+  STACK_FRAME_TYPE_SYMBOL,  // const char* string
+  STACK_FRAME_TYPE_PC       // as returned by StackTrace::Addresses()
+};
 
 struct BASE_EXPORT Backtrace {
+  StackFrameType frame_type;
   // Unused backtrace frames are filled with nullptr frames. If the stack is
   // higher than what can be stored here, the bottom frames are stored. Based
   // on the data above, a depth of 12 captures the full stack in the vast
   // majority of the cases.
   StackFrame frames[12];
 };
 
 bool BASE_EXPORT operator==(const Backtrace& lhs, const Backtrace& rhs);
 
 // The |AllocationContext| is context metadata that is kept for every allocation
@@ skipping 37 matching lines @@
 };
 
 template <>
 struct BASE_EXPORT hash<base::trace_event::AllocationContext> {
   size_t operator()(const base::trace_event::AllocationContext& context) const;
 };
 
 }  // BASE_HASH_NAMESPACE
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_