Make ILogicalDevice::blockForSemaphores also purge the queue drop lists

Author: devshgraphicsprogramming

include/nbl/video/CThreadSafeQueueAdapter.h

@@ -59,10 +59,10 @@ class CThreadSafeQueueAdapter final : public IQueue
             return originalQueue->waitIdle();
         }
 
-        inline uint32_t cullResources() override
+        inline uint32_t cullResources(const ISemaphore* sema=nullptr) override
         {
             std::lock_guard g(m);
-            return originalQueue->cullResources();
+            return originalQueue->cullResources(sema);
         }
 
         inline IQueue* getUnderlyingQueue() const

include/nbl/video/ILogicalDevice.h

@@ -157,16 +157,26 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
 
         //! Semaphore Stuff
         virtual core::smart_refctd_ptr<ISemaphore> createSemaphore(const uint64_t initialValue) = 0;
+        // Waits for max timeout amout of time for the semaphores to reach a specific counter value
+        // DOES NOT implicitly trigger Queue-refcount-resource release because of two reasons:
+        // - the events may trigger loads of resource releases causing extra processing, whereas our `timeout` could be quite small
+        // - the event handlers use `waitForSemaphores` themselves so don't want infinite recursion here
         virtual ISemaphore::WAIT_RESULT waitForSemaphores(const std::span<const ISemaphore::SWaitInfo> infos, const bool waitAll, const uint64_t timeout) = 0;
         // Forever waiting variant if you're confident that the fence will eventually be signalled
+        // Does implicitly trigger Queue-refcount-resource-release
         inline ISemaphore::WAIT_RESULT blockForSemaphores(const std::span<const ISemaphore::SWaitInfo> infos, const bool waitAll=true)
         {
             using retval_t = ISemaphore::WAIT_RESULT;
             if (!infos.empty())
             {
                 auto waitStatus = retval_t::TIMEOUT;
-                while (waitStatus== retval_t::TIMEOUT)
+                while (waitStatus==retval_t::TIMEOUT)
+                {
                     waitStatus = waitForSemaphores(infos,waitAll,999999999ull);
+                    for (const auto& info : infos)
+                    for (const auto& queue : *m_queues)
+                        queue->cullResources(info.semaphore);
+                }
                 return waitStatus;
             }
             return retval_t::SUCCESS;

include/nbl/video/IQueue.h

@@ -108,7 +108,8 @@ class IQueue : public core::Interface, public core::Unmovable
         NBL_API2 virtual RESULT waitIdle();
         // You can call this to force an early check on whether past submits have completed and hasten when the refcount gets dropped.
         // Normally its the next call to `submit` that polls the event timeline for completions.
-        NBL_API2 virtual uint32_t cullResources();
+        // If you want to only check a particular semaphore's timeline, then set `sema` to non nullptr.
+        NBL_API2 virtual uint32_t cullResources(const ISemaphore* sema=nullptr);
 
         // we cannot derive from IBackendObject because we can't derive from IReferenceCounted
         inline const ILogicalDevice* getOriginDevice() const {return m_originDevice;}

src/nbl/video/IQueue.cpp

@@ -110,8 +110,16 @@ auto IQueue::waitIdle() -> RESULT
     return retval;
 }
 
-uint32_t IQueue::cullResources()
+uint32_t IQueue::cullResources(const ISemaphore* sema)
 {
+    if (sema)
+    {
+        const auto& timelines = m_submittedResources->getTimelines();
+        auto found = timelines.find(sema);
+        if (found==timelines.end())
+            return 0;
+        return found->handler->poll().eventsLeft;
+    }
     return m_submittedResources->poll().eventsLeft;
 }