add IGPUCommandBuffer::empty()

Author: devsh

examples_tests

@@ -78,6 +78,27 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
             return false;
         }
 
+        // This lets us know if not submitting this cmdbuf has no side-effects
+        // TODO: should we track the `bind` and `set{$DynamicState}` commands?
+        inline bool empty() const
+        {
+            switch (m_state)
+            {
+                case STATE::RECORDING:
+                    [[fallthrough]];
+                case STATE::EXECUTABLE:
+                    [[fallthrough]];
+                case STATE::PENDING:
+                    if (m_noCommands)
+                        return false;
+                    [[fallthrough]];
+                default:
+                    return true;
+            }
+        }
+        // if you use `getNativeHandle()` to record some custom commands between `begin()` and `end()`
+        inline void setNotEmtpy() {m_noCommands = true;}
+
         //! Begin, Reset, End
         enum class USAGE : uint8_t
         {
@@ -787,6 +808,7 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
 
         uint64_t m_resetCheckedStamp;
         STATE m_state = STATE::INITIAL;
+        bool m_noCommands = true;
         // only useful while recording
         SInheritanceInfo m_cachedInheritanceInfo;
         core::bitflag<USAGE> m_recordingFlags = USAGE::NONE;

include/nbl/video/IGPUCommandBuffer.h

@@ -149,6 +149,7 @@ bool IGPUCommandBuffer::begin(const core::bitflag<USAGE> flags, const SInheritan
     }
     else
         m_cachedInheritanceInfo = {};
+    m_noCommands = true;
     return begin_impl(flags,inheritanceInfo);
 }
 
@@ -239,6 +240,7 @@ bool IGPUCommandBuffer::setEvent(IEvent* _event, const SEventDependencyInfo& dep
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CSetEventCmd>(m_commandList, core::smart_refctd_ptr<const IEvent>(_event)))
         return false;
 
+    m_noCommands = false;
     return setEvent_impl(_event,depInfo);
 }
 
@@ -267,6 +269,7 @@ bool IGPUCommandBuffer::resetEvent(IEvent* _event, const core::bitflag<stage_fla
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CResetEventCmd>(m_commandList,core::smart_refctd_ptr<const IEvent>(_event)))
         return false;
 
+    m_noCommands = false;
     return resetEvent_impl(_event,stageMask);
 }
 
@@ -309,6 +312,7 @@ bool IGPUCommandBuffer::waitEvents(const std::span<IEvent*> events, const SEvent
         for (const auto& barrier : depInfo.imgBarriers)
             *(outIt++) = core::smart_refctd_ptr<const IGPUImage>(barrier.image);
     }
+    m_noCommands = false;
     return waitEvents_impl(events,depInfos);
 }
 
@@ -387,6 +391,7 @@ bool IGPUCommandBuffer::pipelineBarrier(const core::bitflag<asset::E_DEPENDENCY_
         *(outIt++) = barrier.range.buffer;
     for (const auto& barrier : depInfo.imgBarriers)
         *(outIt++) = core::smart_refctd_ptr<const IGPUImage>(barrier.image);
+    m_noCommands = false;
     return pipelineBarrier_impl(dependencyFlags,depInfo);
 }
 
@@ -404,6 +409,7 @@ bool IGPUCommandBuffer::fillBuffer(const asset::SBufferRange<IGPUBuffer>& range,
 
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CFillBufferCmd>(m_commandList,core::smart_refctd_ptr<const IGPUBuffer>(range.buffer)))
         return false;
+    m_noCommands = false;
     return fillBuffer_impl(range,data);
 }
 
@@ -425,6 +431,7 @@ bool IGPUCommandBuffer::updateBuffer(const asset::SBufferRange<IGPUBuffer>& rang
 
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CUpdateBufferCmd>(m_commandList,core::smart_refctd_ptr<const IGPUBuffer>(range.buffer)))
         return false;
+    m_noCommands = false;
     return updateBuffer_impl(range,pData);
 }
 
@@ -450,6 +457,7 @@ bool IGPUCommandBuffer::copyBuffer(const IGPUBuffer* const srcBuffer, IGPUBuffer
 
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyBufferCmd>(m_commandList,core::smart_refctd_ptr<const IGPUBuffer>(srcBuffer),core::smart_refctd_ptr<const IGPUBuffer>(dstBuffer)))
         return false;
+    m_noCommands = false;
     return copyBuffer_impl(srcBuffer, dstBuffer, regionCount, pRegions);
 }
 
@@ -467,6 +475,7 @@ bool IGPUCommandBuffer::clearColorImage(IGPUImage* const image, const IGPUImage:
 
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CClearColorImageCmd>(m_commandList,core::smart_refctd_ptr<const IGPUImage>(image)))
         return false;
+    m_noCommands = false;
     return clearColorImage_impl(image, imageLayout, pColor, rangeCount, pRanges);
 }
 
@@ -483,6 +492,7 @@ bool IGPUCommandBuffer::clearDepthStencilImage(IGPUImage* const image, const IGP
 
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CClearDepthStencilImageCmd>(m_commandList,core::smart_refctd_ptr<const IGPUImage>(image)))
         return false;
+    m_noCommands = false;
     return clearDepthStencilImage_impl(image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
@@ -503,6 +513,7 @@ bool IGPUCommandBuffer::copyBufferToImage(const IGPUBuffer* const srcBuffer, IGP
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyBufferToImageCmd>(m_commandList, core::smart_refctd_ptr<const IGPUBuffer>(srcBuffer), core::smart_refctd_ptr<const IGPUImage>(dstImage)))
         return false;
 
+    m_noCommands = false;
     return copyBufferToImage_impl(srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
@@ -523,6 +534,7 @@ bool IGPUCommandBuffer::copyImageToBuffer(const IGPUImage* const srcImage, const
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyImageToBufferCmd>(m_commandList, core::smart_refctd_ptr<const IGPUImage>(srcImage), core::smart_refctd_ptr<const IGPUBuffer>(dstBuffer)))
         return false;
 
+    m_noCommands = false;
     return copyImageToBuffer_impl(srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
@@ -552,6 +564,7 @@ bool IGPUCommandBuffer::copyImage(const IGPUImage* const srcImage, const IGPUIma
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyImageCmd>(m_commandList, core::smart_refctd_ptr<const IGPUImage>(srcImage), core::smart_refctd_ptr<const IGPUImage>(dstImage)))
         return false;
 
+    m_noCommands = false;
     return copyImage_impl(srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
@@ -629,6 +642,7 @@ bool IGPUCommandBuffer::copyAccelerationStructure(const IGPUAccelerationStructur
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyAccelerationStructureCmd>(m_commandList, core::smart_refctd_ptr<const IGPUAccelerationStructure>(copyInfo.src), core::smart_refctd_ptr<const IGPUAccelerationStructure>(copyInfo.dst)))
         return false;
 
+    m_noCommands = false;
     return copyAccelerationStructure_impl(copyInfo);
 }
 
@@ -645,6 +659,7 @@ bool IGPUCommandBuffer::copyAccelerationStructureToMemory(const IGPUAcceleration
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyAccelerationStructureToOrFromMemoryCmd>(m_commandList, core::smart_refctd_ptr<const IGPUAccelerationStructure>(copyInfo.src), core::smart_refctd_ptr<const IGPUBuffer>(copyInfo.dst.buffer)))
         return false;
 
+    m_noCommands = false;
     return copyAccelerationStructureToMemory_impl(copyInfo);
 }
 
@@ -661,6 +676,7 @@ bool IGPUCommandBuffer::copyAccelerationStructureFromMemory(const IGPUAccelerati
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyAccelerationStructureToOrFromMemoryCmd>(m_commandList, core::smart_refctd_ptr<const IGPUAccelerationStructure>(copyInfo.dst), core::smart_refctd_ptr<const IGPUBuffer>(copyInfo.src.buffer)))
         return false;
 
+    m_noCommands = false;
     return copyAccelerationStructureFromMemory_impl(copyInfo);
 }
 
@@ -676,6 +692,7 @@ bool IGPUCommandBuffer::bindComputePipeline(const IGPUComputePipeline* const pip
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBindComputePipelineCmd>(m_commandList, core::smart_refctd_ptr<const IGPUComputePipeline>(pipeline)))
         return false;
 
+    m_noCommands = false;
     bindComputePipeline_impl(pipeline);
 
     return true;
@@ -695,6 +712,7 @@ bool IGPUCommandBuffer::bindGraphicsPipeline(const IGPUGraphicsPipeline* const p
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBindGraphicsPipelineCmd>(m_commandList, core::smart_refctd_ptr<const IGPUGraphicsPipeline>(pipeline)))
         return false;
 
+    m_noCommands = false;
     return bindGraphicsPipeline_impl(pipeline);
 }
 
@@ -752,6 +770,7 @@ bool IGPUCommandBuffer::bindDescriptorSets(
             m_boundDescriptorSetsRecord.insert({ pDescriptorSets[i], currentVersion });
     }
 
+    m_noCommands = false;
     return bindDescriptorSets_impl(pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, dynamicOffsets);
 }
 
@@ -766,6 +785,7 @@ bool IGPUCommandBuffer::pushConstants(const IGPUPipelineLayout* const layout, co
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CPushConstantsCmd>(m_commandList, core::smart_refctd_ptr<const IGPUPipelineLayout>(layout)))
         return false;
 
+    m_noCommands = false;
     return pushConstants_impl(layout, stageFlags, offset, size, pValues);
 }
 
@@ -783,6 +803,7 @@ bool IGPUCommandBuffer::bindVertexBuffers(const uint32_t firstBinding, const uin
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBindVertexBuffersCmd>(m_commandList,bindingCount,pBindings))
         return false;
 
+    m_noCommands = false;
     return bindVertexBuffers_impl(firstBinding, bindingCount, pBindings);
 }
 
@@ -812,6 +833,7 @@ bool IGPUCommandBuffer::bindIndexBuffer(const asset::SBufferBinding<const IGPUBu
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBindIndexBufferCmd>(m_commandList, core::smart_refctd_ptr<const IGPUBuffer>(binding.buffer)))
         return false;
 
+    m_noCommands = false;
     return bindIndexBuffer_impl(binding,indexType);
 }
 
@@ -845,6 +867,7 @@ bool IGPUCommandBuffer::setLineWidth(const float width)
     else if (width!=1.f)
         return false;
 
+    m_noCommands = false;
     return setLineWidth_impl(width);
 }
 
@@ -859,6 +882,7 @@ bool IGPUCommandBuffer::setDepthBounds(const float minDepthBounds, const float m
     if (minDepthBounds<0.f || maxDepthBounds>1.f)
         return false;
 
+    m_noCommands = false;
     return setDepthBounds_impl(minDepthBounds,maxDepthBounds);
 }
 
@@ -875,6 +899,7 @@ bool IGPUCommandBuffer::resetQueryPool(IQueryPool* const queryPool, const uint32
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CResetQueryPoolCmd>(m_commandList, core::smart_refctd_ptr<const IQueryPool>(queryPool)))
         return false;
 
+    m_noCommands = false;
     return resetQueryPool_impl(queryPool, firstQuery, queryCount);
 }
 
@@ -890,6 +915,7 @@ bool IGPUCommandBuffer::beginQuery(IQueryPool* const queryPool, const uint32_t q
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBeginQueryCmd>(m_commandList, core::smart_refctd_ptr<const IQueryPool>(queryPool)))
         return false;
 
+    m_noCommands = false;
     return beginQuery_impl(queryPool, query, flags);
 }
 
@@ -905,6 +931,7 @@ bool IGPUCommandBuffer::endQuery(IQueryPool* const queryPool, const uint32_t que
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CEndQueryCmd>(m_commandList, core::smart_refctd_ptr<const IQueryPool>(queryPool)))
         return false;
 
+    m_noCommands = false;
     return endQuery_impl(queryPool, query);
 }
 
@@ -925,6 +952,7 @@ bool IGPUCommandBuffer::writeTimestamp(const stage_flags_t pipelineStage, IQuery
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CWriteTimestampCmd>(m_commandList, core::smart_refctd_ptr<const IQueryPool>(queryPool)))
         return false;
 
+    m_noCommands = false;
     return writeTimestamp_impl(pipelineStage, queryPool, query);
 }
 
@@ -947,6 +975,7 @@ bool IGPUCommandBuffer::writeAccelerationStructureProperties(const std::span<con
     auto oit = cmd->getVariableCountResources();
     for (auto& as : pAccelerationStructures)
         *(oit++) = core::smart_refctd_ptr<const core::IReferenceCounted>(as);
+    m_noCommands = false;
     return writeAccelerationStructureProperties_impl(pAccelerationStructures, queryType, queryPool, firstQuery);
 }
 
@@ -968,6 +997,7 @@ bool IGPUCommandBuffer::copyQueryPoolResults(
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CCopyQueryPoolResultsCmd>(m_commandList, core::smart_refctd_ptr<const IQueryPool>(queryPool), core::smart_refctd_ptr<const IGPUBuffer>(dstBuffer.buffer)))
         return false;
 
+    m_noCommands = false;
     return copyQueryPoolResults_impl(queryPool, firstQuery, queryCount, dstBuffer, stride, flags);
 }
 
@@ -984,6 +1014,7 @@ bool IGPUCommandBuffer::dispatch(const uint32_t groupCountX, const uint32_t grou
     if (groupCountX>limits.maxComputeWorkGroupCount[0] || groupCountY>limits.maxComputeWorkGroupCount[1] || groupCountZ>limits.maxComputeWorkGroupCount[2])
         return false;
 
+    m_noCommands = false;
     return dispatch_impl(groupCountX,groupCountY,groupCountZ);
 }
 
@@ -998,6 +1029,7 @@ bool IGPUCommandBuffer::dispatchIndirect(const asset::SBufferBinding<const IGPUB
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CIndirectCmd>(m_commandList,core::smart_refctd_ptr<const IGPUBuffer>(binding.buffer)))
         return false;
 
+    m_noCommands = false;
     return dispatchIndirect_impl(binding);
 }
 
@@ -1037,6 +1069,7 @@ bool IGPUCommandBuffer::beginRenderPass(SRenderpassBeginInfo info, const SUBPASS
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBeginRenderPassCmd>(m_commandList,core::smart_refctd_ptr<const IGPURenderpass>(info.renderpass),core::smart_refctd_ptr<const IGPUFramebuffer>(info.framebuffer)))
         return false;
 
+    m_noCommands = false;
     if (!beginRenderPass_impl(info,contents))
         return false;
     m_cachedInheritanceInfo.renderpass = info.renderpass;
@@ -1054,6 +1087,7 @@ bool IGPUCommandBuffer::nextSubpass(const SUBPASS_CONTENTS contents)
         return false;
 
     m_cachedInheritanceInfo.subpass++;
+    m_noCommands = false;
     return nextSubpass_impl(contents);
 }
 
@@ -1066,6 +1100,7 @@ bool IGPUCommandBuffer::endRenderPass()
         return false;
 
     m_cachedInheritanceInfo.subpass = SInheritanceInfo{}.subpass;
+    m_noCommands = false;
     return endRenderPass_impl();
 }
 
@@ -1109,6 +1144,7 @@ bool IGPUCommandBuffer::clearAttachments(const SClearAttachments& info)
             return false;
     }
 
+    m_noCommands = false;
     return clearAttachments_impl(info);
 }
 
@@ -1121,6 +1157,7 @@ bool IGPUCommandBuffer::draw(const uint32_t vertexCount, const uint32_t instance
     if (vertexCount==0u || instanceCount == 0u)
         return false;
 
+    m_noCommands = false;
     return draw_impl(vertexCount,instanceCount,firstVertex,firstInstance);
 }
 
@@ -1132,6 +1169,7 @@ bool IGPUCommandBuffer::drawIndexed(const uint32_t indexCount, const uint32_t in
     if (indexCount==0u || instanceCount == 0u)
         return false;
 
+    m_noCommands = false;
     return drawIndexed_impl(indexCount,instanceCount,firstIndex,vertexOffset,firstInstance);
 }
 
@@ -1181,6 +1219,7 @@ bool IGPUCommandBuffer::drawIndirect(const asset::SBufferBinding<const IGPUBuffe
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CIndirectCmd>(m_commandList,core::smart_refctd_ptr<const IGPUBuffer>(binding.buffer)))
         return false;
 
+    m_noCommands = false;
     return drawIndirect_impl(binding, drawCount, stride);
 }
 
@@ -1192,6 +1231,7 @@ bool IGPUCommandBuffer::drawIndexedIndirect(const asset::SBufferBinding<const IG
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CIndirectCmd>(m_commandList, core::smart_refctd_ptr<const IGPUBuffer>(binding.buffer)))
         return false;
 
+    m_noCommands = false;
     return drawIndexedIndirect_impl(binding, drawCount, stride);
 }
 
@@ -1203,6 +1243,7 @@ bool IGPUCommandBuffer::drawIndirectCount(const asset::SBufferBinding<const IGPU
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CDrawIndirectCountCmd>(m_commandList, core::smart_refctd_ptr<const IGPUBuffer>(indirectBinding.buffer), core::smart_refctd_ptr<const IGPUBuffer>(countBinding.buffer)))
         return false;
 
+    m_noCommands = false;
     return drawIndirectCount_impl(indirectBinding, countBinding, maxDrawCount, stride);
 }
 
@@ -1214,6 +1255,7 @@ bool IGPUCommandBuffer::drawIndexedIndirectCount(const asset::SBufferBinding<con
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CDrawIndirectCountCmd>(m_commandList, core::smart_refctd_ptr<const IGPUBuffer>(indirectBinding.buffer), core::smart_refctd_ptr<const IGPUBuffer>(countBinding.buffer)))
         return false;
 
+    m_noCommands = false;
     return drawIndexedIndirectCount_impl(indirectBinding, countBinding, maxDrawCount, stride);
 }
 
@@ -1307,6 +1349,7 @@ bool IGPUCommandBuffer::blitImage(const IGPUImage* const srcImage, const IGPUIma
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CBlitImageCmd>(m_commandList, core::smart_refctd_ptr<const IGPUImage>(srcImage), core::smart_refctd_ptr<const IGPUImage>(dstImage)))
         return false;
 
+    m_noCommands = false;
     return blitImage_impl(srcImage, srcImageLayout, dstImage, dstImageLayout, regions, filter);
 }
 
@@ -1340,6 +1383,7 @@ bool IGPUCommandBuffer::resolveImage(const IGPUImage* const srcImage, const IGPU
     if (!m_cmdpool->m_commandListPool.emplace<IGPUCommandPool::CResolveImageCmd>(m_commandList, core::smart_refctd_ptr<const IGPUImage>(srcImage), core::smart_refctd_ptr<const IGPUImage>(dstImage)))
         return false;
 
+    m_noCommands = false;
     return resolveImage_impl(srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
@@ -1362,6 +1406,7 @@ bool IGPUCommandBuffer::executeCommands(const uint32_t count, IGPUCommandBuffer*
         return false;
     for (auto i=0u; i<count; i++)
         cmd->getVariableCountResources()[i] = core::smart_refctd_ptr<const core::IReferenceCounted>(cmdbufs[i]);
+    m_noCommands = false;
     return executeCommands_impl(count,cmdbufs);
 }