diff options
Diffstat (limited to 'chromium/base/memory/discardable_memory_ashmem_allocator_unittest.cc')
| -rw-r--r-- | chromium/base/memory/discardable_memory_ashmem_allocator_unittest.cc | 319 |
1 files changed, 0 insertions, 319 deletions
diff --git a/chromium/base/memory/discardable_memory_ashmem_allocator_unittest.cc b/chromium/base/memory/discardable_memory_ashmem_allocator_unittest.cc deleted file mode 100644 index e9f63ba3439..00000000000 --- a/chromium/base/memory/discardable_memory_ashmem_allocator_unittest.cc +++ /dev/null @@ -1,319 +0,0 @@ -// Copyright 2014 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/memory/discardable_memory_ashmem_allocator.h" - -#include <sys/types.h> -#include <unistd.h> - -#include "base/memory/discardable_memory.h" -#include "base/memory/scoped_ptr.h" -#include "base/strings/string_number_conversions.h" -#include "base/strings/string_split.h" -#include "base/strings/stringprintf.h" -#include "build/build_config.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace base { -namespace internal { - -const char kAllocatorName[] = "allocator-for-testing"; - -const size_t kAshmemRegionSizeForTesting = 32 * 1024 * 1024; -const size_t kPageSize = 4096; - -const size_t kMaxAllowedAllocationSize = - std::numeric_limits<size_t>::max() - kPageSize + 1; - -class DiscardableMemoryAshmemAllocatorTest : public testing::Test { - protected: - DiscardableMemoryAshmemAllocatorTest() - : allocator_(kAllocatorName, kAshmemRegionSizeForTesting) { - } - - DiscardableMemoryAshmemAllocator allocator_; -}; - -void WriteToDiscardableAshmemChunk(DiscardableAshmemChunk* memory, - size_t size) { - // Write to the first and the last pages only to avoid paging in up to 64 - // MBytes. - static_cast<char*>(memory->Memory())[0] = 'a'; - static_cast<char*>(memory->Memory())[size - 1] = 'a'; -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, Basic) { - const size_t size = 128; - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(size)); - ASSERT_TRUE(memory); - WriteToDiscardableAshmemChunk(memory.get(), size); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, ZeroAllocationIsNotSupported) { - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(0)); - ASSERT_FALSE(memory); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, TooLargeAllocationFails) { - scoped_ptr<DiscardableAshmemChunk> memory( - allocator_.Allocate(kMaxAllowedAllocationSize + 1)); - // Page-alignment would have caused an overflow resulting in a small - // allocation if the input size wasn't checked correctly. - ASSERT_FALSE(memory); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - AshmemRegionsAreNotSmallerThanRequestedSize) { - // The creation of the underlying ashmem region is expected to fail since - // there should not be enough room in the address space. When ashmem creation - // fails, the allocator repetitively retries by dividing the size by 2. This - // size should not be smaller than the size the user requested so the - // allocation here should just fail (and not succeed with the minimum ashmem - // region size). - scoped_ptr<DiscardableAshmemChunk> memory( - allocator_.Allocate(kMaxAllowedAllocationSize)); - ASSERT_FALSE(memory); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - AshmemRegionsAreAlwaysPageAligned) { - // Use a separate allocator here so that we can override the ashmem region - // size. - DiscardableMemoryAshmemAllocator allocator( - kAllocatorName, kMaxAllowedAllocationSize); - scoped_ptr<DiscardableAshmemChunk> memory(allocator.Allocate(kPageSize)); - ASSERT_TRUE(memory); - EXPECT_GT(kMaxAllowedAllocationSize, allocator.last_ashmem_region_size()); - ASSERT_TRUE(allocator.last_ashmem_region_size() % kPageSize == 0); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, LargeAllocation) { - const size_t size = 64 * 1024 * 1024; - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(size)); - ASSERT_TRUE(memory); - WriteToDiscardableAshmemChunk(memory.get(), size); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, ChunksArePageAligned) { - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory); - EXPECT_EQ(0U, reinterpret_cast<uint64_t>(memory->Memory()) % kPageSize); - WriteToDiscardableAshmemChunk(memory.get(), kPageSize); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, AllocateFreeAllocate) { - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize)); - // Extra allocation that prevents the region from being deleted when |memory| - // gets deleted. - scoped_ptr<DiscardableAshmemChunk> memory_lock( - allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory); - void* const address = memory->Memory(); - memory->Unlock(); // Tests that the reused chunk is being locked correctly. - memory.reset(); - memory = allocator_.Allocate(kPageSize); - ASSERT_TRUE(memory); - // The previously freed chunk should be reused. - EXPECT_EQ(address, memory->Memory()); - WriteToDiscardableAshmemChunk(memory.get(), kPageSize); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - FreeingWholeAshmemRegionClosesAshmem) { - scoped_ptr<DiscardableAshmemChunk> memory(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory); - const int kMagic = 0xdeadbeef; - *static_cast<int*>(memory->Memory()) = kMagic; - memory.reset(); - // The previous ashmem region should have been closed thus it should not be - // reused. - memory = allocator_.Allocate(kPageSize); - ASSERT_TRUE(memory); - EXPECT_NE(kMagic, *static_cast<const int*>(memory->Memory())); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, AllocateUsesBestFitAlgorithm) { - scoped_ptr<DiscardableAshmemChunk> memory1( - allocator_.Allocate(3 * kPageSize)); - ASSERT_TRUE(memory1); - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(2 * kPageSize)); - ASSERT_TRUE(memory2); - scoped_ptr<DiscardableAshmemChunk> memory3( - allocator_.Allocate(1 * kPageSize)); - ASSERT_TRUE(memory3); - void* const address_3 = memory3->Memory(); - memory1.reset(); - // Don't free |memory2| to avoid merging the 3 blocks together. - memory3.reset(); - memory1 = allocator_.Allocate(1 * kPageSize); - ASSERT_TRUE(memory1); - // The chunk whose size is closest to the requested size should be reused. - EXPECT_EQ(address_3, memory1->Memory()); - WriteToDiscardableAshmemChunk(memory1.get(), kPageSize); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunks) { - scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory1); - scoped_ptr<DiscardableAshmemChunk> memory2(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory2); - scoped_ptr<DiscardableAshmemChunk> memory3(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory3); - scoped_ptr<DiscardableAshmemChunk> memory4(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory4); - void* const memory1_address = memory1->Memory(); - memory1.reset(); - memory3.reset(); - // Freeing |memory2| (located between memory1 and memory3) should merge the - // three free blocks together. - memory2.reset(); - memory1 = allocator_.Allocate(3 * kPageSize); - EXPECT_EQ(memory1_address, memory1->Memory()); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunksAdvanced) { - scoped_ptr<DiscardableAshmemChunk> memory1( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory1); - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory2); - void* const memory1_address = memory1->Memory(); - memory1.reset(); - memory1 = allocator_.Allocate(2 * kPageSize); - memory2.reset(); - // At this point, the region should be in this state: - // 8 KBytes (used), 24 KBytes (free). - memory2 = allocator_.Allocate(6 * kPageSize); - EXPECT_EQ( - static_cast<const char*>(memory2->Memory()), - static_cast<const char*>(memory1_address) + 2 * kPageSize); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, MergeFreeChunksAdvanced2) { - scoped_ptr<DiscardableAshmemChunk> memory1( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory1); - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory2); - void* const memory1_address = memory1->Memory(); - memory1.reset(); - memory1 = allocator_.Allocate(2 * kPageSize); - scoped_ptr<DiscardableAshmemChunk> memory3( - allocator_.Allocate(2 * kPageSize)); - // At this point, the region should be in this state: - // 8 KBytes (used), 8 KBytes (used), 16 KBytes (used). - memory3.reset(); - memory2.reset(); - // At this point, the region should be in this state: - // 8 KBytes (used), 24 KBytes (free). - memory2 = allocator_.Allocate(6 * kPageSize); - EXPECT_EQ( - static_cast<const char*>(memory2->Memory()), - static_cast<const char*>(memory1_address) + 2 * kPageSize); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - MergeFreeChunksAndDeleteAshmemRegion) { - scoped_ptr<DiscardableAshmemChunk> memory1( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory1); - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory2); - memory1.reset(); - memory1 = allocator_.Allocate(2 * kPageSize); - scoped_ptr<DiscardableAshmemChunk> memory3( - allocator_.Allocate(2 * kPageSize)); - // At this point, the region should be in this state: - // 8 KBytes (used), 8 KBytes (used), 16 KBytes (used). - memory1.reset(); - memory3.reset(); - // At this point, the region should be in this state: - // 8 KBytes (free), 8 KBytes (used), 8 KBytes (free). - const int kMagic = 0xdeadbeef; - *static_cast<int*>(memory2->Memory()) = kMagic; - memory2.reset(); - // The whole region should have been deleted. - memory2 = allocator_.Allocate(2 * kPageSize); - EXPECT_NE(kMagic, *static_cast<int*>(memory2->Memory())); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - TooLargeFreeChunksDontCauseTooMuchFragmentationWhenRecycled) { - // Keep |memory_1| below allocated so that the ashmem region doesn't get - // closed when |memory_2| is deleted. - scoped_ptr<DiscardableAshmemChunk> memory_1(allocator_.Allocate(64 * 1024)); - ASSERT_TRUE(memory_1); - scoped_ptr<DiscardableAshmemChunk> memory_2(allocator_.Allocate(32 * 1024)); - ASSERT_TRUE(memory_2); - void* const address = memory_2->Memory(); - memory_2.reset(); - const size_t size = 16 * 1024; - memory_2 = allocator_.Allocate(size); - ASSERT_TRUE(memory_2); - EXPECT_EQ(address, memory_2->Memory()); - WriteToDiscardableAshmemChunk(memory_2.get(), size); - scoped_ptr<DiscardableAshmemChunk> memory_3(allocator_.Allocate(size)); - // The unused tail (16 KBytes large) of the previously freed chunk should be - // reused. - EXPECT_EQ(static_cast<char*>(address) + size, memory_3->Memory()); - WriteToDiscardableAshmemChunk(memory_3.get(), size); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, UseMultipleAshmemRegions) { - // Leave one page untouched at the end of the ashmem region. - const size_t size = kAshmemRegionSizeForTesting - kPageSize; - scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(size)); - ASSERT_TRUE(memory1); - WriteToDiscardableAshmemChunk(memory1.get(), size); - - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(kAshmemRegionSizeForTesting)); - ASSERT_TRUE(memory2); - WriteToDiscardableAshmemChunk(memory2.get(), kAshmemRegionSizeForTesting); - // The last page of the first ashmem region should be used for this - // allocation. - scoped_ptr<DiscardableAshmemChunk> memory3(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory3); - WriteToDiscardableAshmemChunk(memory3.get(), kPageSize); - EXPECT_EQ(memory3->Memory(), static_cast<char*>(memory1->Memory()) + size); -} - -TEST_F(DiscardableMemoryAshmemAllocatorTest, - HighestAllocatedChunkPointerIsUpdatedWhenHighestChunkGetsSplit) { - // Prevents the ashmem region from getting closed when |memory2| gets freed. - scoped_ptr<DiscardableAshmemChunk> memory1(allocator_.Allocate(kPageSize)); - ASSERT_TRUE(memory1); - - scoped_ptr<DiscardableAshmemChunk> memory2( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory2); - - memory2.reset(); - memory2 = allocator_.Allocate(kPageSize); - // There should now be a free chunk of size 3 * |kPageSize| starting at offset - // 2 * |kPageSize| and the pointer to the highest allocated chunk should have - // also been updated to |base_| + 2 * |kPageSize|. This pointer is used to - // maintain the container mapping a chunk address to its previous chunk and - // this map is in turn used while merging previous contiguous chunks. - - // Allocate more than 3 * |kPageSize| so that the free chunk of size 3 * - // |kPageSize| is not reused and |highest_allocated_chunk_| gets used instead. - scoped_ptr<DiscardableAshmemChunk> memory3( - allocator_.Allocate(4 * kPageSize)); - ASSERT_TRUE(memory3); - - // Deleting |memory3| (whose size is 4 * |kPageSize|) should result in a merge - // with its previous chunk which is the free chunk of size |3 * kPageSize|. - memory3.reset(); - memory3 = allocator_.Allocate((3 + 4) * kPageSize); - EXPECT_EQ(memory3->Memory(), - static_cast<const char*>(memory2->Memory()) + kPageSize); -} - -} // namespace internal -} // namespace base |