Add sub-allocated descriptor sets

include/nbl/video/alloc/SubAllocatedDescriptorSet.h

@@ -17,7 +17,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 public:
 	// address allocator gives offsets
 	// reserved allocator allocates memory to keep the address allocator state inside
-	using AddressAllocator = core::GeneralpurposeAddressAllocator<uint32_t>;
+	using AddressAllocator = core::PoolAddressAllocator<uint32_t>;
 	using ReservedAllocator = core::allocator<uint8_t>;
 	using size_type = typename AddressAllocator::size_type;
 	using value_type = typename AddressAllocator::size_type;
@@ -29,7 +29,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 		std::shared_ptr<ReservedAllocator> reservedAllocator;
 		size_t reservedSize;
 	};
-	std::vector<SubAllocDescriptorSetRange> m_allocatableRanges = {};
+	std::unordered_map<uint32_t, SubAllocDescriptorSetRange> m_allocatableRanges = {};
 
 
 public:
@@ -50,26 +50,20 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 				auto count = redirect.getCount(storageIndex);
 				auto flags = redirect.getCreateFlags(storageIndex);
 
-				for (uint32_t j = m_allocatableRanges.size(); j < binding.data; j++)
-				{
-					m_allocatableRanges.push_back({});
-				}
-
-				SubAllocDescriptorSetRange range;
-				range.reservedSize = 0;
 				// Only bindings with these flags will be allocatable
 				if (flags.hasFlags(core::bitflag(IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_UPDATE_AFTER_BIND_BIT)
 					| IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_UPDATE_UNUSED_WHILE_PENDING_BIT
 					| IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_PARTIALLY_BOUND_BIT))
 				{
+					SubAllocDescriptorSetRange range;
 					range.reservedSize = AddressAllocator::reserved_size(maxAllocatableAlignment, static_cast<size_type>(count), args...);
 					range.reservedAllocator = std::shared_ptr<ReservedAllocator>(new ReservedAllocator());
 					range.addressAllocator = std::shared_ptr<AddressAllocator>(new AddressAllocator(
 						range.reservedAllocator->allocate(range.reservedSize, _NBL_SIMD_ALIGNMENT),
 						static_cast<size_type>(0), 0u, maxAllocatableAlignment, static_cast<size_type>(count), std::forward<Args>(args)...
 					));
+					m_allocatableRanges.emplace(binding.data, range);
 				}
-				m_allocatableRanges.insert(m_allocatableRanges.begin() + binding.data, range);
 			}
 		}
 	}
@@ -91,27 +85,42 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 	uint32_t getLayoutBindingCount() { return m_allocatableRanges.size(); }
 
 	// whether that binding index can be sub-allocated
-	bool isBindingAllocatable(uint32_t binding) { return m_allocatableRanges[binding].reservedSize != 0; }
+	bool isBindingAllocatable(uint32_t binding) 
+	{ 
+		return m_allocatableRanges.find(binding) != m_allocatableRanges.end(); 
+	}
 
 	AddressAllocator& getBindingAllocator(uint32_t binding) 
 	{ 
-		assert(isBindingAllocatable(binding)); // Check if this binding has an allocator
-		return *m_allocatableRanges[binding].addressAllocator; 
+		auto range = m_allocatableRanges.find(binding);
+		assert(range != m_allocatableRanges.end());// Check if this binding has an allocator
+		return *range->second.addressAllocator; 
 	}
 
 	// main methods
 
 	//! Warning `outAddresses` needs to be primed with `invalid_value` values, otherwise no allocation happens for elements not equal to `invalid_value`
-	template<typename... Args>
-	inline void multi_allocate(uint32_t binding, uint32_t count, value_type* outAddresses, const size_type* sizes, const Args&... args)
+	inline void multi_allocate(uint32_t binding, uint32_t count, value_type* outAddresses)
 	{
-		core::address_allocator_traits<AddressAllocator>::multi_alloc_addr(getBindingAllocator(binding), count, outAddresses, sizes, 1, args...);
+		auto& allocator = getBindingAllocator(binding);
+		for (uint32_t i=0; i<count; i++)
+		{
+			if (outAddresses[i]!=AddressAllocator::invalid_address)
+				continue;
+
+			outAddresses[i] = allocator.alloc_addr(1,1);
+		}
 	}
-	inline void multi_deallocate(uint32_t binding, uint32_t count, const size_type* addr, const size_type* sizes)
+	inline void multi_deallocate(uint32_t binding, uint32_t count, const size_type* addr)
 	{
-		auto& range = m_allocatableRanges[binding];
-		assert(range.reservedSize); // Check if this binding has an allocator
-		core::address_allocator_traits<AddressAllocator>::multi_free_addr(getBindingAllocator(binding), count, addr, sizes);
+		auto& allocator = getBindingAllocator(binding);
+		for (uint32_t i=0; i<count; i++)
+		{
+			if (addr[i]==AddressAllocator::invalid_address)
+				continue;
+
+			allocator.free_addr(addr[i],1);
+		}
 	}
 };