Enable sharding of AllocationRegister on desktop.

base/trace_event/heap_profiler_allocation_register.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_register.h"
 
 #include <algorithm>
 #include <limits>
 
-#include "base/trace_event/trace_event_memory_overhead.h"
-
 namespace base {
 namespace trace_event {
 
+size_t AllocationRegister::AddressHasher::operator()(
+    const void* address) const {
+  // The multiplicative hashing scheme from [Knuth 1998]. The value of |a| has
+  // been chosen carefully based on measurements with real-word data (addresses
+  // recorded from a Chrome trace run). It is the first prime after 2^17. For
+  // |shift|, 15 yield good results for both 2^18 and 2^19 bucket sizes.
+  // Microbenchmarks show that this simple scheme outperforms fancy hashes like
+  // Murmur3 by 20 to 40 percent.
+  const uintptr_t key = reinterpret_cast<uintptr_t>(address);
+  const uintptr_t a = 131101;
+  const uintptr_t shift = 15;
+  const uintptr_t h = (key * a) >> shift;
+  return h;
+}
+
 AllocationRegister::ConstIterator::ConstIterator(
     const AllocationRegister& alloc_register,
     AllocationIndex index)
     : register_(alloc_register), index_(index) {}
 
 void AllocationRegister::ConstIterator::operator++() {
   index_ = register_.allocations_.Next(index_ + 1);
 }
 
 bool AllocationRegister::ConstIterator::operator!=(
@@ skipping 24 matching lines @@
   }
 
   total_value += backtrace.frame_count;
 
   // These magic constants give best results in terms of average collisions
   // per backtrace. They were found by replaying real backtraces from Linux
   // and Android against different hash functions.
   return (total_value * 131101) >> 14;
 }
 
-size_t AllocationRegister::AddressHasher::operator()(
-    const void* address) const {
-  // The multiplicative hashing scheme from [Knuth 1998]. The value of |a| has
-  // been chosen carefully based on measurements with real-word data (addresses
-  // recorded from a Chrome trace run). It is the first prime after 2^17. For
-  // |shift|, 15 yield good results for both 2^18 and 2^19 bucket sizes.
-  // Microbenchmarks show that this simple scheme outperforms fancy hashes like
-  // Murmur3 by 20 to 40 percent.
-  const uintptr_t key = reinterpret_cast<uintptr_t>(address);
-  const uintptr_t a = 131101;
-  const uintptr_t shift = 15;
-  const uintptr_t h = (key * a) >> shift;
-  return h;
-}
-
 AllocationRegister::AllocationRegister()
     : AllocationRegister(kAllocationCapacity, kBacktraceCapacity) {}
 
 AllocationRegister::AllocationRegister(size_t allocation_capacity,
                                        size_t backtrace_capacity)
     : allocations_(allocation_capacity), backtraces_(backtrace_capacity) {
   Backtrace sentinel = {};
   sentinel.frames[0] = StackFrame::FromThreadName("[out of heap profiler mem]");
   sentinel.frame_count = 1;
 
@@ skipping 61 matching lines @@
 }
 
 AllocationRegister::ConstIterator AllocationRegister::begin() const {
   return ConstIterator(*this, allocations_.Next(0));
 }
 
 AllocationRegister::ConstIterator AllocationRegister::end() const {
   return ConstIterator(*this, AllocationMap::kInvalidKVIndex);
 }
 
-void AllocationRegister::EstimateTraceMemoryOverhead(
-    TraceEventMemoryOverhead* overhead) const {
-  size_t allocated = sizeof(AllocationRegister);
-  size_t resident = sizeof(AllocationRegister) +
-                    allocations_.EstimateUsedMemory() +
-                    backtraces_.EstimateUsedMemory();
-  overhead->Add(TraceEventMemoryOverhead::kHeapProfilerAllocationRegister,
-                allocated, resident);
+size_t AllocationRegister::EstimateAllocatedMemory() const {
+  return sizeof(AllocationRegister);
+}
+
+size_t AllocationRegister::EstimateResidentMemory() const {
+  return sizeof(AllocationRegister) + allocations_.EstimateUsedMemory() +
+         backtraces_.EstimateUsedMemory();
 }
 
 AllocationRegister::BacktraceMap::KVIndex AllocationRegister::InsertBacktrace(
     const Backtrace& backtrace) {
   auto index = backtraces_.Insert(backtrace, 0).first;
   if (index == BacktraceMap::kInvalidKVIndex)
     return kOutOfStorageBacktraceIndex;
   auto& backtrace_and_count = backtraces_.Get(index);
   backtrace_and_count.second++;
   return index;
@@ skipping 13 matching lines @@
   const auto& address_and_info = allocations_.Get(index);
   const auto& backtrace_and_count =
       backtraces_.Get(address_and_info.second.backtrace_index);
   return {address_and_info.first, address_and_info.second.size,
           AllocationContext(backtrace_and_count.first,
                             address_and_info.second.type_name)};
 }
 
 }  // namespace trace_event
 }  // namespace base