Revised some PR review comments, pending bug related to constructors not being called when freeing list

Author: Fletterio

include/nbl/core/alloc/AddressAllocatorBase.h

@@ -25,11 +25,7 @@ namespace core
         public:
             _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-            AddressAllocatorBase() :
-                reservedSpace(nullptr), addressOffset(invalid_address), alignOffset(invalid_address),
-                maxRequestableAlignment(invalid_address), combinedOffset(invalid_address) {}
-            
-
+            AddressAllocatorBase() { invalidate(); }
 
             inline _size_type           max_alignment() const noexcept
             {

include/nbl/core/alloc/aligned_allocator_adaptor.h

@@ -18,19 +18,19 @@ template <class Alloc, size_t overAlign=_NBL_DEFAULT_ALIGNMENT(typename std::all
 class NBL_FORCE_EBO aligned_allocator_adaptor : public Alloc
 {
     public:
-        typedef std::allocator_traits<Alloc>                    traits;
+        using traits                                            = std::allocator_traits<Alloc>;
 
         template< class U > struct rebind
         {
-            typedef aligned_allocator_adaptor<typename Alloc::template rebind<U>::other,overAlign> other;
+            using other = aligned_allocator_adaptor<typename Alloc::template rebind<U>::other,overAlign>;
         };
 
         constexpr static size_t m_type_align                    = alignof(typename traits::value_type);
         constexpr static size_t m_align                         = overAlign>m_type_align ? overAlign:m_type_align;
         constexpr static size_t m_align_minus_1                 = m_align-1u;
 
-        typedef typename traits::template rebind_alloc<uint8_t> ubyte_alloc;
-        typedef typename ubyte_alloc::pointer                   ubyte_ptr;
+        using ubyte_alloc                                       = typename traits::template rebind_alloc<uint8_t>;
+        using ubyte_ptr                                         = typename ubyte_alloc::pointer;
 
     private:
         // better and faster than boost for stateful allocators (no construct/destruct of rebound allocator on every alloc/dealloc)

include/nbl/core/containers/DoublyLinkedList.h

@@ -64,10 +64,11 @@ struct alignas(void*) SDoublyLinkedNode
 	}
 };
 
-template<typename Value>
+template<typename Value, class allocator = core::allocator<SDoublyLinkedNode<Value>> >
 class DoublyLinkedList
 {
 public:
+	using allocator_t = allocator;
 	using address_allocator_t = PoolAddressAllocator<uint32_t>;
 	using node_t = SDoublyLinkedNode<Value>;
 	using value_t = Value;
@@ -121,7 +122,7 @@ class DoublyLinkedList
 	{
 		disposeAll();
 
-		m_addressAllocator = std::unique_ptr<address_allocator_t>(new address_allocator_t(m_reservedSpace, 0u, 0u, 1u, m_cap, 1u));
+		m_addressAllocator = address_allocator_t(m_reservedSpace, 0u, 0u, 1u, m_cap, 1u);
 		m_back = invalid_iterator;
 		m_begin = invalid_iterator;
 
@@ -186,9 +187,9 @@ class DoublyLinkedList
 		// Must at least make list grow
 		if (newCapacity <= m_cap)
 			return false;
-		// Same as code found in ContiguousMemoryLinkedListBase to create aligned space
+		// Have to consider allocating enough space for list AND state of the address allocator
 		const auto firstPart = core::alignUp(address_allocator_t::reserved_size(1u, newCapacity, 1u), alignof(node_t));
-		void* newReservedSpace = _NBL_ALIGNED_MALLOC(firstPart + newCapacity * sizeof(node_t), alignof(node_t));
+		void* newReservedSpace = reinterpret_cast<void*>(m_allocator.allocate(firstPart + newCapacity * sizeof(node_t)));
 
 		// Malloc failed, not possible to grow
 		if (!newReservedSpace)
@@ -198,9 +199,9 @@ class DoublyLinkedList
 		// Copy memory over to new buffer
 		memcpy(newArray, m_array, m_cap * sizeof(node_t));
 		// Create new address allocator from old one
-		m_addressAllocator = std::make_unique<address_allocator_t>(newCapacity, std::move(*(m_addressAllocator)), newReservedSpace);
+		m_addressAllocator = address_allocator_t(newCapacity, std::move(m_addressAllocator), newReservedSpace);
 		// After address allocator creation we can free the old buffer
-		_NBL_ALIGNED_FREE(m_reservedSpace);
+		m_allocator.deallocate(reinterpret_cast<node_t*>(m_reservedSpace));
 		m_cap = newCapacity;
 		m_array = newArray;
 		m_reservedSpace = newReservedSpace;
@@ -210,13 +211,15 @@ class DoublyLinkedList
 	}
 
 	//Constructor, capacity determines the amount of allocated space
-	DoublyLinkedList(const uint32_t capacity, disposal_func_t&& dispose_f = disposal_func_t()) : m_dispose_f(std::move(dispose_f))
+	DoublyLinkedList(const uint32_t capacity, disposal_func_t&& dispose_f = disposal_func_t(), const allocator_t& _allocator = allocator_t()) 
+		: m_dispose_f(std::move(dispose_f)), m_allocator(_allocator)
 	{
+		// Have to consider allocating enough space for list AND state of the address allocator
 		const auto firstPart = core::alignUp(address_allocator_t::reserved_size(1u, capacity, 1u), alignof(node_t));
-		m_reservedSpace = _NBL_ALIGNED_MALLOC(firstPart + capacity * sizeof(node_t), alignof(node_t));
+		m_reservedSpace = reinterpret_cast<void*>(m_allocator.allocate(firstPart + capacity * sizeof(node_t)));
 		m_array = reinterpret_cast<node_t*>(reinterpret_cast<uint8_t*>(m_reservedSpace) + firstPart);
 
-		m_addressAllocator = std::make_unique<address_allocator_t>(m_reservedSpace, 0u, 0u, 1u, capacity, 1u);
+		m_addressAllocator = address_allocator_t(m_reservedSpace, 0u, 0u, 1u, capacity, 1u);
 		m_cap = capacity;
 		m_back = invalid_iterator;
 		m_begin = invalid_iterator;
@@ -230,35 +233,36 @@ class DoublyLinkedList
 
 	DoublyLinkedList& operator=(DoublyLinkedList&& other)
 	{
+		m_allocator = std::move(other.m_allocator);
 		m_addressAllocator = std::move(other.m_addressAllocator);
-		m_reservedSpace = other.m_reservedSpace;
-		m_array = other.m_array;
-		m_dispose_f = std::move(other.m_dispose_f);
-		m_cap = other.m_cap;
-		m_back = other.m_back;
+		m_reservedSpace = std::move(other.m_reservedSpace);
+		m_array = std::move(other.m_array);
+		m_dispose_f = std::move(std::move(other.m_dispose_f));
+		m_cap = std::move(other.m_cap);
+		
 		m_begin = other.m_begin;
+		m_back = other.m_back;
+		other.m_begin = invalid_iterator;
+		other.m_back = invalid_iterator;
 
-		// Nullify other
-		other.m_addressAllocator = nullptr;
-		other.m_reservedSpace = nullptr;
-		other.m_array = nullptr;
-		other.m_cap = 0u;
-		other.m_back = 0u;
-		other.m_begin = 0u;
 		return *this;
 	}
 
 	~DoublyLinkedList()
 	{
 		disposeAll();
-		_NBL_ALIGNED_FREE(m_reservedSpace);
+		// Could be null if list was moved out of
+		if (m_reservedSpace)
+		{
+			m_allocator.deallocate(reinterpret_cast<node_t*>(m_reservedSpace));
+		}
 	}
 
 private:
 	//allocate and get the address of the next free node
 	inline uint32_t reserveAddress()
 	{
-		uint32_t addr = m_addressAllocator->alloc_addr(1u, 1u);
+		uint32_t addr = m_addressAllocator.alloc_addr(1u, 1u);
 		return addr;
 	}
 
@@ -301,7 +305,7 @@ class DoublyLinkedList
 		if (m_dispose_f)
 			m_dispose_f(get(address)->data);
 		get(address)->~node_t();
-		m_addressAllocator->free_addr(address, 1u);
+		m_addressAllocator.free_addr(address, 1u);
 	}
 
 	inline void common_detach(node_t* node)
@@ -312,7 +316,8 @@ class DoublyLinkedList
 			get(node->prev)->next = node->next;
 	}
 
-	std::unique_ptr<address_allocator_t> m_addressAllocator;
+	allocator_t m_allocator;
+	address_allocator_t m_addressAllocator;
 	void* m_reservedSpace;
 	node_t* m_array;