Alternative heap dumping scheme.

base/trace_event/heap_profiler_stack_frame_deduplicator.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_stack_frame_deduplicator.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
 
 StackFrameDeduplicator::FrameNode::FrameNode(StackFrame frame,
                                              int parent_frame_index)
-    : frame(frame), parent_frame_index(parent_frame_index) {}
+    : frame(frame), parent_frame_index(parent_frame_index), indexed(false) {}
 StackFrameDeduplicator::FrameNode::FrameNode(const FrameNode& other) = default;
 StackFrameDeduplicator::FrameNode::~FrameNode() {}
 
 StackFrameDeduplicator::StackFrameDeduplicator() {}
 StackFrameDeduplicator::~StackFrameDeduplicator() {}
 
 int StackFrameDeduplicator::Insert(const StackFrame* beginFrame,
                                    const StackFrame* endFrame) {
   int frame_index = -1;
   std::map<StackFrame, int>* nodes = &roots_;
@@ skipping 19 matching lines @@
       // might need to resize, and this invalidates the |nodes| pointer.
       frames_.push_back(frame_node);
     } else {
       // A tree node for this frame exists. Look for the next one.
       frame_index = node->second;
     }
 
     nodes = &frames_[frame_index].children;
   }
 
+  if (frame_index != -1) {
+    frames_[frame_index].indexed = true;
+  }
+
   return frame_index;
 }
 
 void StackFrameDeduplicator::AppendAsTraceFormat(std::string* out) const {
+#if defined(NEW_TRACE_FORMAT)
+  std::string stringify_buffer;
+  std::unique_ptr<TracedValue> traced_value(new TracedValue);
+
+  std::map<StackFrame, size_t> unique_frame_indexes;
+  traced_value->BeginDictionary("hierarchy");
+  {
+    std::function<void(const std::map<StackFrame, int>&)> append_level =
+        [&](const std::map<StackFrame, int>& level) {
+      for (const auto& frame_and_index: level) {
+        int node_index = frame_and_index.second;
+        const FrameNode& node = frames_[node_index];
+
+        size_t unique_index = unique_frame_indexes.insert(
+            {node.frame, unique_frame_indexes.size()}).first->second;
+        SStringPrintf(&stringify_buffer, "%zu", unique_index);
+        traced_value->BeginDictionaryWithCopiedName(stringify_buffer);
+
+        if (node.indexed) {
+          SStringPrintf(&stringify_buffer, "%d", node_index);
+          traced_value->SetString("bt", stringify_buffer);
+        }
+
+        append_level(node.children);
+
+        traced_value->EndDictionary();
+      }
+    };
+
+    append_level(roots_);
+  }
+  traced_value->EndDictionary();
+
+  traced_value->BeginArray("names");
+  {
+    std::vector<StackFrame> unique_frames;
+    unique_frames.resize(unique_frame_indexes.size());
+    for (const auto& frame_and_index: unique_frame_indexes) {
+      DCHECK(frame_and_index.second < unique_frames.size());
+      unique_frames[frame_and_index.second] = frame_and_index.first;
+    }
+    for (const auto& frame: unique_frames) {
+      switch (frame.type) {
+        case StackFrame::Type::TRACE_EVENT_NAME:
+          traced_value->AppendString(static_cast<const char*>(frame.value));
+          break;
+        case StackFrame::Type::THREAD_NAME:
+          SStringPrintf(&stringify_buffer,
+                        "[Thread: %s]",
+                        static_cast<const char*>(frame.value));
+          traced_value->AppendString(stringify_buffer);
+          break;
+        case StackFrame::Type::PROGRAM_COUNTER:
+          SStringPrintf(&stringify_buffer,
+                        "pc:%" PRIxPTR,
+                        reinterpret_cast<uintptr_t>(frame.value));
+          traced_value->AppendString(stringify_buffer);
+          break;
+      }
+    }
+  }
+  traced_value->EndArray();
+
+  std::string trace;
+  traced_value->AppendAsTraceFormat(out);
+
+#else  // !defined(NEW_TRACE_FORMAT)
+
   out->append("{");  // Begin the |stackFrames| dictionary.
 
   int i = 0;
   auto frame_node = begin();
   auto it_end = end();
   std::string stringify_buffer;
 
   while (frame_node != it_end) {
     // The |stackFrames| format is a dictionary, not an array, so the
     // keys are stringified indices. Write the index manually, then use
@@ skipping 29 matching lines @@
     frame_node_value->AppendAsTraceFormat(out);
 
     i++;
     frame_node++;
 
     if (frame_node != it_end)
       out->append(",");
   }
 
   out->append("}");  // End the |stackFrames| dictionary.
+
+#endif  // defined(NEW_TRACE_FORMAT)
 }
 
 void StackFrameDeduplicator::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
   // The sizes here are only estimates; they fail to take into account the
   // overhead of the tree nodes for the map, but as an estimate this should be
   // fine.
   size_t maps_size = roots_.size() * sizeof(std::pair<StackFrame, int>);
   size_t frames_allocated = frames_.capacity() * sizeof(FrameNode);
   size_t frames_resident = frames_.size() * sizeof(FrameNode);
 
   for (const FrameNode& node : frames_)
     maps_size += node.children.size() * sizeof(std::pair<StackFrame, int>);
 
   overhead->Add("StackFrameDeduplicator",
                 sizeof(StackFrameDeduplicator) + maps_size + frames_allocated,
                 sizeof(StackFrameDeduplicator) + maps_size + frames_resident);
 }
 
 }  // namespace trace_event
 }  // namespace base