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

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 <stdint.h>
 
 #include "base/logging.h"
@@ skipping 42 matching lines @@
     friend class AllocationRegister;
     using CellIndex = uint32_t;
 
     ConstIterator(const AllocationRegister& alloc_register, CellIndex index);
 
     const AllocationRegister& register_;
     CellIndex index_;
   };
 
   AllocationRegister();
-  explicit AllocationRegister(uint32_t num_cells);
-
   ~AllocationRegister();
 
   // Inserts allocation details into the table. If the address was present
   // already, its details are updated. |address| must not be null. (This is
   // because null is used to mark free cells, to allow efficient iteration of
   // the hash table.)
   void Insert(void* address, size_t size, AllocationContext context);
 
   // Removes the address from the table if it is present. It is ok to call this
   // with a null pointer.
@@ skipping 32 matching lines @@
   static const uint32_t kNumBuckets = 0x40000;
   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;
+  static const uint32_t kNumCells = kNumBuckets * 10;
 
   // Returns a value in the range [0, kNumBuckets - 1] (inclusive).
   static uint32_t Hash(void* address);
 
   // 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
   // added after the end.
   static void* AllocateVirtualMemory(size_t size);
 
   // Frees a region of virtual address space allocated by a call to
   // |AllocateVirtualMemory|.
   static void FreeVirtualMemory(void* address, size_t allocated_size);
 
   // Returns a pointer to the variable that contains or should contain the
   // index of the cell that stores the entry for |address|. The pointer may
   // point at an element of |buckets_| or at the |next| member of an element of
   // |cells_|. If the value pointed at is 0, |address| is not in the table.
   CellIndex* Lookup(void* address);
 
   // Takes a cell that is not being used to store an entry (either by recycling
   // from the free list or by taking a fresh cell) and returns its index.
   CellIndex GetFreeCell();
 
-  // The maximum number of cells which can be allocated.
-  uint32_t const num_cells_;
-
   // The array of cells. This array is backed by mmapped memory. Lower indices
   // are accessed first, higher indices are only accessed when required. In
   // this way, even if a huge amount of address space has been mmapped, only
   // the cells that are actually used will be backed by physical memory.
   Cell* const cells_;
 
   // The array of indices into |cells_|. |buckets_[Hash(address)]| will contain
   // the index of the head of the linked list for |Hash(address)|. A value of 0
   // indicates an empty list. This array is backed by mmapped memory.
   CellIndex* const buckets_;
 
   // The head of the free list. This is the index of the cell. A value of 0
   // means that the free list is empty.
   CellIndex free_list_;
 
   // 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.
   CellIndex next_unused_cell_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationRegister);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_REGISTER_H_