[tracing] Implement trace_event::AllocationContext

base/trace_event/memory_profiler_allocation_context.cc

Index: base/trace_event/memory_profiler_allocation_context.cc
diff --git a/base/trace_event/memory_profiler_allocation_context.cc b/base/trace_event/memory_profiler_allocation_context.cc
index 3aea93518c633aa667d1b21f0ff028ce1f117819..c1397dff7971c7b1197d9ca83466b9465f473d8c 100644
--- a/base/trace_event/memory_profiler_allocation_context.cc
+++ b/base/trace_event/memory_profiler_allocation_context.cc
@@ -75,16 +75,52 @@ void AllocationContextTracker::UnsetContextField(const char* key) {
   tracker->context_.erase(key);
 }
 
-// static
-AllocationStack* AllocationContextTracker::GetPseudoStackForTesting() {
-  auto tracker = AllocationContextTracker::GetThreadLocalTracker();
-  return &tracker->pseudo_stack_;
+// Returns a pointer past the end of the fixed-size array |array| of |T| of
+// length |N|, identical to C++11 |std::end|.
+template <typename T, int N>
+const T* End(const T(&array)[N]) {
+  return array + N;
 }
 
 // static
 AllocationContext AllocationContextTracker::GetContext() {
-  // TODO(ruuda): Implement this in a follow-up CL.
-  return AllocationContext();
+  auto tracker = GetThreadLocalTracker();
+  AllocationContext ctx;
+
+  // Fill the backtrace.
+  {
+    auto src = tracker->pseudo_stack_.top();
+    auto dst = ctx.backtrace;
+    auto src_end = tracker->pseudo_stack_.bottom();
+    auto dst_end = End(ctx.backtrace);
+
+    // Copy as much of the top of the pseudo stack into the backtrace as
+    // possible.
+    for (; src != src_end && dst != dst_end; src++, dst++)
+      *dst = *src;
+
+    // If there is room for more, fill the remaining slots with empty frames.
+    for (; dst != dst_end; dst++)
+      *dst = nullptr;

[picksi, 2015/09/25 09:44:35]

Q:Is the performance overhead for clearing all the remaining slots worthwhile?
If you cleared only the next slot would that suffice to stop iterations through
the slots?

[Ruud van Asseldonk, 2015/09/25 11:46:19]

It would, but I am not sure how that would affect performance later on. To group
the allocations by backtrace, comparing the full backtrace padded with zeroes
can potentially be done very efficiently by doing a bitwise comparison of a
chunk of memory as large as the CPU can handle, and the loop is fixed size so it
can be unrolled. If there is garbage after the first null pointer this might
require a branch to early-out comparisons. If we group by using a hash table
then there should be no garbage at the end, for a tree with an operator< it is
probably good to early-out. I have no clue what would be better
performance-wise, but I am also not sure it is relevant here.

Do you want me to change it to a null-terminated list?

[picksi, 2015/09/25 12:31:26]

No, leave it as it is! You make some good points :)

+  }
+
+  // Fill the context fields.
+  {
+    auto src = tracker->context_.begin();
+    auto dst = ctx.fields;
+    auto src_end = tracker->context_.end();
+    auto dst_end = End(ctx.fields);
+
+    // Copy as much (key, value) pairs as possible.
+    for (; src != src_end && dst != dst_end; src++, dst++)
+      *dst = *src;

[picksi, 2015/09/25 09:44:35]

nit: This code is duplicated from 99-100, should it be broken out into a
function?

[Ruud van Asseldonk, 2015/09/25 11:46:19]

Ideally there would be an |std::copy| that copies until either the destination
or source runs out, but there is none :( I wrote it manually now, but in my
opinion it just adds extra noise.

+
+    // 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