Enable sharding of AllocationRegister on desktop.

base/trace_event/heap_profiler_allocation_register.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 229 matching lines @@
   // The index of the first element of |cells_| that has not been used before.
   // If the free list is empty and a new cell is needed, the cell at this index
   // is used. This is the high water mark for the number of entries stored.
   size_t next_unused_cell_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedHashMap);
 };
 
 }  // namespace internal
 
-class TraceEventMemoryOverhead;
-
 // The allocation register keeps track of all allocations that have not been
 // freed. Internally it has two hashtables: one for Backtraces and one for
 // actual allocations. Sizes of both hashtables are fixed, and this class
 // allocates (mmaps) only in its constructor.
 //
 // When either hash table hits max size, new inserts are dropped.
 class BASE_EXPORT AllocationRegister {
  public:
   // Details about an allocation.
   struct Allocation {
@@ skipping 37 matching lines @@
   // Removes the address from the table if it is present. It is ok to call this
   // with a null pointer.
   void Remove(const void* address);
 
   // Finds allocation for the address and fills |out_allocation|.
   bool Get(const void* address, Allocation* out_allocation) const;
 
   ConstIterator begin() const;
   ConstIterator end() const;
 
-  // Estimates memory overhead including |sizeof(AllocationRegister)|.
-  void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) const;
+  // Estimates memory in use.
+  size_t EstimateAllocatedMemory() const;
+  size_t EstimateResidentMemory() const;
 
  private:
   friend AllocationRegisterTest;
 
 // Expect lower number of allocations from mobile platforms. Load factor
 // (capacity / bucket count) is kept less than 10 for optimal hashing. The
 // number of buckets should be changed together with AddressHasher.
 #if defined(OS_ANDROID) || defined(OS_IOS)
+  // Note that allocations are currently sharded over 1 different instance of
+  // AllocationRegister. See "base/trace_event/malloc_dump_provider.cc".
   static const size_t kAllocationBuckets = 1 << 18;
   static const size_t kAllocationCapacity = 1500000;
 #else
-  static const size_t kAllocationBuckets = 1 << 19;
-  static const size_t kAllocationCapacity = 5000000;
+  // Note that allocations are currently sharded over 256 different instances of
+  // AllocationRegister. See "base/trace_event/malloc_dump_provider.cc".
+  static const size_t kAllocationBuckets = 1 << 16;
+  static const size_t kAllocationCapacity = 400000;
 #endif
 
-  // 2^16 works well with BacktraceHasher. When increasing this number make
-  // sure BacktraceHasher still produces low number of collisions.
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  // Note that allocations are currently sharded over 1 different instance of
+  // AllocationRegister. See "base/trace_event/malloc_dump_provider.cc".
   static const size_t kBacktraceBuckets = 1 << 16;
-#if defined(OS_ANDROID)
   static const size_t kBacktraceCapacity = 32000;  // 22K was observed
 #else
-  static const size_t kBacktraceCapacity = 55000;  // 45K was observed on Linux
+  // Note that allocations are currently sharded over 256 different instances of
+  // AllocationRegister. See "base/trace_event/malloc_dump_provider.cc".
+  static const size_t kBacktraceBuckets = 1 << 12;
+  static const size_t kBacktraceCapacity = 10000;  // 45K was observed on Linux
 #endif
 
   struct BacktraceHasher {
     size_t operator () (const Backtrace& backtrace) const;
   };
 
   using BacktraceMap = internal::FixedHashMap<
       kBacktraceBuckets,
       Backtrace,
       size_t, // Number of references to the backtrace (the key). Incremented
@@ skipping 34 matching lines @@
   // this assumption.
   enum : BacktraceMap::KVIndex { kOutOfStorageBacktraceIndex = 0 };
 
   DISALLOW_COPY_AND_ASSIGN(AllocationRegister);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_