[tracing] Increase backtrace map capacity on Linux.

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 27 matching lines @@
 template <size_t NumBuckets, class Key, class Value, class KeyHasher>
 class FixedHashMap {
   // To keep things simple we don't call destructors.
   static_assert(is_trivially_destructible<Key>::value &&
                     is_trivially_destructible<Value>::value,
                 "Key and Value shouldn't have destructors");
  public:
   using KVPair = std::pair<const Key, Value>;
 
   // For implementation simplicity API uses integer index instead
-  // of iterators. Most operations (except FindValidIndex) on KVIndex
-  // are O(1).
+  // of iterators. Most operations (except Find) on KVIndex are O(1).
   using KVIndex = size_t;
   static const KVIndex kInvalidKVIndex = static_cast<KVIndex>(-1);
 
   // Capacity controls how many items this hash map can hold, and largely
   // affects memory footprint.
   FixedHashMap(size_t capacity)
     : num_cells_(capacity),
       cells_(static_cast<Cell*>(
           AllocateGuardedVirtualMemory(num_cells_ * sizeof(Cell)))),
       buckets_(static_cast<Bucket*>(
@@ skipping 238 matching lines @@
   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.
   static const size_t kAllocationBuckets = 1 << 18;
   static const size_t kAllocationCapacity = 1500000;
 
-  // Expect max 2^15 unique backtraces. Can be changed to 2^16 without
-  // needing to tweak BacktraceHasher implementation.
-  static const size_t kBacktraceBuckets = 1 << 15;
-  static const size_t kBacktraceCapacity = kBacktraceBuckets;
+  // 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

[Primiano Tucci (use gerrit), 2016/08/03 13:15:01]

maybe just go for 64k or 128k? On linux we usually have wayyyy more memory.

+#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,
@@ skipping 25 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_