full and complete draft of the new SimpleBlockBasedAllocator

Author: devshgraphicsprogramming

include/nbl/asset/ICPUScene.h

@@ -5,6 +5,7 @@
 #define _NBL_ASSET_I_CPU_SCENE_H_INCLUDED_
 
 
+// TODO: not memory pool but ... object pool
 #include "nbl/core/containers/CMemoryPool.h"
 
 #include "nbl/asset/IScene.h"

include/nbl/core/algorithm/utility.h

@@ -18,6 +18,7 @@ struct type_list_size<type_list<T...>> : std::integral_constant<size_t,sizeof...
 template<typename TypeList>
 inline constexpr size_t type_list_size_v = type_list_size<TypeList>::value;
 
+//
 template<template<typename> class, typename TypeList>
 struct filter;
 template<template<typename> class Pred, typename... T>
@@ -42,6 +43,13 @@ struct filter<Pred,type_list<T,Ts...>>
 template<template<typename> class Pred, typename TypeList>
 using filter_t = filter<Pred,TypeList>::type;
 
+// to work around `std::identity` not matching
+namespace impl
+{
+template<typename T>
+class identitiy {};
+}
+//
 template<template<class...> class ListLikeOutT, template<class> class X, typename ListLike>
 struct list_transform
 {
@@ -52,9 +60,20 @@ struct list_transform
 	public:
 		using type = decltype(_impl(std::declval<ListLike>()));
 };
+template<template<class...> class ListLikeOutT, typename ListLike>
+struct list_transform<ListLikeOutT,impl::identitiy,ListLike>
+{
+	private:
+		template<template<class...> class ListLikeInT, typename... T>
+		static ListLikeOutT<T...> _impl(const ListLikeInT<T...>&);
+		
+	public:
+		using type = decltype(_impl(std::declval<ListLike>()));
+};
 template<template<class...> class ListLikeOutT, template<class> class X, typename ListLike>
 using list_transform_t = list_transform<ListLikeOutT,X,ListLike>::type;
 
+//
 template<template<class> class X, typename ListLike>
 using tuple_transform_t = list_transform_t<std::tuple,X,ListLike>;
 

include/nbl/core/alloc/SimpleBlockBasedAllocator.h

@@ -10,6 +10,8 @@
 #include "nbl/core/alloc/address_allocator_traits.h"
 #include "nbl/core/alloc/AddressAllocatorConcurrencyAdaptors.h"
 
+#include "gtl/btree.hpp"
+
 #include <memory>
 #include <mutex>
 
@@ -24,202 +26,201 @@ class SimpleBlockBasedAllocator final
 {
 	public:
 		using addr_alloc_traits = address_allocator_traits<AddressAllocator>;
+		using extra_params_t = tuple_transform_t<impl::identitiy,addr_alloc_traits::extra_ctor_param_types>;
 		using size_type = typename addr_alloc_traits::size_type;
 		// The blocks will be allocated aligned to at least this value
 		constexpr static inline size_type meta_alignment = 64u;
 
 	private:
-		using extra_params_t = tuple_transform_t<std::type_identity,addr_alloc_traits::extra_ctor_param_types>;
+		using this_t = SimpleBlockBasedAllocator<AddressAllocator>;
 		// Blocks get allocated/deallocated on demand, inside there's a suballocator.
 		// Blocks are always the same size, and obviously can't allocate anything larger than themselves.
-		class Block
+		class alignas(16) Block final
 		{
+				friend class this_t;
+
 				AddressAllocator addrAlloc;
 
-			public:
-				template<typename... Args>
-				inline Block(const size_type blockSize, const Args&... args) :
-					addrAlloc(AddressAllocator(data()+blockSize,./*no address offset*/0u,/*no alignment offset needed*/0u,meta_alignment,blockSize,args...))
+				/* if std::apply doesn't work vause of deduction kicking in https://stackoverflow.com/questions/79893672/using-stdapply-in-a-class-template
+				* 
+				* use https://www.fluentcpp.com/2021/03/05/stdindex_sequence-and-its-improvement-in-c20/ instead
+				template<int ...> struct seq {};
+				template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> { };
+				template<int ...S> struct gens<0, S...> { typedef seq<S...> type; };
+
+				template<int ...S>
+				void constructBlock(Block* mem,seq<S...>)
 				{
-					assert(addr_alloc_traits::get_align_offset(addrAlloc) == 0ul);
-					assert(addr_alloc_traits::get_combined_offset(addrAlloc) == 0u);
+					std::construct_at(mem,m_blockSize,std::get<S>(blockCreationArgs)...);
 				}
+				template<typename... Ts>
+				static inline computeReservedSize(const core::tuple<Ts...>& _addrCreationArgs)
+				{
+					return addr_alloc_traits::reserved_size(meta_alignment,blockSize,std::get<>(_addrCreationArgs)...);
+				}
+				*/
 
-				template<typename... Args>
-				static size_type size_of(size_type blockSize, const Args&... args)
+			public:
+				struct SCreationParams
 				{
-					return core::alignUp(sizeof(AddressAllocator),meta_alignment)+blockSize+addr_alloc_traits::reserved_size(meta_alignment,blockSize,args...);
+					inline SCreationParams(const size_type _blockSize, const extra_params_t& extraArgs) : addrCreationArgs(extraArgs), blockSize(_blockSize),
+						reservedSize(std::apply([blockSize]<typename... Args>(const Args&... args)->size_type
+							{
+								return addr_alloc_traits::reserved_size(meta_alignment,blockSize,args...);
+							},addrCreationArgs)
+						), totalSize(core::alignUp(sizeof(Block)+reservedSize,meta_alignment)+blockSize) {}
+
+					const extra_params_t addrCreationArgs;
+					const size_type blockSize;
+					const size_type reservedSize;
+					const size_type totalSize;
+				};
+				//
+				inline Block(const SCreationParams& params) : addrAlloc(AddressAllocator())
+				{
+					std::apply([&params]<typename... Args>(const Args&... args)->void
+						{
+							addrAlloc = AddressAllocator(this+1,./*no address offset*/0u,/*no alignment offset needed*/0u,meta_alignment,params.blockSize,args...);
+						},params.addrCreationArgs
+					);
+					assert(addr_alloc_traits::get_align_offset(addrAlloc) == 0ul);
+					assert(addr_alloc_traits::get_combined_offset(addrAlloc) == 0u);
 				}
 
-				uint8_t* data() { return reinterpret_cast<uint8_t*>(this)+core::alignUp(sizeof(AddressAllocator),meta_alignment); }
-				const uint8_t* data() const
+				inline uint8_t* data(const SCreationParams& params) {return reinterpret_cast<uint8_t*>(this)+params.totalSize-params.blockSize;}
+				inline const uint8_t* data() const
 				{
 					return const_cast<Block*>(this)->data();
 				}
 
-				const AddressAllocator& getAllocator() const { return addrAlloc; }
+				const AddressAllocator& getAllocator() const {return addrAlloc;}
 
 				size_type alloc(size_type bytes, size_type alignment)
 				{
 					size_type addr = AddressAllocator::invalid_address;
-					addr_alloc_traits::multi_alloc_addr(addrAlloc, 1u, &addr, &bytes, &alignment);
+					addr_alloc_traits::multi_alloc_addr(addrAlloc,1u,&addr,&bytes,&alignment);
 					return addr;
 				}
 
 				void free(size_type addr, size_type bytes)
 				{
-					addr_alloc_traits::multi_free_addr(addrAlloc, 1u, &addr, &bytes);
+					addr_alloc_traits::multi_free_addr(addrAlloc,1u,&addr,&bytes);
 				}
 		};
 
     public:
         virtual inline ~SimpleBlockBasedAllocator()
 		{
 			reset();
-			metaAlloc.deallocate(blocks,maxBlockCount);
 		}
 
-		template<typename... Args>
-		inline SimpleBlockBasedAllocator(smart_refctd_ptr<refctd_memory_resource>&& _mem_resource, const size_type _blockSize, const size_type _initBlockCount, Args&&... args) :
-			m_blockCreationArgs(std::forward<Args>(args)...), m_mem_resource(std::move(_mem_resource)), m_blockSize(_blockSize), m_effectiveBlockSize(Block::size_of(m_blockSize,m_blockCreationArgs))
+		struct SCreationParams
 		{
-// TODO: block init
-			m_initBlockCount = std::max<size_type>(_initBlockCount,1));
-			blocks = metaAlloc.allocate(maxBlockCount,meta_alignment))
-			std::fill(blocks,blocks+maxBlockCount,nullptr);
-		}
-
-		inline SimpleBlockBasedAllocator& operator=(SimpleBlockBasedAllocator&& other)
-        {
-			std::swap(m_blockCreationArgs,other.m_blockCreationArgs);
-			std::swap(m_mem_resource,other.m_mem_resource);
-			std::swap(m_blockSize,other.m_blockSize);
-			std::swap(m_effectiveBlockSize,other.m_effectiveBlockSize);
-// TODO: block swap
-            return *this;
-        }
-		inline SimpleBlockBasedAllocator(SimpleBlockBasedAllocator<AddressAllocator>&& other)
+			smart_refctd_ptr<refctd_memory_resource> mem_resource;
+			extra_params_t addrAllocCtorExtraParams;
+			size_type blockSize = 128u<<10;
+			size_type initBlockCount = 1;
+		};
+		inline SimpleBlockBasedAllocator(SCreationParams&& params) : m_blockCreationParams(params.blockSize,std::move(params.addrAllocCtorExtraParams)),
+			m_initBlockCount(std::max<size_type>(_initBlockCount,1)), m_mem_resource(std::move(params.mem_resource))
 		{
-			operator=(std::move(other));
+			m_blocks.reserve(m_initBlockCount);
+			for (auto i=0u; i<m_initBlockCount; i++)
+				m_blocks.insert(createBlock());
 		}
 
-        inline void		reset()
+		// deallocates everything
+        inline void	reset()
         {
-// TODO: reset
-			for (auto i=minBlockCount; i<maxBlockCount; i++)
-				deleteBlock(i);
+			assert(m_blocks.size()>=m_initBlockCount);
+			auto it = m_blocks.begin();
+			for (auto i=0u; i<m_initBlockCount; i++)
+			{
+				auto* block = *(it++);
+				if (i<m_initBlockCount)
+					block->getAllocator().reset();
+				else
+					deleteBlock(block);
+			}
+			m_blocks.erase(m_blocks.begin()+m_initBlockCount,m_blocks.end());
         }
 
-
-		inline void*	allocate(const size_type bytes, const size_type alignment) noexcept
+		//
+		inline void* allocate(const size_type bytes, const size_type alignment) noexcept
 		{
-// TODO: rewrite
 			constexpr auto invalid_address = AddressAllocator::invalid_address;
-			for (size_type i=0u; i<maxBlockCount; i++)
+			// TODO: better allocation strategies like tlsf
+			for (auto& entry : m_blocks)
 			{
-				auto& block = blocks[i];
-
-				bool die = i==(maxBlockCount-1u);
-				if (!block)
-				{
-					block = createBlock();
-					die = true;
-				}
-
-				size_type addr = block->alloc(bytes, alignment);
-				if (addr == invalid_address)
-				{
-					if (die)
-						break;
-					else
-						continue;
-				}
-
+				auto* block = entry;
+				if (const auto addr=block->alloc(bytes,alignment); addr!=invalid_address)
+					return block->data()+addr;
+			}
+			auto* block = createBlock();
+			if (const auto addr=block->alloc(bytes,alignment); addr!=invalid_address)
+			{
+				m_blocks.insert(block);
 				return block->data()+addr;
 			}
+			else
+				deleteBlock(block);
 			return nullptr;
 		}
-		inline void		deallocate(void* p, const size_type bytes) noexcept
+		inline void	deallocate(void* p, const size_type bytes) noexcept
 		{
-// TODO: rewrite
-			for (size_type i=0u; i<maxBlockCount; i++)
+			assert(m_blocks.size()>=m_initBlockCount);
+			auto found = m_blocks.lower_bound(reinterpret_cast<Block*>(p));
+			assert(found!=m_blocks.end());
+			auto* block = *found;
+			assert(block->data()<=p && p<block->data()+m_blockCreationParams.blockSize);
+			const size_type addr = reinterpret_cast<uint8_t*>(p)-block->data();
+			block->free(addr,bytes);
+			if (m_blocks.size()>m_initBlockCount && addr_alloc_traits::get_allocated_size(block->getAllocator())==size_type(0u))
 			{
-				auto& block = blocks[i];
-				if (!block)
-					continue;
-                    
-				size_type addr = reinterpret_cast<uint8_t*>(p)-block->data();
-				if (addr<blockSize)
-				{
-					block->free(addr,bytes);
-					if (i>=minBlockCount && addr_alloc_traits::get_allocated_size(block->getAllocator())==size_type(0u))
-						deleteBlock(i);
-					return;
-				}
+				deleteBlock(block);
+				m_blocks.erase(found);
 			}
-			assert(false);
 		}
 
-		inline bool		operator!=(const SimpleBlockBasedAllocator<AddressAllocator,DataAllocator>& other) const noexcept
+		inline bool	operator!=(const this_t& other) const noexcept
 		{
-// TODO: rewrite
-			if (blockSize != other.blockSize)
-				return true;
-			if (effectiveBlockSize != other.effectiveBlockSize)
+			if (m_blockCreationParams != other.m_blockCreationParams)
 				return true;
-			if (minBlockCount != other.minBlockCount)
+			if (m_initBlockCount != other.m_initBlockCount)
 				return true;
-			if (maxBlockCount != other.maxBlockCount)
+			if (m_mem_resource != other.m_mem_resource)
 				return true;
-			if (metaAlloc != other.metaAlloc)
-				return true;
-			if (blocks != other.blocks)
-				return true;
-			if (blockAlloc != other.blockAlloc)
+			if (m_backBlock != other.m_backBlock)
 				return true;
 			return false;
 		}
-		inline bool		operator==(const SimpleBlockBasedAllocator<AddressAllocator,DataAllocator>& other) const noexcept
+		inline bool	operator==(const this_t& other) const noexcept
 		{
 			return !operator!=(other);
 		}
 
     protected:
-		extra_params_t m_blockCreationArgs;
-		smart_refctd_ptr<refctd_memory_resource> m_mem_resource;
-		size_type m_blockSize;
-		size_type m_effectiveBlockSize;
-		// TODO: rewrite this
-size_type m_initBlockCount;
-Block** blocks;
-
-
-		template<int ...> struct seq {};
-		template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> { };
-		template<int ...S> struct gens<0, S...> { typedef seq<S...> type; };
-
-		template<int ...S>
-		void constructBlock(Block* mem,seq<S...>)
+		using block_map_t = gtl::btree_set<Block*>;
+		
+		inline Block* createBlock()
 		{
-			std::construct_at(mem,m_blockSize,std::get<S>(blockCreationArgs)...);
+			auto* block = reinterpret_cast<Block*>(m_mem_resource->allocate(m_blockCreationParams.totalSize,meta_alignment));
+			std::construct_at(block,m_blockCreationArgs);
+			m_blocks.insert(block);
+			return block;
 		}
-		Block* createBlock()
+		inline void deleteBlock(Block* block)
 		{
-			auto retval = reinterpret_cast<Block*>(blockAlloc.allocate(effectiveBlockSize, meta_alignment));
-			constructBlock(retval,typename gens<sizeof...(Args)>::type());
-			return retval;
+			assert(block);
+			std::destroy_at(block);
+			m_mem_resource->deallocate(block,m_blockCreationParams.totalSize,meta_alignment);
 		}
 
-
-		void deleteBlock(uint32_t index)
-		{
-			if (!blocks[index])
-				return;
-
-			blocks[index]->~Block();
-			blockAlloc.deallocate(reinterpret_cast<uint8_t*>(blocks[index]),effectiveBlockSize);
-			blocks[index] = nullptr;
-		}
+		const Block::SCreationParams m_blockCreationParams;
+		const uint32_t m_initBlockCount;
+		smart_refctd_ptr<refctd_memory_resource> m_mem_resource;
+		// TODO: better allocation strategies like tlsf
+		block_map_t m_blocks;
 };
 
 template<class AddressAllocator>