Increase allocation register capacity for desktop platforms

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>
 
 #include <utility>
 
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process_metrics.h"
 #include "base/template_util.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
+#include "build/build_config.h"
 
 namespace base {
 namespace trace_event {
 
 class AllocationRegisterTest;
 
 namespace internal {
 
 // Allocates a region of virtual address space of |size| rounded up to the
 // system page size. The memory is zeroed by the system. A guard page is
@@ skipping 162 matching lines @@
     // was reserved for |cells_|), |next_unused_cell_| can be an index outside
     // of the allocated storage. A guard page is allocated there to crash the
     // program in that case. There are alternative solutions:
     // - Deal with it, increase capacity by reallocating |cells_|.
     // - Refuse to insert and let the caller deal with it.
     // Because free cells are re-used before accessing fresh cells with a higher
     // index, and because reserving address space without touching it is cheap,
     // the simplest solution is to just allocate a humongous chunk of address
     // space.
 
-    DCHECK_LT(next_unused_cell_, num_cells_ + 1);
+    CHECK_LT(next_unused_cell_, num_cells_ + 1)
+        << "Allocation Register hash table has too little capacity. Increase "
+           "the capacity to run heap profiler in large sessions.";
 
     return &cells_[idx];
   }
 
   // Returns a value in the range [0, NumBuckets - 1] (inclusive).
   size_t Hash(const Key& key) const {
     if (NumBuckets == (NumBuckets & ~(NumBuckets - 1))) {
       // NumBuckets is a power of 2.
       return KeyHasher()(key) & (NumBuckets - 1);
     } else {
@@ skipping 80 matching lines @@
 
   ConstIterator begin() const;
   ConstIterator end() const;
 
   // Estimates memory overhead including |sizeof(AllocationRegister)|.
   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead) const;
 
  private:
   friend AllocationRegisterTest;
 
-  // Expect max 1.5M allocations. Number of buckets is 2^18 for optimal
-  // hashing and should be changed together with AddressHasher.
+// 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)
   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;
+#endif
 
   // 2^16 works well with BacktraceHasher. When increasing this number make
   // sure BacktraceHasher still produces low number of collisions.
   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
 #endif
 
@@ skipping 34 matching lines @@
   AllocationMap allocations_;
   BacktraceMap backtraces_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationRegister);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_