base/allocator/partition_alloc: make unittests lowmem friendly

base/allocator/partition_allocator/partition_alloc_unittest.cc

 // Copyright (c) 2013 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/allocator/partition_allocator/partition_alloc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bits.h"
+#include "base/sys_info.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
@@ skipping 153 matching lines @@
 }
 
 void CheckPageInCore(void* ptr, bool inCore) {
 #if defined(OS_LINUX)
   unsigned char ret;
   EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
   EXPECT_EQ(inCore, ret);
 #endif
 }
 
+bool IsLargeMemoryDevice() {
+  return base::SysInfo::AmountOfPhysicalMemory() >= 2LL * 1024 * 1024 * 1024;
+}
+
 class MockPartitionStatsDumper : public PartitionStatsDumper {
  public:
   MockPartitionStatsDumper()
       : m_totalResidentBytes(0),
         m_totalActiveBytes(0),
         m_totalDecommittableBytes(0),
         m_totalDiscardableBytes(0) {}
 
   void partitionDumpTotals(const char* partitionName,
                            const PartitionMemoryStats* memoryStats) override {
@@ skipping 465 matching lines @@
   // enabled, the allocated area is overwritten with an "uninitialized"
   // byte pattern.
   EXPECT_EQ(0, *(reinterpret_cast<char*>(newPtr) + (size - 1)));
 #endif
   partitionFreeGeneric(genericAllocator.root(), newPtr);
   partitionFreeGeneric(genericAllocator.root(), ptr3);
   partitionFreeGeneric(genericAllocator.root(), ptr4);
 
   // Can we allocate a massive (512MB) size?
   // Allocate 512MB, but +1, to test for cookie writing alignment issues.
-  ptr = partitionAllocGeneric(genericAllocator.root(), 512 * 1024 * 1024 + 1,
-                              typeName);
-  partitionFreeGeneric(genericAllocator.root(), ptr);
+  // Test this only if the device has enough memory or it might fail due
+  // to OOM.
+  if (IsLargeMemoryDevice()) {
+    ptr = partitionAllocGeneric(genericAllocator.root(), 512 * 1024 * 1024 + 1,
+                                typeName);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+  }
 
   // Check a more reasonable, but still direct mapped, size.
   // Chop a system page and a byte off to test for rounding errors.
   size = 20 * 1024 * 1024;
   size -= kSystemPageSize;
   size -= 1;
   ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
   char* charPtr = reinterpret_cast<char*>(ptr);
   *(charPtr + (size - 1)) = 'A';
   partitionFreeGeneric(genericAllocator.root(), ptr);
@@ skipping 50 matching lines @@
   EXPECT_TRUE(ptr);
   actualSize = partitionAllocGetSize(ptr);
   EXPECT_EQ(predictedSize, actualSize);
   EXPECT_EQ(requestedSize + kSystemPageSize, actualSize);
   // Check that we can write at the end of the reported size too.
   char* charPtr = reinterpret_cast<char*>(ptr);
   *(charPtr + (actualSize - 1)) = 'A';
   partitionFreeGeneric(genericAllocator.root(), ptr);
 
   // Allocate something very large, and uneven.
-  requestedSize = 512 * 1024 * 1024 - 1;
-  predictedSize =
-      partitionAllocActualSize(genericAllocator.root(), requestedSize);
-  ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
-  EXPECT_TRUE(ptr);
-  actualSize = partitionAllocGetSize(ptr);
-  EXPECT_EQ(predictedSize, actualSize);
-  EXPECT_LT(requestedSize, actualSize);
-  partitionFreeGeneric(genericAllocator.root(), ptr);
+  if (IsLargeMemoryDevice()) {
+    requestedSize = 512 * 1024 * 1024 - 1;
+    predictedSize =
+        partitionAllocActualSize(genericAllocator.root(), requestedSize);
+    ptr =
+        partitionAllocGeneric(genericAllocator.root(), requestedSize, typeName);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(ptr);
+    EXPECT_EQ(predictedSize, actualSize);
+    EXPECT_LT(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+  }
 
   // Too large allocation.
   requestedSize = INT_MAX;
   predictedSize =
       partitionAllocActualSize(genericAllocator.root(), requestedSize);
   EXPECT_EQ(requestedSize, predictedSize);
 
   TestShutdown();
 }
 
@@ skipping 554 matching lines @@
 //
 // Disable this test on Android because, due to its allocation-heavy behavior,
 // it tends to get OOM-killed rather than pass.
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 #define MAYBE_RepeatedReturnNullDirect DISABLED_RepeatedReturnNullDirect
 #else
 #define MAYBE_RepeatedReturnNullDirect RepeatedReturnNullDirect
 #endif
 TEST(PartitionAllocTest, MAYBE_RepeatedReturnNullDirect) {
   // A direct-mapped allocation size.
-  DoReturnNullTest(256 * 1024 * 1024);
+  DoReturnNullTest(32 * 1024 * 1024);
 }
 
 #endif  // !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
 // Death tests misbehave on Android, http://crbug.com/643760.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 
 // Make sure that malloc(-1) dies.
 // In the past, we had an integer overflow that would alias malloc(-1) to
 // malloc(0), which is not good.
@@ skipping 759 matching lines @@
     partitionFreeGeneric(genericAllocator.root(), ptr1);
     partitionFreeGeneric(genericAllocator.root(), ptr2);
   }
 
   TestShutdown();
 }
 
 }  // namespace base
 
 #endif  // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)