MemoryTest.cpp File Reference

#include <folly/Memory.h>
#include <limits>
#include <memory>
#include <type_traits>
#include <utility>
#include <glog/logging.h>
#include <folly/ConstexprMath.h>
#include <folly/String.h>
#include <folly/memory/Arena.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	CountedAllocatorStats
class	CountedAllocator< T >
struct	ExpectingAlloc< T >
struct	OverAlignedType

Functions
	TEST (allocateBytes, simple)
	TEST (aligned_malloc, examples)
	TEST (make_unique, compatible_with_std_make_unique)
	TEST (to_weak_ptr, example)
	TEST (SysAllocator, equality)
	TEST (SysAllocator, allocate_unique)
	TEST (SysAllocator, vector)
	TEST (SysAllocator, bad_alloc)
	TEST (AlignedSysAllocator, equality_fixed)
	TEST (AlignedSysAllocator, allocate_unique_fixed)
	TEST (AlignedSysAllocator, vector_fixed)
	TEST (AlignedSysAllocator, bad_alloc_fixed)
	TEST (AlignedSysAllocator, equality_default)
	TEST (AlignedSysAllocator, allocate_unique_default)
	TEST (AlignedSysAllocator, vector_default)
	TEST (AlignedSysAllocator, bad_alloc_default)
	TEST (AlignedSysAllocator, converting_constructor)
	TEST (allocate_sys_buffer, compiles)
	TEST (allocate_unique, ctor_failure)
	TEST (AllocatorObjectLifecycleTraits, compiles)
	TEST (allocateOverAligned, notActuallyOver)
	TEST (allocateOverAligned, manualOverStdAlloc)
	TEST (allocateOverAligned, manualOverCustomAlloc)
	TEST (allocateOverAligned, defaultOverCustomAlloc)

Variables
static constexpr std::size_t	kTooBig

Function Documentation

TEST	(	allocateBytes	,
		simple
	)

Definition at line 38 of file MemoryTest.cpp.

References folly::allocateBytes(), folly::deallocateBytes(), and EXPECT_TRUE.

                            {
  auto p = allocateBytes(10);
  EXPECT_TRUE(p != nullptr);
  deallocateBytes(p, 10);
}

TEST	(	aligned_malloc	,
		examples
	)

Definition at line 44 of file MemoryTest.cpp.

References folly::aligned_free(), folly::aligned_malloc(), EXPECT_EQ, folly::kIsSanitize, and ptr.

                               {
  auto trial = [](size_t align) {
    auto const ptr = aligned_malloc(1, align);
    return (aligned_free(ptr), uintptr_t(ptr));
  };

  if (!kIsSanitize) { // asan allocator raises SIGABRT instead
    EXPECT_EQ(EINVAL, (trial(2), errno)) << "too small";
    EXPECT_EQ(EINVAL, (trial(513), errno)) << "not power of two";
  }

  EXPECT_EQ(0, trial(512) % 512);
  EXPECT_EQ(0, trial(8192) % 8192);
}

TEST	(	make_unique	,
		compatible_with_std_make_unique
	)

Definition at line 59 of file MemoryTest.cpp.

References folly::to_shared_ptr().

                                                   {
  //  HACK: To enforce that `folly::` is imported here.
  to_shared_ptr(std::unique_ptr<std::string>());

  using namespace std;
  make_unique<string>("hello, world");
}

TEST	(	to_weak_ptr	,
		example
	)

Definition at line 67 of file MemoryTest.cpp.

References EXPECT_EQ, folly::lock(), s, and folly::to_weak_ptr().

                           {
  auto s = std::make_shared<int>(17);
  EXPECT_EQ(1, s.use_count());
  EXPECT_EQ(2, (to_weak_ptr(s).lock(), s.use_count())) << "lvalue";
  EXPECT_EQ(3, (to_weak_ptr(decltype(s)(s)).lock(), s.use_count())) << "rvalue";
}

TEST	(	SysAllocator	,
		equality
	)

Definition at line 74 of file MemoryTest.cpp.

References a, b, EXPECT_FALSE, and EXPECT_TRUE.

                             {
  using Alloc = SysAllocator<float>;
  Alloc const a, b;
  EXPECT_TRUE(a == b);
  EXPECT_FALSE(a != b);
}

TEST	(	SysAllocator	,
		allocate_unique
	)

Definition at line 81 of file MemoryTest.cpp.

References EXPECT_EQ, and ptr.

                                    {
  using Alloc = SysAllocator<float>;
  Alloc const alloc;
  auto ptr = allocate_unique<float>(alloc, 3.);
  EXPECT_EQ(3., *ptr);
}

TEST	(	SysAllocator	,
		vector
	)

Definition at line 88 of file MemoryTest.cpp.

References testing::ElementsAreArray(), and EXPECT_THAT.

                           {
  using Alloc = SysAllocator<float>;
  Alloc const alloc;
  std::vector<float, Alloc> nums(alloc);
  nums.push_back(3.);
  nums.push_back(5.);
  EXPECT_THAT(nums, testing::ElementsAreArray({3., 5.}));
}

TEST	(	SysAllocator	,
		bad_alloc
	)

Definition at line 97 of file MemoryTest.cpp.

References EXPECT_THROW, folly::kIsSanitize, and kTooBig.

                              {
  using Alloc = SysAllocator<float>;
  Alloc const alloc;
  std::vector<float, Alloc> nums(alloc);
  if (!kIsSanitize) {
    EXPECT_THROW(nums.reserve(kTooBig), std::bad_alloc);
  }
}

TEST	(	AlignedSysAllocator	,
		equality_fixed
	)

Definition at line 106 of file MemoryTest.cpp.

References a, b, EXPECT_FALSE, and EXPECT_TRUE.

                                          {
  using Alloc = AlignedSysAllocator<float, FixedAlign<1024>>;
  Alloc const a, b;
  EXPECT_TRUE(a == b);
  EXPECT_FALSE(a != b);
}

TEST	(	AlignedSysAllocator	,
		allocate_unique_fixed
	)

Definition at line 113 of file MemoryTest.cpp.

References EXPECT_EQ, and ptr.

                                                 {
  using Alloc = AlignedSysAllocator<float, FixedAlign<1024>>;
  Alloc const alloc;
  auto ptr = allocate_unique<float>(alloc, 3.);
  EXPECT_EQ(3., *ptr);
  EXPECT_EQ(0, std::uintptr_t(ptr.get()) % 1024);
}

TEST	(	AlignedSysAllocator	,
		vector_fixed
	)

Definition at line 121 of file MemoryTest.cpp.

References testing::ElementsAreArray(), EXPECT_EQ, and EXPECT_THAT.

                                        {
  using Alloc = AlignedSysAllocator<float, FixedAlign<1024>>;
  Alloc const alloc;
  std::vector<float, Alloc> nums(alloc);
  nums.push_back(3.);
  nums.push_back(5.);
  EXPECT_THAT(nums, testing::ElementsAreArray({3., 5.}));
  EXPECT_EQ(0, std::uintptr_t(nums.data()) % 1024);
}

TEST	(	AlignedSysAllocator	,
		bad_alloc_fixed
	)

Definition at line 131 of file MemoryTest.cpp.

References EXPECT_THROW, folly::kIsSanitize, and kTooBig.

                                           {
  using Alloc = AlignedSysAllocator<float, FixedAlign<1024>>;
  Alloc const alloc;
  std::vector<float, Alloc> nums(alloc);
  if (!kIsSanitize) {
    EXPECT_THROW(nums.reserve(kTooBig), std::bad_alloc);
  }
}

TEST	(	AlignedSysAllocator	,
		equality_default
	)

Definition at line 140 of file MemoryTest.cpp.

References a, b, c, EXPECT_FALSE, and EXPECT_TRUE.

                                            {
  using Alloc = AlignedSysAllocator<float>;
  Alloc const a(1024), b(1024), c(512);
  EXPECT_TRUE(a == b);
  EXPECT_FALSE(a != b);
  EXPECT_FALSE(a == c);
  EXPECT_TRUE(a != c);
}

TEST	(	AlignedSysAllocator	,
		allocate_unique_default
	)

Definition at line 149 of file MemoryTest.cpp.

References EXPECT_EQ, and ptr.

                                                   {
  using Alloc = AlignedSysAllocator<float>;
  Alloc const alloc(1024);
  auto ptr = allocate_unique<float>(alloc, 3.);
  EXPECT_EQ(3., *ptr);
  EXPECT_EQ(0, std::uintptr_t(ptr.get()) % 1024);
}

TEST	(	AlignedSysAllocator	,
		vector_default
	)

Definition at line 157 of file MemoryTest.cpp.

References testing::ElementsAreArray(), EXPECT_EQ, and EXPECT_THAT.

                                          {
  using Alloc = AlignedSysAllocator<float>;
  Alloc const alloc(1024);
  std::vector<float, Alloc> nums(alloc);
  nums.push_back(3.);
  nums.push_back(5.);
  EXPECT_THAT(nums, testing::ElementsAreArray({3., 5.}));
  EXPECT_EQ(0, std::uintptr_t(nums.data()) % 1024);
}

TEST	(	AlignedSysAllocator	,
		bad_alloc_default
	)

Definition at line 167 of file MemoryTest.cpp.

References EXPECT_THROW, folly::kIsSanitize, and kTooBig.

                                             {
  using Alloc = AlignedSysAllocator<float>;
  Alloc const alloc(1024);
  std::vector<float, Alloc> nums(alloc);
  if (!kIsSanitize) {
    EXPECT_THROW(nums.reserve(kTooBig), std::bad_alloc);
  }
}

TEST	(	AlignedSysAllocator	,
		converting_constructor
	)

Definition at line 176 of file MemoryTest.cpp.

                                                  {
  using Alloc1 = AlignedSysAllocator<float>;
  using Alloc2 = AlignedSysAllocator<double>;
  Alloc1 const alloc1(1024);
  Alloc2 const alloc2(alloc1);
}

TEST	(	allocate_sys_buffer	,
		compiles
	)

Definition at line 183 of file MemoryTest.cpp.

References folly::allocate_sys_buffer().

                                    {
  auto buf = allocate_sys_buffer(256);
  //  Freed at the end of the scope.
}

TEST	(	allocate_unique	,
		ctor_failure
	)

Definition at line 206 of file MemoryTest.cpp.

References testing::Args(), CountedAllocatorStats::deallocates, destroy(), EXPECT_EQ, EXPECT_NE, EXPECT_THROW, and ptr.

                                    {
  struct CtorThrows {
    explicit CtorThrows(bool cond) {
      if (cond) {
        throw std::runtime_error("nope");
      }
    }
  };
  using Alloc = CountedAllocator<CtorThrows>;
  using Deleter = allocator_delete<CountedAllocator<CtorThrows>>;
  {
    CountedAllocatorStats stats;
    Alloc const alloc(stats);
    EXPECT_EQ(0, stats.deallocates);
    std::unique_ptr<CtorThrows, Deleter> ptr{nullptr, Deleter{alloc}};
    ptr = allocate_unique<CtorThrows>(alloc, false);
    EXPECT_NE(nullptr, ptr);
    EXPECT_EQ(0, stats.deallocates);
    ptr = nullptr;
    EXPECT_EQ(nullptr, ptr);
    EXPECT_EQ(1, stats.deallocates);
  }
  {
    CountedAllocatorStats stats;
    Alloc const alloc(stats);
    EXPECT_EQ(0, stats.deallocates);
    std::unique_ptr<CtorThrows, Deleter> ptr{nullptr, Deleter{alloc}};
    EXPECT_THROW(
        ptr = allocate_unique<CtorThrows>(alloc, true), std::runtime_error);
    EXPECT_EQ(nullptr, ptr);
    EXPECT_EQ(1, stats.deallocates);
  }
}

TEST	(	AllocatorObjectLifecycleTraits	,
		compiles
	)

Definition at line 274 of file MemoryTest.cpp.

References string, and folly::value().

                                               {
  using A = std::allocator<int>;
  using S = std::string;

  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<A, int, int>::value, "");
  static_assert(folly::AllocatorHasDefaultObjectConstruct<A, S, S>::value, "");

  static_assert(folly::AllocatorHasDefaultObjectDestroy<A, int>::value, "");
  static_assert(folly::AllocatorHasDefaultObjectDestroy<A, S>::value, "");

  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<
          folly::AlignedSysAllocator<int>,
          int,
          int>::value,
      "");
  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<
          folly::AlignedSysAllocator<int>,
          S,
          S>::value,
      "");

  static_assert(
      folly::AllocatorHasDefaultObjectDestroy<
          folly::AlignedSysAllocator<int>,
          int>::value,
      "");
  static_assert(
      folly::AllocatorHasDefaultObjectDestroy<
          folly::AlignedSysAllocator<int>,
          S>::value,
      "");

  static_assert(
      !folly::AllocatorHasDefaultObjectConstruct<TestAlloc1<S>, S, S>::value,
      "");
  static_assert(
      folly::AllocatorHasDefaultObjectDestroy<TestAlloc1<S>, S>::value, "");

  static_assert(
      !folly::AllocatorHasDefaultObjectConstruct<TestAlloc2<S>, S, S>::value,
      "");
  static_assert(
      !folly::AllocatorHasDefaultObjectDestroy<TestAlloc2<S>, S>::value, "");

  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<TestAlloc3<S>, S, S>::value,
      "");
  static_assert(
      !folly::AllocatorHasDefaultObjectDestroy<TestAlloc3<S>, S>::value, "");

  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<TestAlloc4<S>, S, S>::value,
      "");
  static_assert(
      folly::AllocatorHasDefaultObjectDestroy<TestAlloc4<S>, S>::value, "");

  static_assert(
      folly::AllocatorHasDefaultObjectConstruct<TestAlloc5<S>, S, S>::value,
      "");
  static_assert(
      !folly::AllocatorHasDefaultObjectDestroy<TestAlloc5<S>, S>::value, "");
}

TEST	(	allocateOverAligned	,
		notActuallyOver
	)

Definition at line 371 of file MemoryTest.cpp.

References a, folly::allocationBytesForOverAligned(), and EXPECT_EQ.

                                           {
  // allocates 6 bytes with alignment 4, should get turned into an
  // allocation of 2 elements of something of size and alignment 4
  ExpectingAlloc<char> a(4, 2);
  auto p = folly::allocateOverAligned<decltype(a), 4>(a, 6);
  EXPECT_EQ((reinterpret_cast<uintptr_t>(p) % 4), 0);
  folly::deallocateOverAligned<decltype(a), 4>(a, p, 6);
  EXPECT_EQ((folly::allocationBytesForOverAligned<decltype(a), 4>(6)), 8);
}

TEST	(	allocateOverAligned	,
		manualOverStdAlloc
	)

Definition at line 381 of file MemoryTest.cpp.

References a, folly::aligned_free(), folly::allocationBytesForOverAligned(), and EXPECT_EQ.

                                              {
  // allocates 6 bytes with alignment 64 using std::allocator, which will
  // result in a call to aligned_malloc underneath.  We free one directly
  // to check that this is not the padding path
  std::allocator<short> a;
  auto p = folly::allocateOverAligned<decltype(a), 64>(a, 3);
  auto p2 = folly::allocateOverAligned<decltype(a), 64>(a, 3);
  EXPECT_EQ((reinterpret_cast<uintptr_t>(p) % 64), 0);
  folly::deallocateOverAligned<decltype(a), 64>(a, p, 3);
  aligned_free(p2);
  EXPECT_EQ((folly::allocationBytesForOverAligned<decltype(a), 64>(3)), 6);
}

TEST	(	allocateOverAligned	,
		manualOverCustomAlloc
	)

Definition at line 394 of file MemoryTest.cpp.

References a, folly::allocationBytesForOverAligned(), and EXPECT_EQ.

                                                 {
  // allocates 6 byte with alignment 64 using non-standard allocator, which
  // will result in an allocation of 64 + alignof(max_align_t) underneath.
  ExpectingAlloc<short> a(
      alignof(folly::max_align_t), 64 / alignof(folly::max_align_t) + 1);
  auto p = folly::allocateOverAligned<decltype(a), 64>(a, 3);
  EXPECT_EQ((reinterpret_cast<uintptr_t>(p) % 64), 0);
  folly::deallocateOverAligned<decltype(a), 64>(a, p, 3);
  EXPECT_EQ(
      (folly::allocationBytesForOverAligned<decltype(a), 64>(3)),
      64 + alignof(folly::max_align_t));
}

TEST	(	allocateOverAligned	,
		defaultOverCustomAlloc
	)

Definition at line 407 of file MemoryTest.cpp.

References a, folly::allocateOverAligned(), folly::allocationBytesForOverAligned(), folly::deallocateOverAligned(), and EXPECT_EQ.

                                                  {
  ExpectingAlloc<OverAlignedType> a(
      alignof(folly::max_align_t), 128 / alignof(folly::max_align_t));
  auto p = folly::allocateOverAligned(a, 1);
  EXPECT_EQ((reinterpret_cast<uintptr_t>(p) % 64), 0);
  folly::deallocateOverAligned(a, p, 1);
  EXPECT_EQ(folly::allocationBytesForOverAligned<decltype(a)>(1), 128);
}

Variable Documentation

constexpr std::size_t kTooBig

static

Initial value:

= folly::constexpr_max(
    std::size_t{std::numeric_limits<uint32_t>::max()},
    std::size_t{1} << (8 * sizeof(std::size_t) - 14))

Definition at line 34 of file MemoryTest.cpp.

Referenced by TEST().