linker/tests/linker_memory_allocator_test.cpp

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

#include <gtest/gtest.h>

#include "../linker_allocator.h"

#include <unistd.h>

namespace {

/*
 * this one has size below allocator cap which is 2*sizeof(void*)
 */
struct test_struct_small {
  char dummy_str[5];
};

struct test_struct_large {
  char dummy_str[1009];
};

struct test_struct_huge {
  char dummy_str[73939];
};

struct test_struct_512 {
  char dummy_str[503];
};

};

static size_t kPageSize = sysconf(_SC_PAGE_SIZE);

TEST(linker_memory, test_alloc_0) {
  LinkerMemoryAllocator allocator;
  void* ptr = allocator.alloc(0);
  ASSERT_TRUE(ptr != nullptr);
  allocator.free(ptr);
}

TEST(linker_memory, test_free_nullptr) {
  LinkerMemoryAllocator allocator;
  allocator.free(nullptr);
}

TEST(linker_memory, test_realloc) {
  LinkerMemoryAllocator allocator;
  uint32_t* array = reinterpret_cast<uint32_t*>(allocator.alloc(512));
  const size_t array_size = 512 / sizeof(uint32_t);

  uint32_t model[1000];

  model[0] = 1;
  model[1] = 1;

  for (size_t i = 2; i < 1000; ++i) {
    model[i] = model[i - 1] + model[i - 2];
  }

  memcpy(array, model, array_size);

  uint32_t* reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 1024));

  ASSERT_TRUE(reallocated_ptr != nullptr);
  ASSERT_TRUE(reallocated_ptr != array);

  ASSERT_TRUE(memcmp(reallocated_ptr, model, array_size) == 0);

  array = reallocated_ptr;

  memcpy(array, model, 2*array_size);

  reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 62));

  ASSERT_TRUE(reallocated_ptr == array);

  reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 4000));

  ASSERT_TRUE(reallocated_ptr != nullptr);
  ASSERT_TRUE(reallocated_ptr != array);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(reallocated_ptr) % 16);

  ASSERT_TRUE(memcmp(reallocated_ptr, model, array_size * 2) == 0);

  array = reallocated_ptr;

  memcpy(array, model, 4000);

  reallocated_ptr = reinterpret_cast<uint32_t*>(allocator.realloc(array, 64000));

  ASSERT_TRUE(reallocated_ptr != nullptr);
  ASSERT_TRUE(reallocated_ptr != array);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(reallocated_ptr) % 16);

  ASSERT_TRUE(memcmp(reallocated_ptr, model, 4000) == 0);

  ASSERT_EQ(nullptr, allocator.realloc(reallocated_ptr, 0));
}

TEST(linker_memory, test_small_smoke) {
  LinkerMemoryAllocator allocator;

  uint8_t zeros[16];
  memset(zeros, 0, sizeof(zeros));

  test_struct_small* ptr1 =
      reinterpret_cast<test_struct_small*>(allocator.alloc(sizeof(test_struct_small)));
  test_struct_small* ptr2 =
      reinterpret_cast<test_struct_small*>(allocator.alloc(sizeof(test_struct_small)));

  ASSERT_TRUE(ptr1 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr1) % 16);
  ASSERT_TRUE(ptr2 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr2) % 16);

  ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr1)+16, reinterpret_cast<uintptr_t>(ptr2));
  ASSERT_TRUE(memcmp(ptr1, zeros, 16) == 0);

  allocator.free(ptr1);
  allocator.free(ptr2);
}

TEST(linker_memory, test_huge_smoke) {
  LinkerMemoryAllocator allocator;

  // this should trigger proxy-to-mmap
  test_struct_huge* ptr1 =
      reinterpret_cast<test_struct_huge*>(allocator.alloc(sizeof(test_struct_huge)));
  test_struct_huge* ptr2 =
      reinterpret_cast<test_struct_huge*>(allocator.alloc(sizeof(test_struct_huge)));

  ASSERT_TRUE(ptr1 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr1) % 16);
  ASSERT_TRUE(ptr2 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr2) % 16);

  ASSERT_TRUE(
      reinterpret_cast<uintptr_t>(ptr1)/kPageSize != reinterpret_cast<uintptr_t>(ptr2)/kPageSize);
  allocator.free(ptr2);
  allocator.free(ptr1);
}

TEST(linker_memory, test_large) {
  LinkerMemoryAllocator allocator;

  test_struct_large* ptr1 =
      reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));
  test_struct_large* ptr2 =
      reinterpret_cast<test_struct_large*>(allocator.alloc(1024));

  ASSERT_TRUE(ptr1 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr1) % 16);
  ASSERT_TRUE(ptr2 != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr2) % 16);

  ASSERT_EQ(reinterpret_cast<uintptr_t>(ptr1) + 1024, reinterpret_cast<uintptr_t>(ptr2));

  // let's allocate until we reach the next page.
  size_t n = kPageSize / sizeof(test_struct_large) + 1 - 2;
  test_struct_large* objects[n];

  for (size_t i = 0; i < n; ++i) {
    test_struct_large* obj_ptr =
        reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));
    ASSERT_TRUE(obj_ptr != nullptr);
    objects[i] = obj_ptr;
  }

  test_struct_large* ptr_to_free =
      reinterpret_cast<test_struct_large*>(allocator.alloc(sizeof(test_struct_large)));

  ASSERT_TRUE(ptr_to_free != nullptr);
  ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr_to_free) % 16);

  allocator.free(ptr1);

  for (size_t i=0; i<n; ++i) {
    allocator.free(objects[i]);
  }

  allocator.free(ptr2);
  allocator.free(ptr_to_free);
}