[tracing] Implement trace_event::AllocationContext

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 "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;
 }
@@ skipping 51 matching lines @@
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
   tracker->context_[key] = value;
 }
 
 // static
 void AllocationContextTracker::UnsetContextField(const char* key) {
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
   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

[Primiano Tucci (use gerrit), 2015/10/05 12:35:38]

Hmm all this template magic makes this file very hard to read.
As discussed offline please remove this and just to two separate for-each below.
I wouldn't even have a common Copy method, as the things being copied are
different (backtrace vs fields) that the common method would IMHO make that less
clear

[Ruud van Asseldonk, 2015/10/05 14:20:44]

Agreed, done, though see also comment #4. I did keep |End| to do STL-style
(begin, end) iteration as opposed to C-style (index, size) iteration.

+// length |N|, identical to C++11 |std::end|.
+template <typename T, int N>
+T* End(T(&array)[N]) {
+  return array + N;
+}
+
+// Copies elements from the range (src, src_end) to (dst, dst_end) until either
+// the source range is exhausted, or until the destination range is full. Takes
+// |src| and |dst| by reference so that after calling this function they are
+// both advanced by the number of elements copied.
+template <typename SrcIterator, typename DstIterator>
+void Copy(SrcIterator& src, SrcIterator src_end,
+          DstIterator& dst, DstIterator dst_end) {
+  for (; src != src_end && dst != dst_end; src++, dst++)
+    *dst = *src;
 }
 
 // static
 AllocationContext AllocationContextTracker::GetContext() {

[Primiano Tucci (use gerrit), 2015/10/05 12:35:38]

Maybe you could rename this to GetContextSnapshot() or something like that to
make it clear that this is a copy

[Ruud van Asseldonk, 2015/10/05 14:20:44]

Done.

-  // TODO(ruuda): Implement this in a follow-up CL.
-  return AllocationContext();
+  auto tracker = GetThreadLocalTracker();

[Primiano Tucci (use gerrit), 2015/10/05 12:35:38]

AllocationContextTracker* tracker = GetThreadLocalTracker();

fits in one line and is more readable

[Ruud van Asseldonk, 2015/10/05 14:20:44]

Done.

+  AllocationContext ctx;
+
+  // Fill the backtrace.
+  {
+    auto src = tracker->pseudo_stack_.top();
+    auto dst = ctx.backtrace.frames;
+    auto src_end = tracker->pseudo_stack_.bottom();
+    auto dst_end = End(ctx.backtrace.frames);
+
+    // Copy as much of the top of the pseudo stack into the backtrace as
+    // possible.
+    Copy(src, src_end, dst, dst_end);
+
+    // If there is room for more, fill the remaining slots with empty frames.
+    std::fill(dst, dst_end, nullptr);
+  }
+
+  // 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.
+    Copy(src, src_end, dst, dst_end);
+
+    // 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