[Tracing] Adjust allocation register size for low-end devices

base/trace_event/heap_profiler_allocation_register.cc

 // 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.
 
 #include "base/trace_event/heap_profiler_allocation_register.h"
 
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
 
 AllocationRegister::AllocationRegister()
-    // Reserve enough address space to store |kNumCells| entries if necessary,
+    : AllocationRegister(kNumBuckets * kNumCellsPerBucket) {}
+
+AllocationRegister::AllocationRegister(uint32_t num_cells)
+    // Reserve enough address space to store |num_cells_| entries if necessary,
     // with a guard page after it to crash the program when attempting to store
     // more entries.
-    : cells_(static_cast<Cell*>(AllocateVirtualMemory(kNumCells *
+    : num_cells_(num_cells),
+      cells_(static_cast<Cell*>(AllocateVirtualMemory(num_cells_ *
                                                       sizeof(Cell)))),
       buckets_(static_cast<CellIndex*>(
           AllocateVirtualMemory(kNumBuckets * sizeof(CellIndex)))),
 
       // The free list is empty. The first unused cell is cell 1, because index
       // 0 is used as list terminator.
       free_list_(0),
       next_unused_cell_(1) {}
 
+
 AllocationRegister::~AllocationRegister() {
   FreeVirtualMemory(buckets_, kNumBuckets * sizeof(CellIndex));
-  FreeVirtualMemory(cells_, kNumCells * sizeof(Cell));
+  FreeVirtualMemory(cells_, num_cells_ * sizeof(Cell));
 }
 
 void AllocationRegister::Insert(void* address,
                                 size_t size,
                                 AllocationContext context) {
   DCHECK(address != nullptr);
 
   CellIndex* idx_ptr = Lookup(address);
 
   // If the index is 0, the address is not yet present, so insert it.
@@ skipping 98 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_, kNumCells + 1);
+  DCHECK_LT(next_unused_cell_, num_cells_ + 1);
 
   return idx;
 }
 
 // static
 uint32_t AllocationRegister::Hash(void* address) {
   // The multiplicative hashing scheme from [Knuth 1998]. The value of |a| has
   // been chosen carefully based on measurements with real-word data (addresses
   // recorded from a Chrome trace run). It is the first prime after 2^17. For
   // |shift|, 13, 14 and 15 yield good results. These values are tuned to 2^18
@@ skipping 15 matching lines @@
   size_t resident = sizeof(AllocationRegister)
                     // Include size of touched cells (size of |*cells_|).
                     + sizeof(Cell) * next_unused_cell_
                     // Size of |*buckets_|.
                     + sizeof(CellIndex) * kNumBuckets;
   overhead->Add("AllocationRegister", allocated, resident);
 }
 
 }  // namespace trace_event
 }  // namespace base