base/memory/discardable_memory_ashmem_allocator_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/discardable_memory_ashmem_allocator.h"
   6
   7 #include <sys/types.h>
   8 #include <unistd.h>
   9
  10 #include "base/memory/discardable_memory.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "build/build_config.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace base {
  19 namespace internal {
  20
  21 const char kAllocatorName[] = "allocator-for-testing";
  22
  23 const size_t kAshmemRegionSizeForTesting = 32 * 1024 * 1024;
  24 const size_t kPageSize = 4096;
  25
  26 const size_t kMaxAllowedAllocationSize =
  27     std::numeric_limits<size_t>::max() - kPageSize + 1;
  28
  29 class DiscardableMemoryAshmemAllocatorTest : public testing::Test {
  30  protected:
  31   DiscardableMemoryAshmemAllocatorTest()
  32       : allocator_(kAllocatorName, kAshmemRegionSizeForTesting) {
  33   }
  34
  35   DiscardableMemoryAshmemAllocator allocator_;
  36 };
  37
  38 void WriteToDiscardableAshmemChunk(DiscardableAshmemChunk* memory,
  39                                    size_t size) {
  40   // Write to the first and the last pages only to avoid paging in up to 64
  41   // MBytes.
  42   static_cast<char*>(memory->Memory())[0] = 'a';
  43   static_cast<char*>(memory->Memory())[size - 1] = 'a';
  44 }
  45
  46 TEST_F(DiscardableMemoryAshmemAllocatorTest, Basic) {
  47   const size_t size = 128;
  48   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(size));
  49   ASSERT_TRUE(memory);
  50   WriteToDiscardableAshmemChunk(memory.get(), size);
  51 }
  52
  53 TEST_F(DiscardableMemoryAshmemAllocatorTest, ZeroAllocationIsNotSupported) {
  54   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(0));
  55   ASSERT_FALSE(memory);
  56 }
  57
  58 TEST_F(DiscardableMemoryAshmemAllocatorTest, TooLargeAllocationFails) {
  59   scoped_ptr<DiscardableAshmemChunk> memory(
  60       allocator_.Allocate(kMaxAllowedAllocationSize + 1));
  61   // Page-alignment would have caused an overflow resulting in a small
  62   // allocation if the input size wasn't checked correctly.
  63   ASSERT_FALSE(memory);
  64 }
  65
  66 TEST_F(DiscardableMemoryAshmemAllocatorTest,
  67        AshmemRegionsAreNotSmallerThanRequestedSize) {
  68   // The creation of the underlying ashmem region is expected to fail since
  69   // there should not be enough room in the address space. When ashmem creation
  70   // fails, the allocator repetitively retries by dividing the size by 2. This
  71   // size should not be smaller than the size the user requested so the
  72   // allocation here should just fail (and not succeed with the minimum ashmem
  73   // region size).
  74   scoped_ptr<DiscardableAshmemChunk> memory(
  75       allocator_.Allocate(kMaxAllowedAllocationSize));
  76   ASSERT_FALSE(memory);
  77 }
  78
  79 TEST_F(DiscardableMemoryAshmemAllocatorTest,
  80        AshmemRegionsAreAlwaysPageAligned) {
  81   // Use a separate allocator here so that we can override the ashmem region
  82   // size.
  83   DiscardableMemoryAshmemAllocator allocator(
  84       kAllocatorName, kMaxAllowedAllocationSize);
  85   scoped_ptr<DiscardableAshmemChunk> memory(allocator.Allocate(kPageSize));
  86   ASSERT_TRUE(memory);
  87   EXPECT_GT(kMaxAllowedAllocationSize, allocator.last_ashmem_region_size());
  88   ASSERT_TRUE(allocator.last_ashmem_region_size() % kPageSize == 0);
  89 }
  90
  91 TEST_F(DiscardableMemoryAshmemAllocatorTest, LargeAllocation) {
  92   const size_t size = 64 * 1024 * 1024;
  93   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(size));
  94   ASSERT_TRUE(memory);
  95   WriteToDiscardableAshmemChunk(memory.get(), size);
  96 }
  97
  98 TEST_F(DiscardableMemoryAshmemAllocatorTest, ChunksArePageAligned) {
  99   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize));
 100   ASSERT_TRUE(memory);
 101   EXPECT_EQ(0U, reinterpret_cast<uint64_t>(memory->Memory()) % kPageSize);
 102   WriteToDiscardableAshmemChunk(memory.get(), kPageSize);
 103 }
 104
 105 TEST_F(DiscardableMemoryAshmemAllocatorTest, AllocateFreeAllocate) {
 106   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize));
 107   // Extra allocation that prevents the region from being deleted when |memory|
 108   // gets deleted.
 109   scoped_ptr<DiscardableAshmemChunk> memory_lock(
 110       allocator_.Allocate(kPageSize));
 111   ASSERT_TRUE(memory);
 112   void* const address = memory->Memory();
 113   memory->Unlock();  // Tests that the reused chunk is being locked correctly.
 114   memory.reset();
 115   memory = allocator_.Allocate(kPageSize);
 116   ASSERT_TRUE(memory);
 117   // The previously freed chunk should be reused.
 118   EXPECT_EQ(address, memory->Memory());
 119   WriteToDiscardableAshmemChunk(memory.get(), kPageSize);
 120 }
 121
 122 TEST_F(DiscardableMemoryAshmemAllocatorTest,
 123        FreeingWholeAshmemRegionClosesAshmem) {
 124   scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize));
 125   ASSERT_TRUE(memory);
 126   const int kMagic = 0xdeadbeef;
 127   *static_cast<int*>(memory->Memory()) = kMagic;
 128   memory.reset();
 129   // The previous ashmem region should have been closed thus it should not be
 130   // reused.
 131   memory = allocator_.Allocate(kPageSize);
 132   ASSERT_TRUE(memory);
 133   EXPECT_NE(kMagic, *static_cast<const int*>(memory->Memory()));
 134 }
 135
 136 TEST_F(DiscardableMemoryAshmemAllocatorTest, AllocateUsesBestFitAlgorithm) {
 137   scoped_ptr<DiscardableAshmemChunk> memory1(
 138       allocator_.Allocate(3 * kPageSize));
 139   ASSERT_TRUE(memory1);
 140   scoped_ptr<DiscardableAshmemChunk> memory2(
 141       allocator_.Allocate(2 * kPageSize));
 142   ASSERT_TRUE(memory2);
 143   scoped_ptr<DiscardableAshmemChunk> memory3(
 144       allocator_.Allocate(1 * kPageSize));
 145   ASSERT_TRUE(memory3);
 146   void* const address_3 = memory3->Memory();
 147   memory1.reset();
 148   // Don't free |memory2| to avoid merging the 3 blocks together.
 149   memory3.reset();
 150   memory1 = allocator_.Allocate(1 * kPageSize);
 151   ASSERT_TRUE(memory1);
 152   // The chunk whose size is closest to the requested size should be reused.
 153   EXPECT_EQ(address_3, memory1->Memory());
 154   WriteToDiscardableAshmemChunk(memory1.get(), kPageSize);
 155 }
 156
 157 TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunks) {
 158   scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(kPageSize));
 159   ASSERT_TRUE(memory1);
 160   scoped_ptr<DiscardableAshmemChunk> memory2(allocator_.Allocate(kPageSize));
 161   ASSERT_TRUE(memory2);
 162   scoped_ptr<DiscardableAshmemChunk> memory3(allocator_.Allocate(kPageSize));
 163   ASSERT_TRUE(memory3);
 164   scoped_ptr<DiscardableAshmemChunk> memory4(allocator_.Allocate(kPageSize));
 165   ASSERT_TRUE(memory4);
 166   void* const memory1_address = memory1->Memory();
 167   memory1.reset();
 168   memory3.reset();
 169   // Freeing |memory2| (located between memory1 and memory3) should merge the
 170   // three free blocks together.
 171   memory2.reset();
 172   memory1 = allocator_.Allocate(3 * kPageSize);
 173   EXPECT_EQ(memory1_address, memory1->Memory());
 174 }
 175
 176 TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunksAdvanced) {
 177   scoped_ptr<DiscardableAshmemChunk> memory1(
 178       allocator_.Allocate(4 * kPageSize));
 179   ASSERT_TRUE(memory1);
 180   scoped_ptr<DiscardableAshmemChunk> memory2(
 181       allocator_.Allocate(4 * kPageSize));
 182   ASSERT_TRUE(memory2);
 183   void* const memory1_address = memory1->Memory();
 184   memory1.reset();
 185   memory1 = allocator_.Allocate(2 * kPageSize);
 186   memory2.reset();
 187   // At this point, the region should be in this state:
 188   // 8 KBytes (used), 24 KBytes (free).
 189   memory2 = allocator_.Allocate(6 * kPageSize);
 190   EXPECT_EQ(
 191       static_cast<const char*>(memory2->Memory()),
 192       static_cast<const char*>(memory1_address) + 2 * kPageSize);
 193 }
 194
 195 TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunksAdvanced2) {
 196   scoped_ptr<DiscardableAshmemChunk> memory1(
 197       allocator_.Allocate(4 * kPageSize));
 198   ASSERT_TRUE(memory1);
 199   scoped_ptr<DiscardableAshmemChunk> memory2(
 200       allocator_.Allocate(4 * kPageSize));
 201   ASSERT_TRUE(memory2);
 202   void* const memory1_address = memory1->Memory();
 203   memory1.reset();
 204   memory1 = allocator_.Allocate(2 * kPageSize);
 205   scoped_ptr<DiscardableAshmemChunk> memory3(
 206       allocator_.Allocate(2 * kPageSize));
 207   // At this point, the region should be in this state:
 208   // 8 KBytes (used), 8 KBytes (used), 16 KBytes (used).
 209   memory3.reset();
 210   memory2.reset();
 211   // At this point, the region should be in this state:
 212   // 8 KBytes (used), 24 KBytes (free).
 213   memory2 = allocator_.Allocate(6 * kPageSize);
 214   EXPECT_EQ(
 215       static_cast<const char*>(memory2->Memory()),
 216       static_cast<const char*>(memory1_address) + 2 * kPageSize);
 217 }
 218
 219 TEST_F(DiscardableMemoryAshmemAllocatorTest,
 220        MergeFreeChunksAndDeleteAshmemRegion) {
 221   scoped_ptr<DiscardableAshmemChunk> memory1(
 222       allocator_.Allocate(4 * kPageSize));
 223   ASSERT_TRUE(memory1);
 224   scoped_ptr<DiscardableAshmemChunk> memory2(
 225       allocator_.Allocate(4 * kPageSize));
 226   ASSERT_TRUE(memory2);
 227   memory1.reset();
 228   memory1 = allocator_.Allocate(2 * kPageSize);
 229   scoped_ptr<DiscardableAshmemChunk> memory3(
 230       allocator_.Allocate(2 * kPageSize));
 231   // At this point, the region should be in this state:
 232   // 8 KBytes (used), 8 KBytes (used), 16 KBytes (used).
 233   memory1.reset();
 234   memory3.reset();
 235   // At this point, the region should be in this state:
 236   // 8 KBytes (free), 8 KBytes (used), 8 KBytes (free).
 237   const int kMagic = 0xdeadbeef;
 238   *static_cast<int*>(memory2->Memory()) = kMagic;
 239   memory2.reset();
 240   // The whole region should have been deleted.
 241   memory2 = allocator_.Allocate(2 * kPageSize);
 242   EXPECT_NE(kMagic, *static_cast<int*>(memory2->Memory()));
 243 }
 244
 245 TEST_F(DiscardableMemoryAshmemAllocatorTest,
 246      TooLargeFreeChunksDontCauseTooMuchFragmentationWhenRecycled) {
 247   // Keep |memory_1| below allocated so that the ashmem region doesn't get
 248   // closed when |memory_2| is deleted.
 249   scoped_ptr<DiscardableAshmemChunk> memory_1(allocator_.Allocate(64 * 1024));
 250   ASSERT_TRUE(memory_1);
 251   scoped_ptr<DiscardableAshmemChunk> memory_2(allocator_.Allocate(32 * 1024));
 252   ASSERT_TRUE(memory_2);
 253   void* const address = memory_2->Memory();
 254   memory_2.reset();
 255   const size_t size = 16 * 1024;
 256   memory_2 = allocator_.Allocate(size);
 257   ASSERT_TRUE(memory_2);
 258   EXPECT_EQ(address, memory_2->Memory());
 259   WriteToDiscardableAshmemChunk(memory_2.get(), size);
 260   scoped_ptr<DiscardableAshmemChunk> memory_3(allocator_.Allocate(size));
 261   // The unused tail (16 KBytes large) of the previously freed chunk should be
 262   // reused.
 263   EXPECT_EQ(static_cast<char*>(address) + size, memory_3->Memory());
 264   WriteToDiscardableAshmemChunk(memory_3.get(), size);
 265 }
 266
 267 TEST_F(DiscardableMemoryAshmemAllocatorTest, UseMultipleAshmemRegions) {
 268   // Leave one page untouched at the end of the ashmem region.
 269   const size_t size = kAshmemRegionSizeForTesting - kPageSize;
 270   scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(size));
 271   ASSERT_TRUE(memory1);
 272   WriteToDiscardableAshmemChunk(memory1.get(), size);
 273
 274   scoped_ptr<DiscardableAshmemChunk> memory2(
 275       allocator_.Allocate(kAshmemRegionSizeForTesting));
 276   ASSERT_TRUE(memory2);
 277   WriteToDiscardableAshmemChunk(memory2.get(), kAshmemRegionSizeForTesting);
 278   // The last page of the first ashmem region should be used for this
 279   // allocation.
 280   scoped_ptr<DiscardableAshmemChunk> memory3(allocator_.Allocate(kPageSize));
 281   ASSERT_TRUE(memory3);
 282   WriteToDiscardableAshmemChunk(memory3.get(), kPageSize);
 283   EXPECT_EQ(memory3->Memory(), static_cast<char*>(memory1->Memory()) + size);
 284 }
 285
 286 TEST_F(DiscardableMemoryAshmemAllocatorTest,
 287        HighestAllocatedChunkPointerIsUpdatedWhenHighestChunkGetsSplit) {
 288   // Prevents the ashmem region from getting closed when |memory2| gets freed.
 289   scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(kPageSize));
 290   ASSERT_TRUE(memory1);
 291
 292   scoped_ptr<DiscardableAshmemChunk> memory2(
 293       allocator_.Allocate(4 * kPageSize));
 294   ASSERT_TRUE(memory2);
 295
 296   memory2.reset();
 297   memory2 = allocator_.Allocate(kPageSize);
 298   // There should now be a free chunk of size 3 * |kPageSize| starting at offset
 299   // 2 * |kPageSize| and the pointer to the highest allocated chunk should have
 300   // also been updated to |base_| + 2 * |kPageSize|. This pointer is used to
 301   // maintain the container mapping a chunk address to its previous chunk and
 302   // this map is in turn used while merging previous contiguous chunks.
 303
 304   // Allocate more than 3 * |kPageSize| so that the free chunk of size 3 *
 305   // |kPageSize| is not reused and |highest_allocated_chunk_| gets used instead.
 306   scoped_ptr<DiscardableAshmemChunk> memory3(
 307       allocator_.Allocate(4 * kPageSize));
 308   ASSERT_TRUE(memory3);
 309
 310   // Deleting |memory3| (whose size is 4 * |kPageSize|) should result in a merge
 311   // with its previous chunk which is the free chunk of size |3 * kPageSize|.
 312   memory3.reset();
 313   memory3 = allocator_.Allocate((3 + 4) * kPageSize);
 314   EXPECT_EQ(memory3->Memory(),
 315             static_cast<const char*>(memory2->Memory()) + kPageSize);
 316 }
 317
 318 }  // namespace internal
 319 }  // namespace base