// 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