| // Copyright 2016 The Fuchsia 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 <algorithm> |
| #include <memory> |
| #include <utility> |
| |
| #include <fbl/alloc_checker.h> |
| #include <fbl/intrusive_double_list.h> |
| #include <fbl/ref_counted.h> |
| #include <fbl/ref_ptr.h> |
| #include <fbl/slab_allocator.h> |
| #include <zxtest/zxtest.h> |
| |
| namespace { |
| |
| enum class ConstructType { |
| DEFAULT, |
| LVALUE_REF, |
| RVALUE_REF, |
| L_THEN_R_REF, |
| }; |
| |
| // Test objects. |
| class TestBase { |
| public: |
| // Various constructor forms to exercise SlabAllocator::New |
| TestBase() : ctype_(ConstructType::DEFAULT) { ++allocated_obj_count_; } |
| explicit TestBase(const size_t&) : ctype_(ConstructType::LVALUE_REF) { ++allocated_obj_count_; } |
| explicit TestBase(size_t&&) : ctype_(ConstructType::RVALUE_REF) { ++allocated_obj_count_; } |
| explicit TestBase(const size_t&, size_t&&) : ctype_(ConstructType::L_THEN_R_REF) { |
| ++allocated_obj_count_; |
| } |
| |
| virtual ~TestBase() { --allocated_obj_count_; } |
| |
| ConstructType ctype() const { return ctype_; } |
| |
| static void Reset() { allocated_obj_count_ = 0; } |
| static size_t allocated_obj_count() { return allocated_obj_count_; } |
| const uint8_t* payload() const { return payload_; } |
| |
| private: |
| const ConstructType ctype_; |
| uint8_t payload_[13]; // 13 bytes, just to make the size/alignment strange |
| |
| static size_t allocated_obj_count_; |
| }; |
| |
| // Static storage. |
| size_t TestBase::allocated_obj_count_; |
| |
| template <typename SATraits, typename = void> |
| struct ReleaseHelper; |
| |
| template <typename SATraits> |
| struct ReleaseHelper<SATraits, |
| typename std::enable_if<(SATraits::PtrTraits::IsManaged == false) && |
| (SATraits::AllocatorFlavor == |
| fbl::SlabAllocatorFlavor::INSTANCED)>::type> { |
| static void ReleasePtr(fbl::SlabAllocator<SATraits>& allocator, typename SATraits::PtrType& ptr) { |
| // Instanced slab allocators should static_assert if you attempt to |
| // expand their Delete method. |
| #if TEST_WILL_NOT_COMPILE || 0 |
| allocator.Delete(ptr); |
| #else |
| delete ptr; |
| #endif |
| } |
| }; |
| |
| template <typename SATraits> |
| struct ReleaseHelper<SATraits, |
| typename std::enable_if<(SATraits::PtrTraits::IsManaged == false) && |
| (SATraits::AllocatorFlavor == |
| fbl::SlabAllocatorFlavor::MANUAL_DELETE)>::type> { |
| static void ReleasePtr(fbl::SlabAllocator<SATraits>& allocator, typename SATraits::PtrType& ptr) { |
| // SlabAllocated<> objects which come from MANUAL_DELETE flavors of slab |
| // allocators should have their delete operator protected in order to |
| // prevent someone from calling delete on the object. |
| #if TEST_WILL_NOT_COMPILE || 0 |
| delete ptr; |
| #else |
| allocator.Delete(ptr); |
| #endif |
| } |
| }; |
| |
| template <typename SATraits> |
| struct ReleaseHelper<SATraits, typename std::enable_if<(SATraits::PtrTraits::IsManaged == true) && |
| (SATraits::AllocatorFlavor != |
| fbl::SlabAllocatorFlavor::STATIC)>::type> { |
| static void ReleasePtr(fbl::SlabAllocator<SATraits>&, typename SATraits::PtrType& ptr) { |
| ptr = nullptr; |
| } |
| }; |
| |
| template <typename SATraits> |
| struct ReleaseHelper<SATraits, typename std::enable_if<(SATraits::PtrTraits::IsManaged == false) && |
| (SATraits::AllocatorFlavor == |
| fbl::SlabAllocatorFlavor::STATIC)>::type> { |
| static void ReleasePtr(typename SATraits::PtrType& ptr) { delete ptr; } |
| }; |
| |
| template <typename SATraits> |
| struct ReleaseHelper<SATraits, typename std::enable_if<(SATraits::PtrTraits::IsManaged == true) && |
| (SATraits::AllocatorFlavor == |
| fbl::SlabAllocatorFlavor::STATIC)>::type> { |
| static void ReleasePtr(typename SATraits::PtrType& ptr) { ptr = nullptr; } |
| }; |
| |
| // Traits which define the various test flavors. |
| template <typename LockType, |
| fbl::SlabAllocatorFlavor AllocatorFlavor = fbl::SlabAllocatorFlavor::INSTANCED, |
| fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct UnmanagedTestTraits { |
| class ObjType; |
| using PtrType = ObjType*; |
| using AllocTraits = fbl::SlabAllocatorTraits<PtrType, 1024, LockType, AllocatorFlavor, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = false; |
| static constexpr size_t MaxAllocs(size_t slabs) { return AllocatorType::AllocsPerSlab * slabs; } |
| }; |
| |
| template <typename LockType, fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct UniquePtrTestTraits { |
| class ObjType; |
| using PtrType = std::unique_ptr<ObjType>; |
| using AllocTraits = fbl::SlabAllocatorTraits<PtrType, 1024, LockType, |
| fbl::SlabAllocatorFlavor::INSTANCED, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = true; |
| static constexpr size_t MaxAllocs(size_t slabs) { return AllocatorType::AllocsPerSlab * slabs; } |
| }; |
| |
| template <typename LockType, fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct RefPtrTestTraits { |
| class ObjType; |
| using PtrType = fbl::RefPtr<ObjType>; |
| using AllocTraits = fbl::SlabAllocatorTraits<PtrType, 1024, LockType, |
| fbl::SlabAllocatorFlavor::INSTANCED, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::RefCounted<ObjType>, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = true; |
| static constexpr size_t MaxAllocs(size_t slabs) { return AllocatorType::AllocsPerSlab * slabs; } |
| }; |
| |
| template <typename, bool> |
| struct ObjCounterHelper; |
| |
| template <typename SA> |
| struct ObjCounterHelper<SA, true> { |
| static bool CheckObjCount(const SA& allocator, size_t expected) { |
| return (allocator.obj_count() == expected); |
| } |
| static bool CheckMaxObjCount(const SA& allocator, size_t expected) { |
| return (allocator.max_obj_count() == expected); |
| } |
| static void ResetMaxObjCount(SA* allocator) { allocator->ResetMaxObjCount(); } |
| static bool StaticCheckObjCount(size_t expected) { return (SA::obj_count() == expected); } |
| static bool StaticCheckMaxObjCount(size_t expected) { return (SA::max_obj_count() == expected); } |
| static void StaticResetMaxObjCount() { SA::ResetMaxObjCount(); } |
| }; |
| |
| template <typename SA> |
| struct ObjCounterHelper<SA, false> { |
| static bool CheckObjCount(const SA&, size_t) { return true; } |
| static bool CheckMaxObjCount(const SA&, size_t) { return true; } |
| static void ResetMaxObjCount(SA*) {} |
| static bool StaticCheckObjCount(size_t) { return true; } |
| static bool StaticCheckMaxObjCount(size_t) { return true; } |
| static void StaticResetMaxObjCount() {} |
| }; |
| |
| template <typename Traits> |
| void do_slab_test(typename Traits::AllocatorType& allocator, size_t test_allocs) { |
| const size_t MAX_ALLOCS = Traits::MaxAllocs(allocator.max_slabs()); |
| typename Traits::RefList ref_list; |
| const bool ENB_OBJ_COUNT = |
| Traits::AllocTraits::Options & fbl::SlabAllocatorOptions::EnableObjectCount; |
| using AllocatorType = typename Traits::AllocatorType; |
| |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::ResetMaxObjCount(&allocator); |
| bool res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckObjCount(allocator, 0); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount(allocator, 0); |
| EXPECT_TRUE(res); |
| |
| // Allocate up to the test limit. |
| for (size_t i = 0; i < test_allocs; ++i) { |
| typename Traits::PtrType ptr; |
| |
| EXPECT_EQ(std::min(i, MAX_ALLOCS), TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckObjCount( |
| allocator, TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount( |
| allocator, TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| |
| // Allocate the object; exercise the various constructors |
| switch (i % 4) { |
| case 0: |
| ptr = allocator.New(); |
| break; |
| case 1: |
| ptr = allocator.New(i); |
| break; |
| case 2: |
| ptr = allocator.New(std::move(i)); |
| break; |
| case 3: |
| ptr = allocator.New(i, std::move(i)); |
| break; |
| } |
| |
| if (i < MAX_ALLOCS) { |
| ASSERT_NOT_NULL(ptr, "Allocation failed when it should not have!"); |
| ref_list.push_front(std::move(ptr)); |
| } else { |
| ASSERT_NULL(ptr, "Allocation succeeded when it should not have!"); |
| } |
| |
| EXPECT_EQ(std::min(i + 1, MAX_ALLOCS), TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckObjCount( |
| allocator, TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount( |
| allocator, TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| } |
| |
| // Now remove and de-allocate. |
| size_t max_obj_count = TestBase::allocated_obj_count(); |
| size_t i; |
| for (i = 0; !ref_list.is_empty(); ++i) { |
| auto ptr = ref_list.pop_back(); |
| |
| ASSERT_NOT_NULL(ptr, "nullptr in ref list! This should be impossible."); |
| EXPECT_EQ(std::min(test_allocs, MAX_ALLOCS) - i, TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckObjCount( |
| allocator, TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount(allocator, max_obj_count); |
| EXPECT_TRUE(res); |
| |
| switch (i % 4) { |
| case 0: |
| EXPECT_EQ(ConstructType::DEFAULT, ptr->ctype()); |
| break; |
| case 1: |
| EXPECT_EQ(ConstructType::LVALUE_REF, ptr->ctype()); |
| break; |
| case 2: |
| EXPECT_EQ(ConstructType::RVALUE_REF, ptr->ctype()); |
| break; |
| case 3: |
| EXPECT_EQ(ConstructType::L_THEN_R_REF, ptr->ctype()); |
| break; |
| } |
| |
| // Release the reference (how this gets done depends on allocator flavor and pointer type) |
| ReleaseHelper<typename Traits::AllocTraits>::ReleasePtr(allocator, ptr); |
| |
| if (i % 2 == 1) { |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::ResetMaxObjCount(&allocator); |
| max_obj_count = TestBase::allocated_obj_count(); |
| } |
| res = |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount(allocator, max_obj_count); |
| EXPECT_TRUE(res); |
| } |
| |
| EXPECT_EQ(std::min(test_allocs, MAX_ALLOCS), i); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckObjCount(allocator, 0); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount(allocator, i % 2); |
| EXPECT_TRUE(res); |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::ResetMaxObjCount(&allocator); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::CheckMaxObjCount(allocator, 0); |
| EXPECT_TRUE(res); |
| |
| #if TEST_WILL_NOT_COMPILE || 0 |
| allocator.obj_count(); |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| allocator.max_obj_count(); |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| allocator.ResetMaxObjCount(); |
| #endif |
| } |
| |
| template <typename Traits, size_t SlabCount = Traits::MaxSlabs> |
| void slab_test() { |
| typename Traits::AllocatorType allocator(SlabCount); |
| |
| TestBase::Reset(); |
| |
| { |
| auto fn = [&allocator]() { do_slab_test<Traits>(allocator, 1); }; |
| ASSERT_NO_FAILURES(fn(), "Single allocator test failed"); |
| } |
| |
| { |
| auto fn = [&allocator]() { do_slab_test<Traits>(allocator, Traits::MaxAllocs(SlabCount) / 2); }; |
| ASSERT_NO_FAILURES(fn(), "1/2 capacity allocator test failed"); |
| } |
| |
| { |
| auto fn = [&allocator]() { do_slab_test<Traits>(allocator, Traits::MaxAllocs(SlabCount) + 4); }; |
| ASSERT_NO_FAILURES(fn(), "Over-capacity allocator test failed"); |
| } |
| } |
| |
| template <typename LockType, fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct StaticUnmanagedTestTraits { |
| class ObjType; |
| using PtrType = ObjType*; |
| using AllocTraits = fbl::StaticSlabAllocatorTraits<PtrType, 1024, LockType, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static size_t MaxAllocs() { return AllocatorType::AllocsPerSlab * AllocatorType::max_slabs(); } |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = false; |
| }; |
| template <typename LockType> |
| using StaticCountedUnmanagedTestTraits = |
| StaticUnmanagedTestTraits<LockType, fbl::SlabAllocatorOptions::EnableObjectCount>; |
| |
| template <typename LockType, fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct StaticUniquePtrTestTraits { |
| class ObjType; |
| using PtrType = std::unique_ptr<ObjType>; |
| using AllocTraits = fbl::StaticSlabAllocatorTraits<PtrType, 1024, LockType, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static size_t MaxAllocs() { return AllocatorType::AllocsPerSlab * AllocatorType::max_slabs(); } |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = false; |
| }; |
| |
| template <typename LockType> |
| using StaticCountedUniquePtrTestTraits = |
| StaticUniquePtrTestTraits<LockType, fbl::SlabAllocatorOptions::EnableObjectCount>; |
| |
| template <typename LockType, fbl::SlabAllocatorOptions Options = fbl::SlabAllocatorOptions::None> |
| struct StaticRefPtrTestTraits { |
| class ObjType; |
| using PtrType = fbl::RefPtr<ObjType>; |
| using AllocTraits = fbl::StaticSlabAllocatorTraits<PtrType, 1024, LockType, Options>; |
| using AllocatorType = fbl::SlabAllocator<AllocTraits>; |
| using RefList = fbl::DoublyLinkedList<PtrType>; |
| |
| class ObjType : public TestBase, |
| public fbl::SlabAllocated<AllocTraits>, |
| public fbl::RefCounted<ObjType>, |
| public fbl::DoublyLinkedListable<PtrType> { |
| public: |
| ObjType() : TestBase() {} |
| explicit ObjType(const size_t& val) : TestBase(val) {} |
| explicit ObjType(size_t&& val) : TestBase(std::move(val)) {} |
| explicit ObjType(const size_t& a, size_t&& b) : TestBase(a, std::move(b)) {} |
| }; |
| |
| static constexpr size_t MaxSlabs = 4; |
| static constexpr bool IsManaged = false; |
| |
| static size_t MaxAllocs() { return AllocatorType::AllocsPerSlab * AllocatorType::max_slabs(); } |
| }; |
| |
| template <typename LockType> |
| using StaticCountedRefPtrTestTraits = |
| StaticRefPtrTestTraits<LockType, fbl::SlabAllocatorOptions::EnableObjectCount>; |
| |
| template <typename Traits> |
| void do_static_slab_test(size_t test_allocs) { |
| const bool ENB_OBJ_COUNT = |
| Traits::AllocTraits::Options & fbl::SlabAllocatorOptions::EnableObjectCount; |
| using AllocatorType = typename Traits::AllocatorType; |
| |
| const size_t MAX_ALLOCS = Traits::MaxAllocs(); |
| typename Traits::RefList ref_list; |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticResetMaxObjCount(); |
| bool res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckObjCount(0); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount(0); |
| EXPECT_TRUE(res); |
| |
| // Allocate up to the test limit. |
| for (size_t i = 0; i < test_allocs; ++i) { |
| typename Traits::PtrType ptr; |
| |
| EXPECT_EQ(std::min(i, MAX_ALLOCS), TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckObjCount( |
| TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount( |
| TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| |
| // Allocate the object; exercise the various constructors |
| switch (i % 4) { |
| case 0: |
| ptr = AllocatorType::New(); |
| break; |
| case 1: |
| ptr = AllocatorType::New(i); |
| break; |
| case 2: |
| ptr = AllocatorType::New(std::move(i)); |
| break; |
| case 3: |
| ptr = AllocatorType::New(i, std::move(i)); |
| break; |
| } |
| |
| if (i < MAX_ALLOCS) { |
| ASSERT_NOT_NULL(ptr, "Allocation failed when it should not have!"); |
| ref_list.push_front(std::move(ptr)); |
| } else { |
| ASSERT_NULL(ptr, "Allocation succeeded when it should not have!"); |
| } |
| |
| EXPECT_EQ(std::min(i + 1, MAX_ALLOCS), TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckObjCount( |
| TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount( |
| TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| } |
| |
| // Now remove and de-allocate. |
| size_t max_obj_count = TestBase::allocated_obj_count(); |
| size_t i; |
| for (i = 0; !ref_list.is_empty(); ++i) { |
| auto ptr = ref_list.pop_back(); |
| |
| ASSERT_NOT_NULL(ptr, "nullptr in ref list! This should be impossible."); |
| EXPECT_EQ(std::min(test_allocs, MAX_ALLOCS) - i, TestBase::allocated_obj_count()); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckObjCount( |
| TestBase::allocated_obj_count()); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount(max_obj_count); |
| EXPECT_TRUE(res); |
| |
| switch (i % 4) { |
| case 0: |
| EXPECT_EQ(ConstructType::DEFAULT, ptr->ctype()); |
| break; |
| case 1: |
| EXPECT_EQ(ConstructType::LVALUE_REF, ptr->ctype()); |
| break; |
| case 2: |
| EXPECT_EQ(ConstructType::RVALUE_REF, ptr->ctype()); |
| break; |
| case 3: |
| EXPECT_EQ(ConstructType::L_THEN_R_REF, ptr->ctype()); |
| break; |
| } |
| |
| // Release the reference (how this gets done depends on allocator flavor and pointer type) |
| ReleaseHelper<typename Traits::AllocTraits>::ReleasePtr(ptr); |
| if (i % 2 == 1) { |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticResetMaxObjCount(); |
| max_obj_count = TestBase::allocated_obj_count(); |
| } |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount(max_obj_count); |
| EXPECT_TRUE(res); |
| } |
| |
| EXPECT_EQ(std::min(test_allocs, MAX_ALLOCS), i); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckObjCount(0); |
| EXPECT_TRUE(res); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount(i % 2); |
| EXPECT_TRUE(res); |
| ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticResetMaxObjCount(); |
| res = ObjCounterHelper<AllocatorType, ENB_OBJ_COUNT>::StaticCheckMaxObjCount(0); |
| EXPECT_TRUE(res); |
| #if TEST_WILL_NOT_COMPILE || 0 |
| AllocatorType::obj_count(); |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| AllocatorType::max_obj_count(); |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| AllocatorType::ResetMaxObjCount(); |
| #endif |
| } |
| |
| template <typename Traits> |
| void static_slab_test() { |
| TestBase::Reset(); |
| |
| ASSERT_NO_FAILURES(do_static_slab_test<Traits>(1), "Single allocator test failed"); |
| |
| ASSERT_NO_FAILURES(do_static_slab_test<Traits>(Traits::MaxAllocs() / 2), |
| "1/2 capacity allocator test failed"); |
| |
| ASSERT_NO_FAILURES(do_static_slab_test<Traits>(Traits::MaxAllocs() + 4), |
| "Over-capacity allocator test failed"); |
| } |
| } // namespace |
| |
| using MutexLock = ::fbl::Mutex; |
| using NullLock = ::fbl::NullLock; |
| |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticUnmanagedTestTraits<MutexLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticUniquePtrTestTraits<MutexLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticRefPtrTestTraits<MutexLock>::AllocTraits, 1); |
| |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticUnmanagedTestTraits<NullLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticUniquePtrTestTraits<NullLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticRefPtrTestTraits<NullLock>::AllocTraits, 1); |
| |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedUnmanagedTestTraits<MutexLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedUniquePtrTestTraits<MutexLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedRefPtrTestTraits<MutexLock>::AllocTraits, 1); |
| |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedUnmanagedTestTraits<NullLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedUniquePtrTestTraits<NullLock>::AllocTraits, 1); |
| DECLARE_STATIC_SLAB_ALLOCATOR_STORAGE(StaticCountedRefPtrTestTraits<NullLock>::AllocTraits, 1); |
| |
| #define MAKE_TEST(_name, ...) \ |
| TEST(SlabAllocatorTest, _name) { \ |
| auto fn = __VA_ARGS__; \ |
| ASSERT_NO_FAILURES(fn()); \ |
| } |
| |
| MAKE_TEST(UnmanagedSingleSlabMutex, slab_test<UnmanagedTestTraits<MutexLock>, 1>) |
| MAKE_TEST(UnmanagedMultiSlabMutex, slab_test<UnmanagedTestTraits<MutexLock>>) |
| MAKE_TEST(UniquePtrSingleSlabMutex, slab_test<UniquePtrTestTraits<MutexLock>, 1>) |
| MAKE_TEST(UniquePtrMultiSlabMutex, slab_test<UniquePtrTestTraits<MutexLock>>) |
| MAKE_TEST(RefPtrSingleSlabMutex, slab_test<RefPtrTestTraits<MutexLock>, 1>) |
| MAKE_TEST(RefPtrMultiSlabMutex, slab_test<RefPtrTestTraits<MutexLock>>) |
| MAKE_TEST(UnmanagedSingleSlabUnlock, slab_test<UnmanagedTestTraits<NullLock>, 1>) |
| MAKE_TEST(UnmanagedMultiSlabUnlock, slab_test<UnmanagedTestTraits<NullLock>>) |
| MAKE_TEST(UniquePtrSingleSlabUnlock, slab_test<UniquePtrTestTraits<NullLock>, 1>) |
| MAKE_TEST(UniquePtrMultiSlabUnlock, slab_test<UniquePtrTestTraits<NullLock>>) |
| MAKE_TEST(RefPtrSingleSlabUnlock, slab_test<RefPtrTestTraits<NullLock>, 1>) |
| MAKE_TEST(RefPtrMultiSlabUnlock, slab_test<RefPtrTestTraits<NullLock>>) |
| MAKE_TEST(ManualDeleteUnmanagedMutex, |
| slab_test<UnmanagedTestTraits<MutexLock, fbl::SlabAllocatorFlavor::MANUAL_DELETE>>) |
| MAKE_TEST(ManualDeleteUnmanagedUnlock, |
| slab_test<UnmanagedTestTraits<NullLock, fbl::SlabAllocatorFlavor::MANUAL_DELETE>>) |
| MAKE_TEST(StaticUnmanagedUnlock, static_slab_test<StaticUnmanagedTestTraits<NullLock>>) |
| MAKE_TEST(StaticUniquePtrUnlock, static_slab_test<StaticUniquePtrTestTraits<NullLock>>) |
| MAKE_TEST(StaticRefPtrUnlock, static_slab_test<StaticRefPtrTestTraits<NullLock>>) |
| MAKE_TEST(StaticUnmanagedMutex, static_slab_test<StaticUnmanagedTestTraits<MutexLock>>) |
| MAKE_TEST(StaticUniquePtrMutex, static_slab_test<StaticUniquePtrTestTraits<MutexLock>>) |
| MAKE_TEST(StaticRefPtrMutex, static_slab_test<StaticRefPtrTestTraits<MutexLock>>) |
| MAKE_TEST(CountedUnmanagedSingleSlabMutex, |
| slab_test<UnmanagedTestTraits<MutexLock, fbl::SlabAllocatorFlavor::INSTANCED, |
| fbl::SlabAllocatorOptions::EnableObjectCount>, |
| 1>) |
| MAKE_TEST(CountedUnmanagedMultiSlabMutex, |
| slab_test<UnmanagedTestTraits<MutexLock, fbl::SlabAllocatorFlavor::INSTANCED, |
| fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST( |
| CountedUniquePtrSingleSlabMutex, |
| slab_test<UniquePtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>, 1>) |
| MAKE_TEST(CountedUniquePtrMultiSlabMutex, |
| slab_test<UniquePtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedRefPtrSingleSlabMutex, |
| slab_test<RefPtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>, 1>) |
| MAKE_TEST(CountedRefPtrMultiSlabMutex, |
| slab_test<RefPtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedUnmanagedSingleSlabUnlock, |
| slab_test<UnmanagedTestTraits<NullLock, fbl::SlabAllocatorFlavor::INSTANCED, |
| fbl::SlabAllocatorOptions::EnableObjectCount>, |
| 1>) |
| MAKE_TEST(CountedUnmanagedMultiSlabUnlock, |
| slab_test<UnmanagedTestTraits<NullLock, fbl::SlabAllocatorFlavor::INSTANCED, |
| fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedUniquePtrSingleSlabUnlock, |
| slab_test<UniquePtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>, 1>) |
| MAKE_TEST(CountedUniquePtrMultiSlabUnlock, |
| slab_test<UniquePtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedRefPtrSingleSlabUnlock, |
| slab_test<RefPtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>, 1>) |
| MAKE_TEST(CountedRefPtrMultiSlabUnlock, |
| slab_test<RefPtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedManualDeleteUnmanagedMutex, |
| slab_test<UnmanagedTestTraits<MutexLock, fbl::SlabAllocatorFlavor::MANUAL_DELETE, |
| fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedManualDeleteUnmanagedUnlock, |
| slab_test<UnmanagedTestTraits<NullLock, fbl::SlabAllocatorFlavor::MANUAL_DELETE, |
| fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticUnmanagedMutex, |
| static_slab_test< |
| StaticUnmanagedTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticUniquePtrMutex, |
| static_slab_test< |
| StaticUniquePtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticRefPtrMutex, |
| static_slab_test< |
| StaticRefPtrTestTraits<MutexLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticUnmanagedUnlock, |
| static_slab_test< |
| StaticUnmanagedTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticUniquePtrUnlock, |
| static_slab_test< |
| StaticUniquePtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| MAKE_TEST(CountedStaticRefPtrUnlock, |
| static_slab_test< |
| StaticRefPtrTestTraits<NullLock, fbl::SlabAllocatorOptions::EnableObjectCount>>) |
| |
| #undef MAKE_TEST |
| |
| TEST(SlabAllocatorTest, AllowManualDeleteOperator) { |
| #if TEST_WILL_NOT_COMPILE || 0 |
| { |
| struct Obj; |
| using Traits = |
| fbl::StaticSlabAllocatorTraits<std::unique_ptr<Obj>, 4096, fbl::Mutex, |
| fbl::SlabAllocatorOptions::AllowManualDeleteOperator>; |
| struct Obj : public fbl::SlabAllocated<Traits> {}; |
| [[maybe_unused]] fbl::SlabAllocator<Traits> allocator(1); |
| } |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| { |
| struct Obj; |
| using Traits = fbl::UnlockedStaticSlabAllocatorTraits< |
| std::unique_ptr<Obj>, 4096, fbl::SlabAllocatorOptions::AllowManualDeleteOperator>; |
| struct Obj : public fbl::SlabAllocated<Traits> {}; |
| [[maybe_unused]] fbl::SlabAllocator<Traits> allocator(1); |
| } |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| { |
| struct Obj; |
| using Traits = |
| fbl::InstancedSlabAllocatorTraits<std::unique_ptr<Obj>, 4096, fbl::Mutex, |
| fbl::SlabAllocatorOptions::AllowManualDeleteOperator>; |
| struct Obj : public fbl::SlabAllocated<Traits> {}; |
| [[maybe_unused]] fbl::SlabAllocator<Traits> allocator(1); |
| } |
| #endif |
| #if TEST_WILL_NOT_COMPILE || 0 |
| { |
| struct Obj; |
| using Traits = fbl::UnlockedInstancedSlabAllocatorTraits< |
| std::unique_ptr<Obj>, 4096, fbl::SlabAllocatorOptions::AllowManualDeleteOperator>; |
| struct Obj : public fbl::SlabAllocated<Traits> {}; |
| [[maybe_unused]] fbl::SlabAllocator<Traits> allocator(1); |
| } |
| #endif |
| { |
| struct Obj; |
| struct DeleteFriend; |
| using Traits = fbl::UnlockedManualDeleteSlabAllocatorTraits< |
| Obj*, 4096, fbl::SlabAllocatorOptions::AllowManualDeleteOperator>; |
| struct Obj : public fbl::SlabAllocated<Traits> { |
| friend struct DeleteFriend; |
| }; |
| |
| struct DeleteFriend { |
| static void Delete(Obj* obj) { delete obj; } |
| }; |
| |
| [[maybe_unused]] fbl::SlabAllocator<Traits> allocator(1); |
| |
| // Heap allocate and then delete an object. This should never ASSERT |
| // because of the option flag that we passed. Note that we still need to be |
| // a friend of the object in order to even attempt to do this. |
| Obj* the_obj = new Obj(); |
| ASSERT_NOT_NULL(the_obj); |
| DeleteFriend::Delete(the_obj); |
| } |
| } |
