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 {
     const void* address;
     size_t size;
     AllocationContext context;
   };
 
+  struct BASE_EXPORT AddressHasher {
+    size_t operator()(const void* address) const;
+  };
+
   // An iterator that iterates entries in no particular order.
   class BASE_EXPORT ConstIterator {
    public:
     void operator++();
     bool operator!=(const ConstIterator& other) const;
     Allocation operator*() const;
 
    private:
     friend class AllocationRegister;
     using AllocationIndex = size_t;
@@ skipping 22 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
               // when an allocation that references the backtrace is inserted,
               // and decremented when the allocation is removed. When the
               // number drops to zero, the backtrace is removed from the map.
       BacktraceHasher>;
 
   struct AllocationInfo {
     size_t size;
     const char* type_name;
     BacktraceMap::KVIndex backtrace_index;
   };
 
-  struct AddressHasher {
-    size_t operator () (const void* address) const;
-  };
-
   using AllocationMap = internal::FixedHashMap<
       kAllocationBuckets,
       const void*,
       AllocationInfo,
       AddressHasher>;
 
   BacktraceMap::KVIndex InsertBacktrace(const Backtrace& backtrace);
   void RemoveBacktrace(BacktraceMap::KVIndex index);
 
   Allocation GetAllocation(AllocationMap::KVIndex) const;
 
   AllocationMap allocations_;
   BacktraceMap backtraces_;
 
   // Sentinel used when the |backtraces_| table is full.
   //
   // This is a slightly abstraction to allow for constant propagation. It
   // knows that the sentinel will be the first item inserted into the table
   // and that the first index retuned will be 0. The constructor DCHECKs
   // 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_