[Tracing] Introduce HeapDumpWriter helper class

base/trace_event/memory_profiler_allocation_context.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/memory_profiler_allocation_context.h"
 
 #include <algorithm>
+#include <cstring>
 
+#include "base/hash.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 namespace trace_event {
 
 subtle::Atomic32 AllocationContextTracker::capture_enabled_ = 0;
 
 namespace {
 ThreadLocalStorage::StaticSlot g_tls_alloc_ctx_tracker = TLS_INITIALIZER;
 }
 
 AllocationStack::AllocationStack() {}
 AllocationStack::~AllocationStack() {}
 
-// This function is added to the TLS slot to clean up the instance when the
-// thread exits.
-void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
-  delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
+bool operator==(const Backtrace& lhs, const Backtrace& rhs) {
+  // Pointer equality of the stack frames is assumed, so instead of doing a deep
+  // string comparison on all of the frames, a |memcmp| suffices.
+  return std::memcmp(lhs.frames, rhs.frames, sizeof(lhs.frames)) == 0;
 }
 
-AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
-  auto tracker =
-      static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
-
-  if (!tracker) {
-    tracker = new AllocationContextTracker();
-    g_tls_alloc_ctx_tracker.Set(tracker);
-  }
-
-  return tracker;
+uint32_t BacktraceHash::operator()(const Backtrace& backtrace) const {
+  return SuperFastHash(reinterpret_cast<const char*>(backtrace.frames),

[Primiano Tucci (use gerrit), 2015/10/26 11:52:06]

be really careful with SuperFastHash. I got bitten in the past* as it is easy to
collide if two stacks differ only for the last 4 chars, which might be the case
here. If unsure use sha1 and we can always use a faster hash later if we hit
performance problems.

* see [chromium-dev] base::Hash(), how robust is it supposed to be

[Ruud van Asseldonk, 2015/10/26 14:51:26]

I saw that discussion. Insertion in the hash table is done while a lock for the
allocation register is held. All allocations from all threads are blocked on
this, so performance is critical here. I have not benchmarked SHA1 against
SuperFastHash, but I did compare |std::map| and |base::hash_map|, where for map
the comparison is a |memcmp| of the backtrace. The result was that a hash table
is about 30% faster. Do you think it is worthwhile to investigate performance of
different hashes?

[Primiano Tucci (use gerrit), 2015/10/26 20:57:57]

Ok, didn't realize that after all, if you end up having some collision you just
have a slightly slower path. In my case it was different as I was expecting to
now have collisions.
So, even if SuperFastHash should suck systematically, everything will always
work (just maybe a bit slower)

+                       sizeof(backtrace.frames));
 }
 
 StackFrameDeduplicator::FrameNode::FrameNode(StackFrame frame,
                                              int parent_frame_index)
     : frame(frame), parent_frame_index(parent_frame_index) {}
 StackFrameDeduplicator::FrameNode::~FrameNode() {}
 
 StackFrameDeduplicator::StackFrameDeduplicator() {}
 StackFrameDeduplicator::~StackFrameDeduplicator() {}
 
-int StackFrameDeduplicator::Insert(const AllocationContext::Backtrace& bt) {
+int StackFrameDeduplicator::Insert(const Backtrace& bt) {
   int frame_index = -1;
   std::map<StackFrame, int>* nodes = &roots_;
 
   for (size_t i = 0; i < arraysize(bt.frames); i++) {
     if (!bt.frames[i])
       break;
 
     auto node = nodes->find(bt.frames[i]);
     if (node == nodes->end()) {
       // There is no tree node for this frame yet, create it. The parent node
@@ skipping 14 matching lines @@
       // A tree node for this frame exists. Look for the next one.
       frame_index = node->second;
     }
 
     nodes = &frames_[frame_index].children;
   }
 
   return frame_index;
 }
 
+// This function is added to the TLS slot to clean up the instance when the
+// thread exits.
+void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
+  delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
+}
+
+AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
+  auto tracker =
+      static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
+
+  if (!tracker) {
+    tracker = new AllocationContextTracker();
+    g_tls_alloc_ctx_tracker.Set(tracker);
+  }
+
+  return tracker;
+}
+
 AllocationContextTracker::AllocationContextTracker() {}
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
 void AllocationContextTracker::SetCaptureEnabled(bool enabled) {
   // When enabling capturing, also initialize the TLS slot. This does not create
   // a TLS instance yet.
   if (enabled && !g_tls_alloc_ctx_tracker.initialized())
     g_tls_alloc_ctx_tracker.Initialize(DestructAllocationContextTracker);
 
@@ skipping 72 matching lines @@
     // If there is room for more, fill the remaining slots with nullptr keys.
     for (; dst != dst_end; dst++)
       dst->first = nullptr;
   }
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base