Fix multi timeline functionality

Author: deprilula28

include/nbl/video/IGPUDescriptorSet.h

@@ -69,7 +69,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);
+        void dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop, const asset::IDescriptor::E_TYPE type);
 
         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.

include/nbl/video/alloc/SubAllocatedDescriptorSet.h

@@ -99,31 +99,34 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 	using EventHandler = MultiTimelineEventHandlerST<DeferredFreeFunctor>;
 protected:
 	struct SubAllocDescriptorSetRange {
-		EventHandler eventHandler = EventHandler({});
+		std::unique_ptr<EventHandler> eventHandler = nullptr;
 		std::unique_ptr<AddressAllocator> addressAllocator = nullptr;
 		std::unique_ptr<ReservedAllocator> reservedAllocator = nullptr;
 		size_t reservedSize = 0;
 		asset::IDescriptor::E_TYPE descriptorType = asset::IDescriptor::E_TYPE::ET_COUNT;
 
 		SubAllocDescriptorSetRange(
+			std::unique_ptr<EventHandler>&& inEventHandler,
 			std::unique_ptr<AddressAllocator>&& inAddressAllocator,
 			std::unique_ptr<ReservedAllocator>&& inReservedAllocator,
 			size_t inReservedSize,
 			asset::IDescriptor::E_TYPE inDescriptorType) :
-			eventHandler({}), addressAllocator(std::move(inAddressAllocator)),
+			eventHandler(std::move(inEventHandler)), addressAllocator(std::move(inAddressAllocator)),
 			reservedAllocator(std::move(inReservedAllocator)), 
 			reservedSize(inReservedSize),
 			descriptorType(inDescriptorType) {}
 		SubAllocDescriptorSetRange() {}
 
 		SubAllocDescriptorSetRange& operator=(SubAllocDescriptorSetRange&& other)
 		{
+			eventHandler = std::move(other.eventHandler);
 			addressAllocator = std::move(other.addressAllocator);
 			reservedAllocator = std::move(other.reservedAllocator);
 			reservedSize = other.reservedSize;
 			descriptorType = other.descriptorType;
 
 			// Nullify other
+			other.eventHandler = nullptr;
 			other.addressAllocator = nullptr;
 			other.reservedAllocator = nullptr;
 			other.reservedSize = 0u;
@@ -147,7 +150,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 
 	// constructors
 	inline SubAllocatedDescriptorSet(core::smart_refctd_ptr<video::IGPUDescriptorSet>&& descriptorSet,
-		core::smart_refctd_ptr<video::ILogicalDevice>&& logicalDevice) : m_logicalDevice(std::move(logicalDevice))
+		core::smart_refctd_ptr<video::ILogicalDevice>&& logicalDevice)
 	{
 		auto layout = descriptorSet->getLayout();
 		for (uint32_t descriptorType = 0; descriptorType < static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); descriptorType++)
@@ -175,12 +178,15 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 						static_cast<size_type>(0), 0u, MaxDescriptorSetAllocationAlignment, static_cast<size_type>(count),
 						MinDescriptorSetAllocationSize
 					));
+					auto eventHandler = std::unique_ptr<EventHandler>(new EventHandler(core::smart_refctd_ptr<ILogicalDevice>(logicalDevice)));
 
-					m_allocatableRanges[binding.data] = SubAllocDescriptorSetRange(std::move(addressAllocator), std::move(reservedAllocator), reservedSize, descType);
+					m_allocatableRanges[binding.data] = SubAllocDescriptorSetRange(std::move(eventHandler), std::move(addressAllocator), std::move(reservedAllocator), reservedSize, descType);
+					assert(m_allocatableRanges[binding.data].eventHandler->getLogicalDevice());
 				}
 			}
 		}
 		m_descriptorSet = std::move(descriptorSet);
+		m_logicalDevice = std::move(logicalDevice);
 	}
 
 	inline ~SubAllocatedDescriptorSet()
@@ -272,7 +278,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 			// FUTURE TODO: later we could only nullify the descriptors we don't end up reallocating if without robustness features
 			nulls.resize(m_totalDeferredFrees);
 			auto outNulls = nulls.data();
-			eventHandler.wait(maxWaitPoint, unallocatedSize, outNulls);
+			eventHandler->wait(maxWaitPoint, unallocatedSize, outNulls);
 			m_logicalDevice->nullifyDescriptors({ nulls.data(),outNulls }, range->second.descriptorType);
 
 			// always call with the same parameters, otherwise this turns into a mess with the non invalid_address gaps
@@ -299,17 +305,19 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 
 		auto allocator = getBindingAllocator(binding);
 		if (allocator)
-		for (size_type i=0; i<count; i++)
 		{
-			if (addr[i]==AddressAllocator::invalid_address)
-				continue;
-
-			allocator->free_addr(addr[i],1);
-			outNullify->dstSet = m_descriptorSet.get();
-			outNullify->binding = binding;
-			outNullify->arrayElement = i;
-			outNullify->count = 1;
-			outNullify++;
+			for (size_type i = 0; i < count; i++)
+			{
+				if (addr[i] == AddressAllocator::invalid_address)
+					continue;
+
+				allocator->free_addr(addr[i], 1);
+				outNullify->dstSet = m_descriptorSet.get();
+				outNullify->binding = binding;
+				outNullify->arrayElement = i;
+				outNullify->count = 1;
+				outNullify++;
+			}
 		}
 		return outNullify;
 	}
@@ -325,7 +333,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 		auto& eventHandler = range->second.eventHandler;
 		auto debugGuard = stAccessVerifyDebugGuard();
 		m_totalDeferredFrees += functor.getWorstCaseCount();
-		eventHandler.latch(futureWait,std::move(functor));
+		eventHandler->latch(futureWait,std::move(functor));
 	}
 
 	// defers based on the conservative estimation if `futureWait` needs to be waited on, if doesn't will call nullify descriiptors internally immediately
@@ -353,7 +361,7 @@ class SubAllocatedDescriptorSet : public core::IReferenceCounted
 		for (uint32_t i = 0; i < m_allocatableRanges.size(); i++)
 		{
 			auto& it = m_allocatableRanges[i];
-			frees += it.eventHandler.poll(outNulls).eventsLeft;
+			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);
 		}

src/nbl/video/IGPUDescriptorSet.cpp

@@ -124,27 +124,25 @@ void IGPUDescriptorSet::processWrite(const IGPUDescriptorSet::SWriteDescriptorSe
     incrementVersion();
 }
 
-void IGPUDescriptorSet::dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop)
+void IGPUDescriptorSet::dropDescriptors(const IGPUDescriptorSet::SDropDescriptorSet& drop, const asset::IDescriptor::E_TYPE type)
 {
     assert(drop.dstSet == this);
 
-    for (uint32_t t = 0; t < static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); ++t)
-    {
-        const auto type = static_cast<asset::IDescriptor::E_TYPE>(t);
+	auto* dstDescriptors = drop.dstSet->getDescriptors(type, drop.binding);
+	auto* dstSamplers = drop.dstSet->getMutableSamplers(drop.binding);
+	assert(dstDescriptors);
+    // Samplers are only used in the combined image sampler descriptors
+    if (type == asset::IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER)
+	    assert(dstSamplers); 
 
-        auto* dstDescriptors = drop.dstSet->getDescriptors(type, drop.binding);
-        auto* dstSamplers = drop.dstSet->getMutableSamplers(drop.binding);
-		assert(dstDescriptors);
-		assert(dstSamplers);
+	if (dstDescriptors)
+		for (uint32_t i = 0; i < drop.count; i++)
+			dstDescriptors[drop.arrayElement + i] = nullptr;
 
-        if (dstDescriptors)
-            for (uint32_t i = 0; i < drop.count; i++)
-                dstDescriptors[drop.arrayElement + i] = nullptr;
+	if (dstSamplers)
+		for (uint32_t i = 0; i < drop.count; i++)
+			dstSamplers[drop.arrayElement + i] = nullptr;
 
-        if (dstSamplers)
-            for (uint32_t i = 0; i < drop.count; i++)
-                dstSamplers[drop.arrayElement + i] = nullptr;
-    }
 	// we only increment the version to detect UPDATE-AFTER-BIND and automagically invalidate descriptor sets
 	// so, only if we do the path that writes descriptors, do we want to increment version
     if (getOriginDevice()->getEnabledFeatures().nullDescriptor)

src/nbl/video/ILogicalDevice.cpp

@@ -452,7 +452,7 @@ bool ILogicalDevice::nullifyDescriptors(const std::span<const IGPUDescriptorSet:
         if (!ds || !ds->wasCreatedBy(this))
             return false;
 
-        ds->dropDescriptors(drop);
+        ds->dropDescriptors(drop, descriptorType);
     }
 
     nullifyDescriptors_impl(dropDescriptors, descriptorType);