[tracing] Turn StackFrame into struct.

base/trace_event/heap_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/heap_profiler_allocation_context.h"
 
 #include <cstring>
 
 #include "base/hash.h"
 #include "base/macros.h"
 
 namespace base {
 namespace trace_event {
 
+bool operator < (const StackFrame& lhs, const StackFrame& rhs) {
+  return lhs.value < rhs.value;
+}
+
+bool operator == (const StackFrame& lhs, const StackFrame& rhs) {
+  return lhs.value == rhs.value;
+}
+
+bool operator != (const StackFrame& lhs, const StackFrame& rhs) {
+  return lhs.value != rhs.value;

[Primiano Tucci (use gerrit), 2016/04/19 19:45:06]

small thing. I'd probably just implement this as !(lhs == rhs), so if in future
somebody changes ==, this doesn't go out of sync.

[Dmitry Skiba, 2016/04/19 22:14:14]

Done.

+}
+
 // Constructor that does not initialize members.
 AllocationContext::AllocationContext() {}
 
 // static
 AllocationContext AllocationContext::Empty() {
   AllocationContext ctx;

[Primiano Tucci (use gerrit), 2016/04/19 19:45:06]

At this point can we remove this and make this into the ctor?  This perf
optimization between the default ctor and Empty does not make any sense anymore
with your change. Let's keep the code easier (Empty is just used by tests)

[Dmitry Skiba, 2016/04/19 22:14:14]

Done.

 
-  for (size_t i = 0; i < arraysize(ctx.backtrace.frames); i++)
-    ctx.backtrace.frames[i] = nullptr;
-
+  ctx.backtrace.frame_count = 0;
   ctx.type_name = nullptr;
 
   return ctx;
 }
 
 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;
+  if (lhs.frame_count != rhs.frame_count) return false;
+  return std::equal(lhs.frames, lhs.frames + lhs.frame_count, rhs.frames);
 }
 
 bool operator==(const AllocationContext& lhs, const AllocationContext& rhs) {
   return (lhs.backtrace == rhs.backtrace) && (lhs.type_name == rhs.type_name);
 }
 
 }  // namespace trace_event
 }  // namespace base
 
 namespace BASE_HASH_NAMESPACE {
 using base::trace_event::AllocationContext;
 using base::trace_event::Backtrace;
+using base::trace_event::StackFrame;
+
+size_t hash<StackFrame>::operator()(const StackFrame& frame) const {
+  return hash<const void*>()(frame.value);
+}
 
 size_t hash<Backtrace>::operator()(const Backtrace& backtrace) const {
-  return base::SuperFastHash(reinterpret_cast<const char*>(backtrace.frames),
-                             sizeof(backtrace.frames));
+  const void* values[Backtrace::kMaxFrameCount];
+  for (size_t i = 0; i != backtrace.frame_count; ++i) {
+    values[i] = backtrace.frames[i].value;
+  }
+  return base::SuperFastHash(reinterpret_cast<const char*>(values),
+                             backtrace.frame_count * sizeof(*values));
 }
 
 size_t hash<AllocationContext>::operator()(const AllocationContext& ctx) const {
   size_t backtrace_hash = hash<Backtrace>()(ctx.backtrace);
 
   // Multiplicative hash from [Knuth 1998]. Works best if |size_t| is 32 bits,
   // because the magic number is a prime very close to 2^32 / golden ratio, but
   // will still redistribute keys bijectively on 64-bit architectures because
   // the magic number is coprime to 2^64.
   size_t type_hash = reinterpret_cast<size_t>(ctx.type_name) * 2654435761;
 
   // Multiply one side to break the commutativity of +. Multiplication with a
   // number coprime to |numeric_limits<size_t>::max() + 1| is bijective so
   // randomness is preserved.
   return (backtrace_hash * 3) + type_hash;
 }
 
 }  // BASE_HASH_NAMESPACE