fix a smal bug and introduce a base class for TimelineEventHandler, also get everything to compile

Author: devshgraphicsprogramming

include/nbl/video/TimelineEventHandlers.h

@@ -9,28 +9,48 @@
 
 namespace nbl::video
 {
+class TimelineEventHandlerBase : core::Unmovable, core::Uncopyable
+{
+    public:
+        struct PollResult
+        {
+            uint32_t eventsLeft = ~0u;
+            bool bailed = false;
+        };
+
+        // little utility
+        inline const ISemaphore* getSemaphore() const { return m_sema.get(); }
+        
+        // todo: rename to default_wait_point ?
+        template<class Clock=std::chrono::steady_clock>
+        static inline Clock::time_point default_wait()
+        {
+            return Clock::now()+std::chrono::microseconds(50);
+        }
+
+    protected:
+        TimelineEventHandlerBase(core::smart_refctd_ptr<const ISemaphore>&& sema) : m_sema(std::move(sema)) {}
+
+        core::smart_refctd_ptr<const ISemaphore> m_sema;
+};
+
 template<typename Functor>
 class MultiTimelineEventHandlerST;
 
 // Could be made MT and relatively lockless, if only had a good lock-few circular buffer impl
 // Not sure its worth the effort as anything using this will probably need to be lockful to be MT
 template<typename Functor>
-class TimelineEventHandlerST final : core::Unmovable, core::Uncopyable
+class TimelineEventHandlerST final : TimelineEventHandlerBase
 {
     public:
         // Theoretically could make a factory function cause passing a null semaphore is invalid, but counting on users to be relatively intelligent.
         inline TimelineEventHandlerST(core::smart_refctd_ptr<const ISemaphore>&& sema, const uint64_t initialCapacity=4095/sizeof(FunctorValuePair)+1) :
-            m_sema(std::move(sema)), m_greatestLatch(0)
-        {
-            m_greatestSignal = m_sema->getCounterValue();
-        }
+            TimelineEventHandlerBase(std::move(sema)), m_greatestLatch(0), m_greatestSignal(m_sema->getCounterValue()) {}
         // If you don't want to deadlock here, look into the `abort*` family of methods
         ~TimelineEventHandlerST()
         {
             while (wait(std::chrono::steady_clock::now()+std::chrono::seconds(5))) {}
         }
-        // little utility
-        inline const ISemaphore* getSemaphore() const {return m_sema.get();}
 
         inline uint32_t count() const {return m_cb.size();}
 
@@ -44,23 +64,12 @@ class TimelineEventHandlerST final : core::Unmovable, core::Uncopyable
         }
 
         //
-        struct PollResult
-        {
-            uint32_t eventsLeft = ~0u;
-            bool bailed = false;
-        };
         template<typename... Args>
         inline PollResult poll(Args&&... args)
         {
             return poll_impl<true>(std::forward<Args>(args)...);
         }
 
-        template<class Clock=std::chrono::steady_clock>
-        static inline Clock::time_point default_wait()
-        {
-            return Clock::now()+std::chrono::microseconds(50);
-        }
-
         template<class Clock, class Duration=typename Clock::duration, typename... Args>
         inline uint32_t wait(const std::chrono::time_point<Clock,Duration>& timeout_time, Args&&... args)
         {
@@ -160,7 +169,6 @@ class TimelineEventHandlerST final : core::Unmovable, core::Uncopyable
         };
         // could be a circular buffer but whatever for now
         core::deque<FunctorValuePair> m_cb;
-        core::smart_refctd_ptr<const ISemaphore> m_sema;
         uint64_t m_greatestSignal;
         uint64_t m_greatestLatch;
 
@@ -410,7 +418,7 @@ class MultiTimelineEventHandlerST final : core::Unmovable, core::Uncopyable
         inline container_t::iterator eraseTimeline(typename container_t::iterator timeline)
         {
             // if not the last in scratch
-            if (timeline->waitInfoIx<m_scratchWaitInfos.size())
+            if (timeline->waitInfoIx+1<m_scratchWaitInfos.size())
             {
                 // swap the mapping with the end scratch element
                 const auto& lastScratch = m_scratchWaitInfos.back();

include/nbl/video/alloc/CAsyncSingleBufferSubAllocator.h

@@ -117,7 +117,8 @@ class CAsyncSingleBufferSubAllocator
 
         // perfect forward ctor to `CSingleBufferSubAllocator`
         template<typename... Args>
-        inline CAsyncSingleBufferSubAllocator(Args&&... args) : m_composed(std::forward<Args>(args)...) {}
+        inline CAsyncSingleBufferSubAllocator(Args&&... args) : m_composed(std::forward<Args>(args)...),
+            deferredFrees(core::smart_refctd_ptr<ILogicalDevice>(const_cast<ILogicalDevice*>(m_composed.getBuffer()->getOriginDevice()))) {}
         virtual ~CAsyncSingleBufferSubAllocator() {}
 
 
@@ -135,7 +136,7 @@ class CAsyncSingleBufferSubAllocator
             std::unique_lock<std::recursive_mutex> tLock(stAccessVerfier,std::try_to_lock_t());
             assert(tLock.owns_lock());
             #endif // _NBL_DEBUG
-            return deferredFrees.poll();
+            return deferredFrees.poll().eventsLeft;
         }
 
         //! Returns max possible currently allocatable single allocation size, without having to wait for GPU more
@@ -200,7 +201,7 @@ class CAsyncSingleBufferSubAllocator
             std::unique_lock<std::recursive_mutex> tLock(stAccessVerfier,std::try_to_lock_t());
             assert(tLock.owns_lock());
             #endif // _NBL_DEBUG
-            multi_deallocate(count,addr,bytes,nullptr);
+            multi_deallocate(count,addr,bytes,{});
         }
         // TODO: improve signature of this function in the future
         template<typename T=core::IReferenceCounted>

include/nbl/video/alloc/StreamingTransientDataBuffer.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
+// Copyright (C) 2018-2024 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
 #ifndef _NBL_VIDEO_STREAMING_TRANSIENT_DATA_BUFFER_H_
@@ -15,7 +15,6 @@
 namespace nbl::video
 {
 
-#if 0 // TODO: port
 template<class HostAllocator=core::allocator<uint8_t>, class RecursiveLockable=std::recursive_mutex>
 class StreamingTransientDataBufferMT;
 
@@ -39,24 +38,28 @@ class StreamingTransientDataBuffer
         template<typename... Args>
         inline StreamingTransientDataBuffer(asset::SBufferRange<IGPUBuffer>&& _bufferRange, Args&&... args) : m_composed(std::move(_bufferRange),std::forward<Args>(args)...)
         {
-            assert(getBuffer()->getBoundMemory()->isMappable());
-            assert(getBuffer()->getBoundMemory()->getMappedPointer());
+            assert(getBuffer()->getBoundMemory().memory->isMappable());
+            assert(getBuffer()->getBoundMemory().memory->getMappedPointer());
             // we're suballocating from a buffer, whole buffer needs to be reachable from the mapped pointer
-            const auto mappedRange = getBuffer()->getBoundMemory()->getMappedRange();
-            assert(mappedRange.offset<=getBuffer()->getBoundMemoryOffset());
-            assert(mappedRange.offset+mappedRange.length>=getBuffer()->getBoundMemoryOffset()+getBuffer()->getSize());
+            const auto mappedRange = getBuffer()->getBoundMemory().memory->getMappedRange();
+            assert(mappedRange.offset<=getBuffer()->getBoundMemory().offset);
+            assert(mappedRange.offset+mappedRange.length>=getBuffer()->getBoundMemory().offset+getBuffer()->getSize());
         }
         virtual ~StreamingTransientDataBuffer() {}
 
         //
-        inline bool needsManualFlushOrInvalidate() const {return getBuffer()->getBoundMemory()->haveToMakeVisible();}
+        inline bool needsManualFlushOrInvalidate() const {return getBuffer()->getBoundMemory().memory->haveToMakeVisible();}
 
         // getters
         inline IGPUBuffer* getBuffer() noexcept {return m_composed.getBuffer();}
         inline const IGPUBuffer* getBuffer() const noexcept {return m_composed.getBuffer();}
 
         //
-        inline void* getBufferPointer() noexcept {return getBuffer()->getBoundMemory()->getMappedPointer();}
+        inline void* getBufferPointer() noexcept
+        {
+            const auto bound = getBuffer()->getBoundMemory();
+            return reinterpret_cast<uint8_t*>(bound.memory->getMappedPointer())+bound.offset;
+        }
 
         //
         inline uint32_t cull_frees() noexcept {return m_composed.cull_frees();}
@@ -99,7 +102,7 @@ class StreamingTransientDataBuffer
         template<typename... Args>
         inline size_type multi_place(uint32_t count, Args&&... args) noexcept
         {
-            return multi_place(GPUEventWrapper::default_wait(), count, std::forward<Args>(args)...);
+            return multi_place(TimelineEventHandlerBase::default_wait(),count,std::forward<Args>(args)...);
         }
 };
 }
@@ -206,7 +209,6 @@ class StreamingTransientDataBufferMT : public core::IReferenceCounted
             return lock;
         }
 };
-#endif
 
 }