More cleanups.

Author: achalpandeyy

include/nbl/video/IGPUCommandBuffer.h

@@ -130,8 +130,6 @@ class NBL_API IGPUCommandBuffer :
 
     inline const core::unordered_map<const IGPUDescriptorSet*, uint64_t>& getBoundDescriptorSetsRecord() const { return m_boundDescriptorSetsRecord; }
 
-    inline void clearBoundDescriptorSetsRecord() { m_boundDescriptorSetsRecord.clear(); }
-
 protected: 
     friend class IGPUQueue;
 
@@ -247,7 +245,6 @@ class NBL_API IGPUCommandBuffer :
     virtual bool executeCommands_impl(uint32_t count, cmdbuf_t* const* const cmdbufs) = 0;
 
 private:
-    // Be wary of making it protected/calling it in the derived classes because it sets state which will overwrite the state set in base class methods.
     inline bool checkForParentPoolReset()
     {
         if (m_cmdpool->getResetCounter() <= m_resetCheckedStamp)
@@ -256,6 +253,8 @@ class NBL_API IGPUCommandBuffer :
         m_resetCheckedStamp = m_cmdpool->getResetCounter();
         m_state = ES_INITIAL;
 
+        m_boundDescriptorSetsRecord.clear();
+
         m_commandList.head = nullptr;
         m_commandList.tail = nullptr;
 
@@ -267,6 +266,7 @@ class NBL_API IGPUCommandBuffer :
     inline void releaseResourcesBackToPool()
     {
         deleteCommandList();
+        m_boundDescriptorSetsRecord.clear();
         releaseResourcesBackToPool_impl();
     }
 
@@ -277,6 +277,21 @@ class NBL_API IGPUCommandBuffer :
         m_commandList.tail = nullptr;
     }
 
+    inline bool checkStateBeforeRecording()
+    {
+        if (m_state != ES_RECORDING)
+        {
+            m_logger.log("Failed to record into command buffer: not in RECORDING state.", system::ILogger::ELL_ERROR);
+            return false;
+        }
+        if (checkForParentPoolReset())
+        {
+            m_logger.log("Failed to record into command buffer: pool was reset since the recording begin() call.", system::ILogger::ELL_ERROR);
+            return false;
+        }
+        return true;
+    }
+
     uint64_t m_resetCheckedStamp = 0;
 
     // This bound descriptor set record doesn't include the descriptor sets whose layout has _any_ one of its bindings

include/nbl/video/IGPUCommandPool.h

@@ -9,8 +9,6 @@
 #include "nbl/video/decl/IBackendObject.h"
 #include "nbl/video/IGPUPipelineLayout.h"
 
-#include "nbl/asset/ICPUCommandBuffer.h"
-
 namespace nbl::video
 {
 class IGPUCommandBuffer;
@@ -104,20 +102,25 @@ class NBL_API IGPUCommandPool : public core::IReferenceCounted, public IBackendO
     public:
         static inline constexpr uint32_t STORAGE_SIZE = COMMAND_SEGMENT_SIZE - core::roundUp(sizeof(header_t), alignof(ICommand));
 
-        CCommandSegment()
+        CCommandSegment(CCommandSegment* prev)
         {
             static_assert(alignof(ICommand) == COMMAND_SEGMENT_ALIGNMENT);
             m_header.commandAllocator = core::LinearAddressAllocator<uint32_t>(nullptr, 0u, 0u, alignof(ICommand), STORAGE_SIZE);
             m_header.next = nullptr;
 
             wipeNextCommandSize();
+
+            if (prev)
+                prev->m_header.next = this;
         }
 
         ~CCommandSegment()
         {
-            auto* cmd = reinterpret_cast<ICommand*>(m_data);
-            while ((cmd != segment_end()) || (cmd->getSize() != 0))
+            for (ICommand* cmd = begin(); cmd != end();)
             {
+                if (cmd->getSize() == 0)
+                    break;
+
                 auto* nextCmd = reinterpret_cast<ICommand*>(reinterpret_cast<uint8_t*>(cmd) + cmd->getSize());
                 cmd->~ICommand();
                 cmd = nextCmd;
@@ -142,7 +145,12 @@ class NBL_API IGPUCommandPool : public core::IReferenceCounted, public IBackendO
         inline CCommandSegment* getNextHead() const { return m_header.nextHead; }
         inline CCommandSegment* getPrevHead() const { return m_header.prevHead; }
 
-        inline ICommand* segment_end()
+        inline ICommand* begin()
+        {
+            return reinterpret_cast<ICommand*>(m_data);
+        }
+
+        inline ICommand* end()
         {
             return reinterpret_cast<ICommand*>(m_data + m_header.commandAllocator.get_allocated_size());
         }
@@ -255,6 +263,7 @@ class NBL_API IGPUCommandPool : public core::IReferenceCounted, public IBackendO
             if (!list.tail && !appendToList(list))
                 return nullptr;
 
+            // not forwarding twice because newCmd() will never be called the second time
             auto newCmd = [&]() -> Cmd*
             {
                 auto cmdMem = list.tail->allocate<Cmd>(args...);
@@ -290,12 +299,7 @@ class NBL_API IGPUCommandPool : public core::IReferenceCounted, public IBackendO
             if (head == m_head)
                 m_head = head->getNextHead();
 
-            auto oneBefore = head->getPrevHead();
-            auto oneAfter = head->getNextHead();
-            CCommandSegment::linkHeads(oneBefore, oneAfter);
-
-            if (!oneBefore && !oneAfter)
-                m_head = nullptr;
+            CCommandSegment::linkHeads(head->getPrevHead(), head->getNextHead());
 
             for (auto& segment = head; segment;)
             {
@@ -323,7 +327,7 @@ class NBL_API IGPUCommandPool : public core::IReferenceCounted, public IBackendO
     private:
         inline bool appendToList(SCommandSegmentList& list)
         {
-            auto segment = m_pool.emplace<CCommandSegment>();
+            auto segment = m_pool.emplace<CCommandSegment>(list.tail);
             if (!segment)
             {
                 assert(false);
@@ -427,19 +431,19 @@ class IGPUCommandPool::CBeginRenderPassCmd : public IGPUCommandPool::IFixedSizeC
 class IGPUCommandPool::CPipelineBarrierCmd : public IGPUCommandPool::ICommand
 {
 public:
-    CPipelineBarrierCmd(const uint32_t bufferCount, const asset::ICPUCommandBuffer::SBufferMemoryBarrier* bufferMemoryBarriers, const uint32_t imageCount, const asset::ICPUCommandBuffer::SImageMemoryBarrier* imageMemoryBarriers)
-        : ICommand(calc_size(bufferCount, bufferMemoryBarriers, imageCount, imageMemoryBarriers)), m_resourceCount(bufferCount+imageCount)
+    CPipelineBarrierCmd(const uint32_t bufferCount, const core::smart_refctd_ptr<const IGPUBuffer>* buffers, const uint32_t imageCount, const core::smart_refctd_ptr<const IGPUImage>* images)
+        : ICommand(calc_size(bufferCount, buffers, imageCount, images)), m_resourceCount(bufferCount + imageCount)
     {
         auto barrierResources = getBarrierResources();
         std::uninitialized_default_construct_n(barrierResources, m_resourceCount);
 
         uint32_t k = 0;
 
         for (auto i = 0; i < bufferCount; ++i)
-            barrierResources[k++] = bufferMemoryBarriers[i].buffer;
+            barrierResources[k++] = buffers[i];
 
         for (auto i = 0; i < imageCount; ++i)
-            barrierResources[k++] = imageMemoryBarriers[i].image;
+            barrierResources[k++] = images[i];
     }
 
     ~CPipelineBarrierCmd()
@@ -449,9 +453,9 @@ class IGPUCommandPool::CPipelineBarrierCmd : public IGPUCommandPool::ICommand
             barrierResources[i].~smart_refctd_ptr();
     }
 
-    static uint32_t calc_size(const uint32_t bufferCount, const asset::ICPUCommandBuffer::SBufferMemoryBarrier* bufferMemoryBarriers, const uint32_t imageCount, const asset::ICPUCommandBuffer::SImageMemoryBarrier* imageMemoryBarriers)
+    static uint32_t calc_size(const uint32_t bufferCount, const core::smart_refctd_ptr<const IGPUBuffer>* buffers, const uint32_t imageCount, const core::smart_refctd_ptr<const IGPUImage>* images)
     {
-        return core::alignUp(sizeof(CPipelineBarrierCmd) + (bufferCount+imageCount)*sizeof(core::smart_refctd_ptr<const core::IReferenceCounted>), alignof(CPipelineBarrierCmd));
+        return core::alignUp(sizeof(CPipelineBarrierCmd) + (bufferCount + imageCount) * sizeof(core::smart_refctd_ptr<const core::IReferenceCounted>), alignof(CPipelineBarrierCmd));
     }
 
 private:

include/nbl/video/IGPUQueue.h

@@ -106,19 +106,6 @@ class NBL_API IGPUQueue : public core::Interface, public core::Unmovable
             return true;
         }
 
-        inline void clearBoundDescriptorSetsRecord(uint32_t _count, const SSubmitInfo* _submits)
-        {
-            for (uint32_t i = 0u; i < _count; ++i)
-            {
-                for (uint32_t c = 0u; c < _submits[i].commandBufferCount; ++c)
-                {
-                    auto* cmdbuf = _submits[i].commandBuffers[c];
-                    if (cmdbuf)
-                        cmdbuf->clearBoundDescriptorSetsRecord();
-                }
-            }
-        }
-
         const uint32_t m_familyIndex;
         const E_CREATE_FLAGS m_flags;
         const float m_priority;

src/nbl/video/CVulkanQueue.cpp

@@ -108,8 +108,6 @@ bool CVulkanQueue::submit(uint32_t _count, const SSubmitInfo* _submits, IGPUFenc
         if(!IGPUQueue::markCommandBuffersAsDone(_count, _submits))
             return false;
 
-        IGPUQueue::clearBoundDescriptorSetsRecord(_count, _submits);
-
         return true;
     }