[Tracing] Enable heap dumps with both type info and backtraces

base/trace_event/heap_profiler_heap_dump_writer.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_HEAP_DUMP_WRITER_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_
 
-#include <string>
+#include <set>
 
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 
 namespace base {
 namespace trace_event {
 
 class StackFrameDeduplicator;
 class TracedValue;
 class TypeNameDeduplicator;
 
+namespace {
+struct Bucket;
+}
+
 // Helper class to dump a snapshot of an |AllocationRegister| or other heap
 // bookkeeping structure into a |TracedValue|. This class is intended to be
 // used as a one-shot local instance on the stack. To write heap dumps, call
-// |InsertAllocation| for every captured allocation, then call |WriteHeapDump|
-// to do the processing and generate a heap dump value for the trace log.
+// |InsertAllocation| for every captured allocation, then call |Dump| to do
+// the processing, and pass its return value to |Write| to get a |TracedValue|
+// that can be dumped into the trace log.
 class BASE_EXPORT HeapDumpWriter {
  public:
+  // An entry in the "entries" array as described in https://goo.gl/KY7zVE.
+  struct Entry {
+    size_t size;
+
+    // References a backtrace in the stack frame deduplicator. -1 means empty
+    // backtrace (the root of the tree).
+    int stack_frame_id;
+
+    // References a type name in the type name deduplicator. -1 indicates that
+    // the size is the cumulative size for all types (the root of the tree).
+    int type_id;
+  };
+
   // The |StackFrameDeduplicator| and |TypeNameDeduplicator| are not owned. The
   // heap dump writer assumes exclusive access to them during the lifetime of
   // the dump writer.
   HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator,
                  TypeNameDeduplicator* type_name_deduplicator);
+
   ~HeapDumpWriter();
 
   // Inserts information from which the heap dump will be generated. This method
   // does minimal processing, so it can be called when a lock is held.
   void InsertAllocation(const AllocationContext& context, size_t size);
 
-  // Aggregates allocations and writes an "entries" array to a traced value. See
-  // https://goo.gl/jYN4Zn for a description of the format.
-  scoped_refptr<TracedValue> WriteHeapDump();
+  // Aggregates allocations to compute the total size of the heap, then breaks
+  // down the heap recursively. This produces the values that should be dumped
+  // in the "entries" array. The number of entries is kept reasonable because
+  // long tails are not included. Use |Write| to convert to a traced value.
+  const std::set<Entry>& Dump();

[Primiano Tucci (use gerrit), 2015/12/08 18:05:30]

I understand this is for testability, but I'd like to see here only the method
that make sense for this class (GetHeapDump that returns a TracedValue). You can
make this a private method used internally and friend the test.

[Ruud van Asseldonk, 2015/12/09 14:07:53]

Obsolete now. I put it in a namespace instead.

+
+  // Writes an "entries" array to a traced value. See https://goo.gl/KY7zVE for
+  // a description of the format.
+  static scoped_refptr<TracedValue> Write(const std::set<Entry>& dump);

[Primiano Tucci (use gerrit), 2015/12/08 18:05:30]

and obviously drop (privatize) this

[Ruud van Asseldonk, 2015/12/09 14:07:54]

Obsolete now.

 
  private:
-  // Writes a "bt" key that references a stack frame in the |stackFrames|
-  // dictionary.
-  void WriteStackFrameIndex(int index);
+  // Inserts an |Entry| for |Bucket| into |entries_|. Returns false if the
+  // entry was present before, true if it was not.
+  bool InsertEntry(const Bucket& bucket);
 
-  // Writes a "type" key with the stringified type ID.
-  void WriteTypeId(int type_id);
+  // Recursively breaks down a bucket into smaller buckets and adds entries for
+  // the buckets worth dumping to |entries_|.
+  void BreakDown(const Bucket& bucket);
 
-  // Writes a "size" key with value |size| as a hexidecimal string to the traced
-  // value.
-  void WriteSize(size_t size);
+  // A map map from allocation context to the number of bytes allocated for that
+  // context.
+  hash_map<AllocationContext, size_t> bytes_by_context_;
 
-  // The value that this heap dumper writes to.
-  const scoped_refptr<TracedValue> traced_value_;
+  // The collection of entries that is filled by |Dump|.
+  std::set<Entry> entries_;
 
   // Helper for generating the |stackFrames| dictionary. Not owned, must outlive
   // this heap dump writer instance.
   StackFrameDeduplicator* const stack_frame_deduplicator_;
 
   // Helper for converting type names to IDs. Not owned, must outlive this heap
   // dump writer instance.
   TypeNameDeduplicator* const type_name_deduplicator_;
 
-  // A map of allocation context to the number of bytes allocated for that
-  // context.
-  hash_map<AllocationContext, size_t> bytes_by_context_;
-
-  // Buffer for converting integers into strings, that is re-used throughout the
-  // dump.
-  std::string buffer_;
-
   DISALLOW_COPY_AND_ASSIGN(HeapDumpWriter);
 };
 
+// Comparison operator to enable putting |Entry| in a |std::set|.
+BASE_EXPORT bool operator<(HeapDumpWriter::Entry lhs,
+                           HeapDumpWriter::Entry rhs);
+
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_HEAP_DUMP_WRITER_H_