tcmalloc_unittest: Don't run Realloc test on low memory devices

base/allocator/tcmalloc_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdio.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/process/process_metrics.h"
+#include "base/sys_info.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_TCMALLOC)
 namespace {
 
 using std::min;
 
 #ifdef NDEBUG
 // We wrap malloc and free in noinline functions to ensure that we test the real
@@ skipping 58 matching lines @@
   } else {
     EXPECT_NE(reinterpret_cast<void*>(NULL), p)
         << "calloc(n, s) should succeed";
     for (size_t i = 0; i < n * s; i++) {
       EXPECT_EQ('\0', p[i]);
     }
     free(p);
   }
 }
 
+bool IsLowMemoryDevice() {
+  // 256MiB

[Primiano Tucci (use gerrit), 2017/04/04 14:10:51]

this is IMHO redundant given the code below, and just prone to end up out of
sync :)

[bcf, 2017/04/04 18:44:06]

Done.

+  return base::SysInfo::AmountOfPhysicalMemory() <= 256LL * 1024 * 1024;
+}
+
 }  // namespace
 
 TEST(TCMallocTest, Malloc) {
   // Try allocating data with a bunch of alignments and sizes
   for (int size = 1; size < 1048576; size *= 2) {
     unsigned char* ptr = reinterpret_cast<unsigned char*>(malloc(size));
     // Should be 2 byte aligned
     EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & 1);
     Fill(ptr, size);
     EXPECT_TRUE(Valid(ptr, size));
@@ skipping 34 matching lines @@
     for (unsigned d = 0; d < s * 2; ++d) {
       void* new_p = realloc(p, start_sizes[s] - deltas[d]);
       ASSERT_EQ(p, new_p);  // realloc should not allocate new memory
     }
     free(p);
   }
 }
 #endif
 
 TEST(TCMallocTest, Realloc) {
+  if (IsLowMemoryDevice())

[Primiano Tucci (use gerrit), 2017/04/04 14:10:51]

to be honest, you could have moved the early return to line 165. the top half is
quite small (NextSize goes up to 130k). the problem should be only the 1<<14
below, which * 8192 ends up using 130 MB.

In any case, can you please add a comment saying:

// The logic below tries to allocate kNumEntries * 9000 ~= 130 MB of memory.
This would cause the test to crash on low memory devices with no VM overcommit
(e.g., chromecast).

[bcf, 2017/04/04 18:44:06]

Done.

+    return;
+
   for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
     for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
       unsigned char* src = reinterpret_cast<unsigned char*>(malloc(src_size));
       Fill(src, src_size);
       unsigned char* dst =
           reinterpret_cast<unsigned char*>(realloc(src, dst_size));
       EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
       EXPECT_TRUE(Valid(dst, dst_size));
       if (dst != NULL)
         free(dst);
     }
   }
 

[Primiano Tucci (use gerrit), 2017/04/04 14:10:51]

to be honest, you could have moved the early return here. the top half is quite
small (NextSize goes up to 130k). the problem should be only the 1<<14 below,
which * 8192 ends up using 130 MB.

[bcf, 2017/04/04 18:44:06]

Done.

   // Now make sure realloc works correctly even when we overflow the
   // packed cache, so some entries are evicted from the cache.
   // The cache has 2^12 entries, keyed by page number.
   const int kNumEntries = 1 << 14;
   int** p = reinterpret_cast<int**>(malloc(sizeof(*p) * kNumEntries));
   int sum = 0;
   for (int i = 0; i < kNumEntries; i++) {
     // no page size is likely to be bigger than 8192?
     p[i] = reinterpret_cast<int*>(malloc(8192));
     p[i][1000] = i;  // use memory deep in the heart of p
@@ skipping 48 matching lines @@
   const size_t kPageSize = base::GetPageSize();
   for (size_t size = 1; size <= kPageSize; size <<= 1) {
     char* p = reinterpret_cast<char*>(TCMallocDoMallocForTest(size));
     ASSERT_DEATH(TCMallocDoFreeForTest(p); TCMallocDoFreeForTest(p),
                  "Circular loop in list detected");
   }
 }
 #endif  // NDEBUG
 
 #endif