[tracing] Reduce number of buckets in AllocationRegister.

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 83 matching lines @@
   // are part of a linked list via the |next| member. This list is either the
   // list for a particular hash, or the free list. All cells are contiguous in
   // memory in one big array. Therefore, on 64-bit systems, space can be saved
   // by storing 32-bit indices instead of pointers as links. Index 0 is used as
   // the list terminator.
   struct Cell {
     CellIndex next;
     Allocation allocation;
   };
 
-  // The number of buckets, 2^18, approximately 260 000, has been tuned for
+  // The number of buckets, 2^17, approximately 130 000, has been tuned for
   // Chrome's typical number of outstanding allocations. (This number varies
   // between processes. Most processes have a sustained load of ~30k unfreed
   // allocations, but some processes have peeks around 100k-400k allocations.)
   // Because of the size of the table, it is likely that every |buckets_|
   // access and every |cells_| access will incur a cache miss. Microbenchmarks
   // suggest that it is worthwile to use more memory for the table to avoid
   // chasing down the linked list, until the size is 2^18. The number of buckets
   // is a power of two so modular indexing can be done with bitwise and.
-  static const uint32_t kNumBuckets = 0x40000;
+  static const uint32_t kNumBuckets = 0x20000;
   static const uint32_t kNumBucketsMask = kNumBuckets - 1;
 
   // Reserve address space to store at most this number of entries. High
   // capacity does not imply high memory usage due to the access pattern. The
   // only constraint on the number of cells is that on 32-bit systems address
   // space is scarce (i.e. reserving 2GiB of address space for the entries is
   // not an option). A value of ~3M entries is large enough to handle spikes in
   // the number of allocations, and modest enough to require no more than a few
   // dozens of MiB of address space.
   static const uint32_t kNumCellsPerBucket = 10;
@@ skipping 43 matching lines @@
   // is used. This is the high water mark for the number of entries stored.
   CellIndex next_unused_cell_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationRegister);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_