Modified barrier API to accept multiple resources per call (#1959)

Co-authored-by: Yong He <yonghe@outlook.com>

7 files changed, 132 insertions, 50 deletions

diff --git a/slang-gfx.h b/slang-gfx.h
index 1b587fd9f..d09c844a6 100644
--- a/slang-gfx.h
+++ b/slang-gfx.h
@@ -415,7 +415,7 @@ public:
 #define SLANG_UUID_ITextureResource                                                    \
     {                                                                                  \
         0xcf88a31c, 0x6187, 0x46c5, { 0xa4, 0xb7, 0xeb, 0x58, 0xc7, 0x33, 0x40, 0x17 } \
-    } 
+    }
 
 // Needed for building on cygwin with gcc
 #undef Always
@@ -1171,8 +1171,17 @@ public:
         size_t size) = 0;
     virtual SLANG_NO_THROW void SLANG_MCALL
         uploadBufferData(IBufferResource* dst, size_t offset, size_t size, void* data) = 0;
-    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst) = 0;
-    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst) = 0;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+        size_t count,
+        ITextureResource* const* textures,
+        ResourceState src,
+        ResourceState dst) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+        size_t count,
+        IBufferResource* const* buffers,
+        ResourceState src,
+        ResourceState dst) = 0;
 };
 
 enum class AccelerationStructureCopyMode
diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp
index 788baed0d..fccc1e3f0 100644
--- a/tools/gfx/cuda/render-cuda.cpp
+++ b/tools/gfx/cuda/render-cuda.cpp
@@ -995,12 +995,20 @@ public:
                 m_writer->copyBuffer(dst, dstOffset, src, srcOffset, size);
             }
 
-            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
+            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+                size_t count,
+                ITextureResource* const* textures,
+                ResourceState src,
+                ResourceState dst) override
             {
                 assert(!"Unimplemented");
             }
 
-            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
+            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+                size_t count,
+                IBufferResource* const* buffers,
+                ResourceState src,
+                ResourceState dst) override
             {
                 assert(!"Unimplemented");
             }
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index 4002450f3..28c00d08e 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -3441,11 +3441,19 @@ public:
                     size,
                     data);
             }
-            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst) override
+            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+                size_t count,
+                ITextureResource* const* textures,
+                ResourceState src,
+                ResourceState dst) override
             {
                 assert(!"Unimplemented");
             }
-            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst) override
+            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+                size_t count,
+                IBufferResource* const* buffers,
+                ResourceState src,
+                ResourceState dst) override
             {
                 assert(!"Unimplemented");
             }
diff --git a/tools/gfx/debug-layer.cpp b/tools/gfx/debug-layer.cpp
index 869a93411..bab564f14 100644
--- a/tools/gfx/debug-layer.cpp
+++ b/tools/gfx/debug-layer.cpp
@@ -1007,18 +1007,36 @@ void DebugResourceCommandEncoder::uploadBufferData(
     baseObject->uploadBufferData(dstImpl->baseObject, offset, size, data);
 }
 
-void DebugResourceCommandEncoder::textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
+void DebugResourceCommandEncoder::textureBarrier(
+    size_t count,
+    ITextureResource* const* textures,
+    ResourceState src,
+    ResourceState dst)
 {
     SLANG_GFX_API_FUNC;
-    auto textureImpl = static_cast<DebugTextureResource*>(texture);
-    baseObject->textureBarrier(textureImpl->baseObject, src, dst);
+
+    List<ITextureResource*> innerTextures;
+    for (size_t i = 0; i < count; i++)
+    {
+        innerTextures.add(static_cast<DebugTextureResource*>(textures[i])->baseObject.get());
+    }
+    baseObject->textureBarrier(count, innerTextures.getBuffer(), src, dst);
 }
 
-void DebugResourceCommandEncoder::bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
+void DebugResourceCommandEncoder::bufferBarrier(
+    size_t count,
+    IBufferResource* const* buffers,
+    ResourceState src,
+    ResourceState dst)
 {
     SLANG_GFX_API_FUNC;
-    auto bufferImpl = static_cast<DebugBufferResource*>(buffer);
-    baseObject->bufferBarrier(bufferImpl->baseObject, src, dst);
+
+    List<IBufferResource*> innerBuffers;
+    for(size_t i = 0; i < count; i++)
+    {
+        innerBuffers.add(static_cast<DebugBufferResource*>(buffers[i])->baseObject.get());
+    }
+    baseObject->bufferBarrier(count, innerBuffers.getBuffer(), src, dst);
 }
 
 void DebugRayTracingCommandEncoder::endEncoding()
diff --git a/tools/gfx/debug-layer.h b/tools/gfx/debug-layer.h
index 2f0bc76ce..d25fbd453 100644
--- a/tools/gfx/debug-layer.h
+++ b/tools/gfx/debug-layer.h
@@ -319,8 +319,16 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL
         uploadBufferData(IBufferResource* dst, size_t offset, size_t size, void* data) override;
     virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, SlangInt index) override;
-    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst) override;
-    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+        size_t count,
+        ITextureResource* const* textures,
+        ResourceState src,
+        ResourceState dst) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+        size_t count,
+        IBufferResource* const* buffers,
+        ResourceState src,
+        ResourceState dst) override;
 public:
     DebugCommandBuffer* commandBuffer;
     bool isOpen = false;
diff --git a/tools/gfx/immediate-renderer-base.cpp b/tools/gfx/immediate-renderer-base.cpp
index e87c1e558..eb5450746 100644
--- a/tools/gfx/immediate-renderer-base.cpp
+++ b/tools/gfx/immediate-renderer-base.cpp
@@ -249,12 +249,20 @@ public:
             m_writer->writeTimestamp(pool, index);
         }
 
-        virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
+        virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+            size_t count,
+            ITextureResource* const* textures,
+            ResourceState src,
+            ResourceState dst) override
         {
             assert(!"Unimplemented");
         }
 
-        virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
+        virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+            size_t count,
+            IBufferResource* const* buffers,
+            ResourceState src,
+            ResourceState dst) override
         {
             assert(!"Unimplemented");
         }
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index d2cbd6790..9eb0b71a1 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -4108,47 +4108,70 @@ public:
                     size,
                     data);
             }
-            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
-            {
-                auto image = static_cast<TextureResourceImpl*>(texture);
-                auto desc = image->getDesc();
-
-                VkImageMemoryBarrier barrier = {};
-                barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-                barrier.image = image->m_image;
-                barrier.oldLayout = translateImageLayout(src);
-                barrier.newLayout = translateImageLayout(dst);
-                barrier.subresourceRange.aspectMask;
-                barrier.subresourceRange.baseArrayLayer = 0;
-                barrier.subresourceRange.baseMipLevel = 0;
-                barrier.subresourceRange.layerCount = desc->arraySize;
-                barrier.subresourceRange.levelCount = desc->numMipLevels;
-                barrier.srcAccessMask = calcAccessFlags(src);
-                barrier.dstAccessMask = calcAccessFlags(dst);
-
-               VkPipelineStageFlagBits srcStage = calcPipelineStageFlags(src, true);
-               VkPipelineStageFlagBits dstStage = calcPipelineStageFlags(dst, false);
+            virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+                size_t count,
+                ITextureResource* const* textures,
+                ResourceState src,
+                ResourceState dst)
+            {
+                List<VkImageMemoryBarrier> barriers;
+                barriers.setCount(count);
+
+                for (size_t i = 0; i < count; i++)
+                {
+                    auto image = static_cast<TextureResourceImpl*>(textures[i]);
+                    auto desc = image->getDesc();
+
+                    VkImageMemoryBarrier barrier = {};
+                    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+                    barrier.image = image->m_image;
+                    barrier.oldLayout = translateImageLayout(src);
+                    barrier.newLayout = translateImageLayout(dst);
+                    barrier.subresourceRange.aspectMask;
+                    barrier.subresourceRange.baseArrayLayer = 0;
+                    barrier.subresourceRange.baseMipLevel = 0;
+                    barrier.subresourceRange.layerCount = desc->arraySize;
+                    barrier.subresourceRange.levelCount = desc->numMipLevels;
+                    barrier.srcAccessMask = calcAccessFlags(src);
+                    barrier.dstAccessMask = calcAccessFlags(dst);
+                    barriers.add(barrier);
+                }
+
+                VkPipelineStageFlagBits srcStage = calcPipelineStageFlags(src, true);
+                VkPipelineStageFlagBits dstStage = calcPipelineStageFlags(dst, false);
 
                 auto& vkApi = m_commandBuffer->m_renderer->m_api;
-                vkApi.vkCmdPipelineBarrier(m_commandBuffer->m_commandBuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+                vkApi.vkCmdPipelineBarrier(m_commandBuffer->m_commandBuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, count, barriers.getBuffer());
             }
-            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
+            virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+                size_t count,
+                IBufferResource* const* buffers,
+                ResourceState src,
+                ResourceState dst)
             {
-                auto bufferImpl = static_cast<BufferResourceImpl*>(buffer);
+                List<VkBufferMemoryBarrier> barriers;
+                barriers.setCount(count);
+
+                for (size_t i = 0; i < count; i++)
+                {
+                    auto bufferImpl = static_cast<BufferResourceImpl*>(buffers[i]);
 
-                VkBufferMemoryBarrier barrier = {};
-                barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
-                barrier.srcAccessMask = calcAccessFlags(src);
-                barrier.dstAccessMask = calcAccessFlags(dst);
-                barrier.buffer = bufferImpl->m_buffer.m_buffer;
-                barrier.offset = 0;
-                barrier.size = buffer->getDesc()->sizeInBytes;
+                    VkBufferMemoryBarrier barrier = {};
+                    barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+                    barrier.srcAccessMask = calcAccessFlags(src);
+                    barrier.dstAccessMask = calcAccessFlags(dst);
+                    barrier.buffer = bufferImpl->m_buffer.m_buffer;
+                    barrier.offset = 0;
+                    barrier.size = bufferImpl->getDesc()->sizeInBytes;
+
+                    barriers.add(barrier);
+                }
 
-               VkPipelineStageFlagBits srcStage = calcPipelineStageFlags(src, true);
-               VkPipelineStageFlagBits dstStage = calcPipelineStageFlags(dst, false);
+                VkPipelineStageFlagBits srcStage = calcPipelineStageFlags(src, true);
+                VkPipelineStageFlagBits dstStage = calcPipelineStageFlags(dst, false);
 
                 auto& vkApi = m_commandBuffer->m_renderer->m_api;
-                vkApi.vkCmdPipelineBarrier(m_commandBuffer->m_commandBuffer, srcStage, dstStage, 0, 0, nullptr, 1, &barrier, 0, nullptr);
+                vkApi.vkCmdPipelineBarrier(m_commandBuffer->m_commandBuffer, srcStage, dstStage, 0, 0, nullptr, count, barriers.getBuffer(), 0, nullptr);
             }
             virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override
             {