| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1001833005:
Update from https://crrev.com/320343 (Closed)
Base URL: git@github.com:domokit/mojo.git@master