Add sub-allocated descriptor sets

include/nbl/video/IGPUDescriptorSet.h

@@ -57,6 +57,20 @@ class IGPUDescriptorSet : public asset::IDescriptorSet<const IGPUDescriptorSetLa
         inline IDescriptorPool* getPool() const { return m_pool.get(); }
         inline bool isZombie() const { return (m_pool.get() == nullptr); }
 
+        // why is this private? nothing it uses is private
+        // small utility
+        inline asset::IDescriptor::E_TYPE getBindingType(const uint32_t binding) const
+        {
+            for (auto t=0u; t<static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); t++)
+            {
+                const auto type = static_cast<asset::IDescriptor::E_TYPE>(t);
+                const auto& bindingRedirect = getLayout()->getDescriptorRedirect(type);
+                if (bindingRedirect.getStorageOffset(redirect_t::binding_number_t{binding}).data!=redirect_t::Invalid)
+                    return type;
+            }
+            return asset::IDescriptor::E_TYPE::ET_COUNT;
+        }
+
 	protected:
         IGPUDescriptorSet(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& _layout, core::smart_refctd_ptr<IDescriptorPool>&& pool, IDescriptorPool::SStorageOffsets&& offsets);
         virtual ~IGPUDescriptorSet();
@@ -69,7 +83,7 @@ class IGPUDescriptorSet : public asset::IDescriptorSet<const IGPUDescriptorSetLa
         void processWrite(const IGPUDescriptorSet::SWriteDescriptorSet& write, const asset::IDescriptor::E_TYPE type);
         bool validateCopy(const IGPUDescriptorSet::SCopyDescriptorSet& copy) const;
         void processCopy(const IGPUDescriptorSet::SCopyDescriptorSet& copy);
-        void dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop, const asset::IDescriptor::E_TYPE type);
+        void dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop);
 
         using redirect_t = IGPUDescriptorSetLayout::CBindingRedirect;
         // This assumes that descriptors of a particular type in the set will always be contiguous in pool's storage memory, regardless of which binding in the set they belong to.
@@ -85,18 +99,6 @@ class IGPUDescriptorSet : public asset::IDescriptorSet<const IGPUDescriptorSetLa
 
             return descriptors+localOffset;
         }
-        // small utility
-        inline asset::IDescriptor::E_TYPE getBindingType(const uint32_t binding) const
-        {
-            for (auto t=0u; t<static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); t++)
-            {
-                const auto type = static_cast<asset::IDescriptor::E_TYPE>(t);
-                const auto& bindingRedirect = getLayout()->getDescriptorRedirect(type);
-                if (bindingRedirect.getStorageOffset(redirect_t::binding_number_t{binding}).data!=redirect_t::Invalid)
-                    return type;
-            }
-            return asset::IDescriptor::E_TYPE::ET_COUNT;
-        }
 
         inline core::smart_refctd_ptr<IGPUSampler>* getMutableSamplers(const uint32_t binding) const
         {

include/nbl/video/ILogicalDevice.h

@@ -633,7 +633,7 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
         }
 
         // should this be joined together with the existing updateDescriptorSets?
-        bool nullifyDescriptors(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors, asset::IDescriptor::E_TYPE descriptorType);
+        bool nullifyDescriptors(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors);
 
         //! Renderpasses and Framebuffers
         core::smart_refctd_ptr<IGPURenderpass> createRenderpass(const IGPURenderpass::SCreationParams& params);
@@ -853,7 +853,7 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
 
         // Drops refcounted references of the descriptors in these indices for the descriptor lifetime tracking 
         // If the nullDescriptor device feature is enabled, this would also write a null descriptor to the descriptor set
-        virtual void nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors, asset::IDescriptor::E_TYPE descriptorType) = 0;
+        virtual void nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors) = 0;
 
         virtual core::smart_refctd_ptr<IGPURenderpass> createRenderpass_impl(const IGPURenderpass::SCreationParams& params, IGPURenderpass::SCreationParamValidationResult&& validation) = 0;
         virtual core::smart_refctd_ptr<IGPUFramebuffer> createFramebuffer_impl(IGPUFramebuffer::SCreationParams&& params) = 0;

include/nbl/video/alloc/SubAllocatedDescriptorSet.h

@@ -284,7 +284,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 			nulls.resize(m_totalDeferredFrees);
 			auto outNulls = nulls.data();
 			eventHandler->wait(maxWaitPoint, unallocatedSize, outNulls);
-			m_logicalDevice->nullifyDescriptors({ nulls.data(),outNulls }, range->second.descriptorType);
+			m_logicalDevice->nullifyDescriptors({ nulls.data(),outNulls });
 
 			// always call with the same parameters, otherwise this turns into a mess with the non invalid_address gaps
 			unallocatedSize = try_multi_allocate(binding,count,outAddresses);
@@ -352,7 +352,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 			auto actualEnd = multi_deallocate(nulls.data(), binding, count, addr);
 			// This is checked to be valid above
 			auto range = m_allocatableRanges.find(binding);
-			m_logicalDevice->nullifyDescriptors({nulls.data(),actualEnd}, range->second.descriptorType);
+			m_logicalDevice->nullifyDescriptors({nulls.data(),actualEnd});
 		}
 	}
 
@@ -367,9 +367,8 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 		{
 			auto& it = m_allocatableRanges[i];
 			frees += it.eventHandler->poll(outNulls).eventsLeft;
-			// TODO: this could be optimized to be put outside the loop
-			m_logicalDevice->nullifyDescriptors({nulls.data(),outNulls}, it.descriptorType);
 		}
+		m_logicalDevice->nullifyDescriptors({nulls.data(),outNulls});
 		return frees;
 	}
 };

src/nbl/video/CVulkanLogicalDevice.cpp

@@ -635,12 +635,15 @@ core::smart_refctd_ptr<IDescriptorPool> CVulkanLogicalDevice::createDescriptorPo
     return nullptr;
 }
 
+// a lot of empirical research went into defining this constant
+constexpr uint32_t MaxDescriptorSetAsWrites = 69u;
+
 void CVulkanLogicalDevice::updateDescriptorSets_impl(const SUpdateDescriptorSetsParams& params)
 {
     // Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of
     // VkWriteDescriptorSetAccelerationStructureKHR, VkWriteDescriptorSetAccelerationStructureNV, or VkWriteDescriptorSetInlineUniformBlockEXT
     core::vector<VkWriteDescriptorSet> vk_writeDescriptorSets(params.writes.size(),{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,nullptr});
-    core::vector<VkWriteDescriptorSetAccelerationStructureKHR> vk_writeDescriptorSetAS(69u,{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,nullptr});
+    core::vector<VkWriteDescriptorSetAccelerationStructureKHR> vk_writeDescriptorSetAS(MaxDescriptorSetAsWrites,{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,nullptr});
 
     core::vector<VkDescriptorBufferInfo> vk_bufferInfos(params.bufferCount);
     core::vector<VkDescriptorImageInfo> vk_imageInfos(params.imageCount);
@@ -727,40 +730,41 @@ void CVulkanLogicalDevice::updateDescriptorSets_impl(const SUpdateDescriptorSets
     m_devf.vk.vkUpdateDescriptorSets(m_vkdev,vk_writeDescriptorSets.size(),vk_writeDescriptorSets.data(),vk_copyDescriptorSets.size(),vk_copyDescriptorSets.data());
 }
 
-void CVulkanLogicalDevice::nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> drops, asset::IDescriptor::E_TYPE descriptorType)
+void CVulkanLogicalDevice::nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> drops)
 {
     if (getEnabledFeatures().nullDescriptor)
     {
-        return
+        return;
     }
 
 	core::vector<VkWriteDescriptorSet> vk_writeDescriptorSets(drops.size(),{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,nullptr});
-	core::vector<VkWriteDescriptorSetAccelerationStructureKHR> vk_writeDescriptorSetAS(69u,{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,nullptr});
+	core::vector<VkWriteDescriptorSetAccelerationStructureKHR> vk_writeDescriptorSetAS(MaxDescriptorSetAsWrites,{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,nullptr});
 
 	size_t maxSize = 0;
 	for (auto i = 0; i < drops.size(); i++)
 	{
 		const auto& write = drops[i];
-		maxSize = core::max(maxSize, write.count);
-	}
-	size_t descriptorSize;
-	switch (asset::IDescriptor::GetTypeCategory(descriptorType))
-	{
-        case asset::IDescriptor::EC_BUFFER:
+        auto descriptorType = write.dstSet->getBindingType(write.binding);
+		size_t descriptorSize;
+		switch (asset::IDescriptor::GetTypeCategory(descriptorType))
+		{
+		case asset::IDescriptor::EC_BUFFER:
 			descriptorSize = sizeof(VkDescriptorBufferInfo);
 			break;
-        case asset::IDescriptor::EC_IMAGE:
+		case asset::IDescriptor::EC_IMAGE:
 			descriptorSize = sizeof(VkDescriptorImageInfo);
 			break;
-        case asset::IDescriptor::EC_BUFFER_VIEW:
+		case asset::IDescriptor::EC_BUFFER_VIEW:
 			descriptorSize = sizeof(VkBufferView);
 			break;
-        case asset::IDescriptor::EC_ACCELERATION_STRUCTURE:
+		case asset::IDescriptor::EC_ACCELERATION_STRUCTURE:
 			descriptorSize = sizeof(VkAccelerationStructureKHR);
 			break;
+		}
+		maxSize = core::max(maxSize, write.count * descriptorSize);
 	}
 
-	core::vector<uint8_t> nullDescriptors(maxSize * descriptorSize, 0u);
+	core::vector<uint8_t> nullDescriptors(maxSize, 0u);
 
 	{
 		auto outWrite = vk_writeDescriptorSets.data();
@@ -769,6 +773,7 @@ void CVulkanLogicalDevice::nullifyDescriptors_impl(const std::span<const IGPUDes
 		for (auto i=0; i<drops.size(); i++)
 		{
 			const auto& write = drops[i];
+			auto descriptorType = write.dstSet->getBindingType(write.binding);
 
 			outWrite->dstSet = static_cast<const CVulkanDescriptorSet*>(write.dstSet)->getInternalObject();
 			outWrite->dstBinding = write.binding;
@@ -777,21 +782,22 @@ void CVulkanLogicalDevice::nullifyDescriptors_impl(const std::span<const IGPUDes
 			outWrite->descriptorCount = write.count;
 			switch (asset::IDescriptor::GetTypeCategory(descriptorType))
 			{
-				case asset::IDescriptor::EC_BUFFER:
-					outWrite->pBufferInfo = reinterpret_cast<VkDescriptorBufferInfo*>(nullDescriptors.data());
-					break;
-				case asset::IDescriptor::EC_IMAGE:
-					outWrite->pImageInfo = reinterpret_cast<VkDescriptorImageInfo*>(nullDescriptors.data());
-					break;
-				case asset::IDescriptor::EC_BUFFER_VIEW:
-					outWrite->pTexelBufferView = reinterpret_cast<VkBufferView*>(nullDescriptors.data());
-					break;
-				case asset::IDescriptor::EC_ACCELERATION_STRUCTURE:
-					outWriteAS->accelerationStructureCount = write.count;
-					outWriteAS->pAccelerationStructures = reinterpret_cast<VkAccelerationStructureKHR*>(nullDescriptors.data());
-					break;
-				default:
-					assert(!"Invalid code path.");
+			case asset::IDescriptor::EC_BUFFER:
+				outWrite->pBufferInfo = reinterpret_cast<VkDescriptorBufferInfo*>(nullDescriptors.data());
+				break;
+			case asset::IDescriptor::EC_IMAGE:
+				outWrite->pImageInfo = reinterpret_cast<VkDescriptorImageInfo*>(nullDescriptors.data());
+				break;
+			case asset::IDescriptor::EC_BUFFER_VIEW:
+				outWrite->pTexelBufferView = reinterpret_cast<VkBufferView*>(nullDescriptors.data());
+				break;
+			case asset::IDescriptor::EC_ACCELERATION_STRUCTURE:
+				outWriteAS->accelerationStructureCount = write.count;
+				outWriteAS->pAccelerationStructures = reinterpret_cast<VkAccelerationStructureKHR*>(nullDescriptors.data());
+				outWrite->pNext = outWriteAS++;
+				break;
+            default:
+                assert(!"Invalid code path.");
 			}
 			outWrite++;
 		}

src/nbl/video/CVulkanLogicalDevice.h

@@ -282,7 +282,7 @@ class CVulkanLogicalDevice final : public ILogicalDevice
         // descriptor sets
         core::smart_refctd_ptr<IDescriptorPool> createDescriptorPool_impl(const IDescriptorPool::SCreateInfo& createInfo) override;
         void updateDescriptorSets_impl(const SUpdateDescriptorSetsParams& params) override;
-        void nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors, asset::IDescriptor::E_TYPE descriptorType) override;
+        void nullifyDescriptors_impl(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors) override;
 
         // renderpasses and framebuffers
         core::smart_refctd_ptr<IGPURenderpass> createRenderpass_impl(const IGPURenderpass::SCreationParams& params, IGPURenderpass::SCreationParamValidationResult&& validation) override;

src/nbl/video/IGPUDescriptorSet.cpp

@@ -124,11 +124,13 @@ void IGPUDescriptorSet::processWrite(const IGPUDescriptorSet::SWriteDescriptorSe
     incrementVersion();
 }
 
-void IGPUDescriptorSet::dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop, const asset::IDescriptor::E_TYPE type)
+void IGPUDescriptorSet::dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop)
 {
     assert(drop.dstSet == this);
 
-	auto* dstDescriptors = drop.dstSet->getDescriptors(type, drop.binding);
+    const auto descriptorType = getBindingType(drop.binding);
+
+	auto* dstDescriptors = drop.dstSet->getDescriptors(descriptorType, drop.binding);
 	auto* dstSamplers = drop.dstSet->getMutableSamplers(drop.binding);
 
 	if (dstDescriptors)

src/nbl/video/ILogicalDevice.cpp

@@ -444,18 +444,25 @@ bool ILogicalDevice::updateDescriptorSets(const std::span<const IGPUDescriptorSe
     return true;
 }
 
-bool ILogicalDevice::nullifyDescriptors(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors, asset::IDescriptor::E_TYPE descriptorType)
+bool ILogicalDevice::nullifyDescriptors(const std::span<const IGPUDescriptorSet::SDropDescriptorSet> dropDescriptors)
 {
     for (const auto& drop : dropDescriptors)
     {
         auto ds = drop.dstSet;
         if (!ds || !ds->wasCreatedBy(this))
             return false;
+        // (no binding)
+        if (ds->getBindingType(drop.binding) == asset::IDescriptor::E_TYPE::ET_COUNT)
+            return false;
+    }
 
-        ds->dropDescriptors(drop, descriptorType);
+    for (const auto& drop : dropDescriptors)
+    {
+        auto ds = drop.dstSet;
+        ds->dropDescriptors(drop);
     }
 
-    nullifyDescriptors_impl(dropDescriptors, descriptorType);
+    nullifyDescriptors_impl(dropDescriptors);
     return true;
 }