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

base/trace_event/heap_profiler_allocation_register_unittest.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/process/process_metrics.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 class AllocationRegisterTest : public testing::Test {
  public:
   static const uint32_t kNumBuckets = AllocationRegister::kNumBuckets;
-  static const uint32_t kNumCells = AllocationRegister::kNumCells;
 
   // Returns the number of cells that the |AllocationRegister| can store per
   // system page.
   size_t GetNumCellsPerPage() {
     return GetPageSize() / sizeof(AllocationRegister::Cell);
   }
 
   uint32_t GetHighWaterMark(const AllocationRegister& reg) {
     return reg.next_unused_cell_;
   }
+
+  uint32_t GetNumCells(const AllocationRegister& reg) {
+    return reg.num_cells_;
+  }
 };
 
 // Iterates over all entries in the allocation register and returns the bitwise
 // or of all addresses stored in it.
 uintptr_t OrAllAddresses(const AllocationRegister& reg) {
   uintptr_t acc = 0;
 
   for (auto i : reg)
     acc |= reinterpret_cast<uintptr_t>(i.address);
 
@@ skipping 158 matching lines @@
 
   // Inserting one more entry should use a fresh cell again.
   reg.Insert(reinterpret_cast<void*>(prime), 0, ctx);
   ASSERT_EQ(prime - 1, GetHighWaterMark(reg) - initial_water_mark);
 }
 
 // Check that the process aborts due to hitting the guard page when inserting
 // too many elements.
 #if GTEST_HAS_DEATH_TEST
 TEST_F(AllocationRegisterTest, OverflowDeathTest) {
-  AllocationRegister reg;
+  // Use a smaller register to prevent OOM errors on low-end devices.
+  AllocationRegister reg(kNumBuckets * 5);

[Ruud van Asseldonk, 2015/12/17 10:10:06]

Now that this is configurable, we might as well pick a small value such as
|GetNumCellsPerPage()| or 32 (the value of |GetNumCellsPerPage()| for x64 with
4096-byte pages) here. It will have the additional benefit of speeding up the
test.

[seantopping, 2015/12/17 20:07:32]

Done.

   AllocationContext ctx = AllocationContext::Empty();
   uintptr_t i;
 
-  // Fill up all of the memory allocated for the register. |kNumCells| minus 1
-  // elements are inserted, because cell 0 is unused, so this should fill up
-  // the available cells exactly.
-  for (i = 1; i < kNumCells; i++) {
+  // Fill up all of the memory allocated for the register. |GetNumCells(reg)|
+  // minus 1 elements are inserted, because cell 0 is unused, so this should
+  // fill up the available cells exactly.
+  for (i = 1; i < GetNumCells(reg); i++) {
     reg.Insert(reinterpret_cast<void*>(i), 0, ctx);
   }
 
   // Adding just one extra element might still work because the allocated memory
   // is rounded up to the page size. Adding a page full of elements should cause
   // overflow.
   const size_t cells_per_page = GetNumCellsPerPage();
 
   ASSERT_DEATH(for (size_t j = 0; j < cells_per_page; j++) {
     reg.Insert(reinterpret_cast<void*>(i + j), 0, ctx);
   }, "");
 }
 #endif
 
 }  // namespace trace_event
 }  // namespace base