[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_heap_dump_writer.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_heap_dump_writer.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 48 matching lines @@
 
 // Comparison operator to order buckets by their size.
 bool operator<(const Bucket& lhs, const Bucket& rhs) {
   return lhs.size < rhs.size;
 }
 
 // Groups the allocations in the bucket by |breakBy|. The buckets in the
 // returned list will have |backtrace_cursor| advanced or
 // |is_broken_down_by_type_name| set depending on the property to group by.
 std::vector<Bucket> GetSubbuckets(const Bucket& bucket, BreakDownMode breakBy) {
-  base::hash_map<const char*, Bucket> breakdown;
+  base::hash_map<StackFrame, Bucket> breakdown;
 
   if (breakBy == BreakDownMode::kByBacktrace) {
     for (const auto& context_and_size : bucket.bytes_by_context) {
       const Backtrace& backtrace = context_and_size.first->backtrace;
-      const char* const* begin = std::begin(backtrace.frames);
-      const char* const* end = std::end(backtrace.frames);
-      const char* const* cursor = begin + bucket.backtrace_cursor;
+      const StackFrame* begin = std::begin(backtrace.frames);

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

if StackFrame is "const char*", I think
const char* const* begin
should become:
StackFrame const* begin

same below

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

Actually, 'const StackFrame*' and 'StackFrame const*' are equivalent here, and
both produce 'void const* const*'. ('backtrace' is const&, so assigning
'backtrace.frames' to anything other than  'void const* const*' wouldn't
compile.)

+      const StackFrame* end = std::end(backtrace.frames);
+      const StackFrame* cursor = begin + bucket.backtrace_cursor;
 
       // The backtrace in the context is padded with null pointers, but these
       // should not be considered for breakdown. Adjust end to point past the
       // last non-null frame.
       while (begin != end && *(end - 1) == nullptr)
         end--;
 
       DCHECK_LE(cursor, end);
 
       if (cursor != end) {
@@ skipping 95 matching lines @@
 HeapDumpWriter::~HeapDumpWriter() {}
 
 bool HeapDumpWriter::AddEntryForBucket(const Bucket& bucket) {
   // The contexts in the bucket are all different, but the [begin, cursor) range
   // is equal for all contexts in the bucket, and the type names are the same if
   // |is_broken_down_by_type_name| is set.
   DCHECK(!bucket.bytes_by_context.empty());
 
   const AllocationContext* context = bucket.bytes_by_context.front().first;
 
-  const char* const* backtrace_begin = std::begin(context->backtrace.frames);
-  const char* const* backtrace_end = backtrace_begin + bucket.backtrace_cursor;
+  const StackFrame* backtrace_begin = std::begin(context->backtrace.frames);
+  const StackFrame* backtrace_end = backtrace_begin + bucket.backtrace_cursor;
   DCHECK_LE(bucket.backtrace_cursor, arraysize(context->backtrace.frames));
 
   Entry entry;
-  entry.stack_frame_id =
-      stack_frame_deduplicator_->Insert(backtrace_begin, backtrace_end);
+  entry.stack_frame_id = stack_frame_deduplicator_->Insert(
+      context->backtrace.frame_type, backtrace_begin, backtrace_end);
 
   // Deduplicate the type name, or use ID -1 if type name is not set.
   entry.type_id = bucket.is_broken_down_by_type_name
                       ? type_name_deduplicator_->Insert(context->type_name)
                       : -1;
 
   entry.size = bucket.size;
 
   auto position_and_inserted = entries_.insert(entry);
   return position_and_inserted.second;
@@ skipping 20 matching lines @@
 
 const std::set<Entry>& HeapDumpWriter::Summarize(
     const hash_map<AllocationContext, size_t>& bytes_by_context) {
   // Start with one bucket that represents the entire heap. Iterate by
   // reference, because the allocation contexts are going to point to allocation
   // contexts stored in |bytes_by_context|.
   Bucket root_bucket;
   for (const auto& context_and_size : bytes_by_context) {
     const AllocationContext* context = &context_and_size.first;
     const size_t size = context_and_size.second;
-    root_bucket.bytes_by_context.push_back(std::make_pair(context, size));
-    root_bucket.size += size;
+    if (size != 0) {

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

uh do we see any zero allocations?

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

Yup. Maybe we need to ignore them earlier, in MallocDumpProvider?

+      // GetSubbuckets() expects non-zero allocations
+      root_bucket.bytes_by_context.push_back(std::make_pair(context, size));
+      root_bucket.size += size;
+    }
   }
 
   AddEntryForBucket(root_bucket);
 
   // Recursively break down the heap and fill |entries_| with entries to dump.
   BreakDown(root_bucket);
 
   return entries_;
 }
 
@@ skipping 42 matching lines @@
     const hash_map<AllocationContext, size_t>& bytes_by_size,
     StackFrameDeduplicator* stack_frame_deduplicator,
     TypeNameDeduplicator* type_name_deduplicator) {
   internal::HeapDumpWriter writer(stack_frame_deduplicator,
                                   type_name_deduplicator);
   return Serialize(writer.Summarize(bytes_by_size));
 }
 
 }  // namespace trace_event
 }  // namespace base