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() {
+  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 48 matching lines @@
       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);
     }
   }
 
+  // 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).
+  if (IsLowMemoryDevice())
+    return;
+
   // 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