Refactor PipelineStateVkImpl::ShaderStageInfo

Use internal struct Item to keep stage element data

Author: TheMostDiligent

Graphics/Archiver/src/Archiver_Vk.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -128,9 +128,8 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf
     {
         ShaderStageInfoVk&                    Src{ShaderStages[i]};
         PipelineStateVkImpl::ShaderStageInfo& Dst{ShaderStagesVk[i]};
-        Dst.Type    = Src.Type;
-        Dst.Shaders = std::move(Src.Shaders);
-        Dst.SPIRVs  = std::move(Src.SPIRVs);
+        Dst.Type  = Src.Type;
+        Dst.Items = std::move(Src.Items);
     }
 
     IPipelineResourceSignature** ppSignatures    = CreateInfo.ppResourceSignatures;
@@ -189,7 +188,7 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf
         const PipelineStateVkImpl::ShaderStageInfo& Stage = ShaderStagesVk[j];
         for (size_t i = 0; i < Stage.Count(); ++i)
         {
-            const std::vector<Uint32>& SPIRV    = Stage.SPIRVs[i];
+            const std::vector<Uint32>& SPIRV    = Stage.Items[i].SPIRV;
             ShaderCreateInfo           ShaderCI = ShaderStages[j].Serialized[i]->GetCreateInfo();
 
             ShaderCI.Source       = nullptr;

Graphics/GraphicsEngineVulkan/include/PipelineStateVkImpl.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -73,6 +73,7 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
 
     const PipelineLayoutVk& GetPipelineLayout() const { return m_PipelineLayout; }
 
+    using ShaderResourcesSharedPtr = std::shared_ptr<const SPIRVShaderResources>;
     struct ShaderStageInfo
     {
         ShaderStageInfo() {}
@@ -84,8 +85,14 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
         // Shader stage type. All shaders in the stage must have the same type.
         SHADER_TYPE Type = SHADER_TYPE_UNKNOWN;
 
-        std::vector<const ShaderVkImpl*>   Shaders;
-        std::vector<std::vector<uint32_t>> SPIRVs;
+        struct Item
+        {
+            const ShaderVkImpl*   pShader = nullptr;
+            std::vector<uint32_t> SPIRV;
+
+            explicit Item(const ShaderVkImpl* _pShader);
+        };
+        std::vector<Item> Items;
 
         friend SHADER_TYPE GetShaderStageType(const ShaderStageInfo& Stage) { return Stage.Type; }
     };

Graphics/GraphicsEngineVulkan/include/ShaderVkImpl.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -90,7 +90,8 @@ class ShaderVkImpl final : public ShaderBase<EngineVkImplTraits>
         return !IsCompiling() ? m_SPIRV : NullSPIRV;
     }
 
-    const std::shared_ptr<const SPIRVShaderResources>& GetShaderResources() const
+    using ShaderResourcesSharedPtr = std::shared_ptr<const SPIRVShaderResources>;
+    const ShaderResourcesSharedPtr& GetShaderResources() const
     {
         DEV_CHECK_ERR(!IsCompiling(), "Shader resources are not available until the shader is compiled. Use GetStatus() to check the shader status.");
         return m_pShaderResources;
@@ -115,7 +116,7 @@ class ShaderVkImpl final : public ShaderBase<EngineVkImplTraits>
                     const CreateInfo&       VkShaderCI) noexcept(false);
 
 private:
-    std::shared_ptr<const SPIRVShaderResources> m_pShaderResources;
+    ShaderResourcesSharedPtr m_pShaderResources;
 
     std::string           m_EntryPoint;
     std::vector<uint32_t> m_SPIRV;

Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp

@@ -56,33 +56,27 @@ namespace
 {
 
 void InitPipelineShaderStages(const VulkanUtilities::LogicalDevice&              LogicalDevice,
-                              PipelineStateVkImpl::TShaderStages&                ShaderStages,
+                              const PipelineStateVkImpl::TShaderStages&          ShaderStages,
                               std::vector<VulkanUtilities::ShaderModuleWrapper>& ShaderModules,
                               std::vector<VkPipelineShaderStageCreateInfo>&      Stages)
 {
-    for (size_t s = 0; s < ShaderStages.size(); ++s)
+    for (const PipelineStateVkImpl::ShaderStageInfo& Stage : ShaderStages)
     {
-        const std::vector<const ShaderVkImpl*>& Shaders    = ShaderStages[s].Shaders;
-        std::vector<std::vector<uint32_t>>&     SPIRVs     = ShaderStages[s].SPIRVs;
-        const SHADER_TYPE                       ShaderType = ShaderStages[s].Type;
-
-        VERIFY_EXPR(Shaders.size() == SPIRVs.size());
-
         VkPipelineShaderStageCreateInfo StageCI{};
         StageCI.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
         StageCI.pNext = nullptr;
         StageCI.flags = 0; //  reserved for future use
-        StageCI.stage = ShaderTypeToVkShaderStageFlagBit(ShaderType);
+        StageCI.stage = ShaderTypeToVkShaderStageFlagBit(Stage.Type);
 
         VkShaderModuleCreateInfo ShaderModuleCI{};
         ShaderModuleCI.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
         ShaderModuleCI.pNext = nullptr;
         ShaderModuleCI.flags = 0;
 
-        for (size_t i = 0; i < Shaders.size(); ++i)
+        for (const PipelineStateVkImpl::ShaderStageInfo::Item& StageItem : Stage.Items)
         {
-            const ShaderVkImpl*         pShader = Shaders[i];
-            const std::vector<uint32_t> SPIRV   = SPIRVs[i];
+            const ShaderVkImpl*          pShader = StageItem.pShader;
+            const std::vector<uint32_t>& SPIRV   = StageItem.SPIRV;
 
             ShaderModuleCI.codeSize = SPIRV.size() * sizeof(uint32_t);
             ShaderModuleCI.pCode    = SPIRV.data();
@@ -415,9 +409,9 @@ std::vector<VkRayTracingShaderGroupCreateInfoKHR> BuildRTShaderGroupDescription(
         {
             if (ShaderType == Stage.Type)
             {
-                for (Uint32 i = 0; i < Stage.Shaders.size(); ++i, ++idx)
+                for (Uint32 i = 0; i < Stage.Items.size(); ++i, ++idx)
                 {
-                    if (Stage.Shaders[i] == pShaderVk)
+                    if (Stage.Items[i].pShader == pShaderVk)
                         return idx;
                 }
                 UNEXPECTED("Unable to find shader '", pShaderVk->GetDesc().Name, "' in the shader stage. This should never happen and is a bug.");
@@ -554,22 +548,27 @@ void VerifyResourceMerge(const char*                       PSOName,
 } // namespace
 
 
+PipelineStateVkImpl::ShaderStageInfo::Item::Item(const ShaderVkImpl* _pShader) :
+    pShader{_pShader},
+    SPIRV{_pShader->GetSPIRV()}
+{
+}
+
 PipelineStateVkImpl::ShaderStageInfo::ShaderStageInfo(const ShaderVkImpl* pShader) :
     Type{pShader->GetDesc().ShaderType},
-    Shaders{pShader},
-    SPIRVs{pShader->GetSPIRV()}
+    Items{Item{pShader}}
 {}
 
 void PipelineStateVkImpl::ShaderStageInfo::Append(const ShaderVkImpl* pShader)
 {
     VERIFY_EXPR(pShader != nullptr);
-    VERIFY(std::find(Shaders.begin(), Shaders.end(), pShader) == Shaders.end(),
+    VERIFY(std::find_if(Items.begin(), Items.end(), [pShader](const Item& I) { return I.pShader == pShader; }) == Items.end(),
            "Shader '", pShader->GetDesc().Name, "' already exists in the stage. Shaders must be deduplicated.");
 
     const SHADER_TYPE NewShaderType = pShader->GetDesc().ShaderType;
     if (Type == SHADER_TYPE_UNKNOWN)
     {
-        VERIFY_EXPR(Shaders.empty() && SPIRVs.empty());
+        VERIFY_EXPR(Items.empty());
         Type = NewShaderType;
     }
     else
@@ -578,14 +577,12 @@ void PipelineStateVkImpl::ShaderStageInfo::Append(const ShaderVkImpl* pShader)
                ") of shader '", pShader->GetDesc().Name, "' being added to the stage is inconsistent with the stage type (",
                GetShaderTypeLiteralName(Type), ").");
     }
-    Shaders.push_back(pShader);
-    SPIRVs.push_back(pShader->GetSPIRV());
+    Items.emplace_back(pShader);
 }
 
 size_t PipelineStateVkImpl::ShaderStageInfo::Count() const
 {
-    VERIFY_EXPR(Shaders.size() == SPIRVs.size());
-    return Shaders.size();
+    return Items.size();
 }
 
 PipelineResourceSignatureDescWrapper PipelineStateVkImpl::GetDefaultResourceSignatureDesc(
@@ -599,9 +596,9 @@ PipelineResourceSignatureDescWrapper PipelineStateVkImpl::GetDefaultResourceSign
     std::unordered_map<ShaderResourceHashKey, const SPIRVShaderResourceAttribs&, ShaderResourceHashKey::Hasher> UniqueResources;
     for (const ShaderStageInfo& Stage : ShaderStages)
     {
-        for (const ShaderVkImpl* pShader : Stage.Shaders)
+        for (const ShaderStageInfo::Item& StageItem : Stage.Items)
         {
-            const SPIRVShaderResources& ShaderResources = *pShader->GetShaderResources();
+            const SPIRVShaderResources& ShaderResources = *StageItem.pShader->GetShaderResources();
             ShaderResources.ProcessResources(
                 [&](const SPIRVShaderResourceAttribs& Attribs, Uint32) //
                 {
@@ -627,7 +624,7 @@ PipelineResourceSignatureDescWrapper PipelineStateVkImpl::GetDefaultResourceSign
                     {
                         if (Attribs.ArraySize == 0)
                         {
-                            LOG_ERROR_AND_THROW("Resource '", Attribs.Name, "' in shader '", pShader->GetDesc().Name, "' is a runtime-sized array. ",
+                            LOG_ERROR_AND_THROW("Resource '", Attribs.Name, "' in shader '", ShaderResources.GetShaderName(), "' is a runtime-sized array. ",
                                                 "You must use explicit resource signature to specify the array size.");
                         }
 
@@ -668,21 +665,21 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
 
     // Verify that pipeline layout is compatible with shader resources and
     // remap resource bindings.
-    for (size_t s = 0; s < ShaderStages.size(); ++s)
+    for (ShaderStageInfo& Stage : ShaderStages)
     {
-        const std::vector<const ShaderVkImpl*>& Shaders    = ShaderStages[s].Shaders;
-        std::vector<std::vector<uint32_t>>&     SPIRVs     = ShaderStages[s].SPIRVs;
-        const SHADER_TYPE                       ShaderType = ShaderStages[s].Type;
+        const SHADER_TYPE ShaderType = Stage.Type;
 
-        VERIFY_EXPR(Shaders.size() == SPIRVs.size());
-
-        for (size_t i = 0; i < Shaders.size(); ++i)
+        for (ShaderStageInfo::Item& StageItem : Stage.Items)
         {
-            const ShaderVkImpl*    pShader = Shaders[i];
-            std::vector<uint32_t>& SPIRV   = SPIRVs[i];
+            const char* const               ShaderName       = StageItem.pShader->GetDesc().Name;
+            const ShaderResourcesSharedPtr& pShaderResources = StageItem.pShader->GetShaderResources();
+            std::vector<uint32_t>&          SPIRV            = StageItem.SPIRV;
 
-            const auto& pShaderResources = pShader->GetShaderResources();
-            VERIFY_EXPR(pShaderResources);
+            if (!pShaderResources)
+            {
+                UNEXPECTED("Shader resources are not initialized for shader '", ShaderName, "'. This is a bug.");
+                continue;
+            }
 
             if (pDvpShaderResources)
                 pDvpShaderResources->emplace_back(pShaderResources);
@@ -693,7 +690,7 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
                     const ResourceAttribution ResAttribution = GetResourceAttribution(SPIRVAttribs.Name, ShaderType, pSignatures, SignatureCount);
                     if (!ResAttribution)
                     {
-                        LOG_ERROR_AND_THROW("Shader '", pShader->GetDesc().Name, "' contains resource '", SPIRVAttribs.Name,
+                        LOG_ERROR_AND_THROW("Shader '", ShaderName, "' contains resource '", SPIRVAttribs.Name,
                                             "' that is not present in any pipeline resource signature used to create pipeline state '",
                                             PipelineName, "'.");
                     }
@@ -708,7 +705,7 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
                     {
                         const PipelineResourceDesc& ResDesc = ResAttribution.pSignature->GetResourceDesc(ResAttribution.ResourceIndex);
                         ValidatePipelineResourceCompatibility(ResDesc, ResType, Flags, SPIRVAttribs.ArraySize,
-                                                              pShader->GetDesc().Name, SignDesc.Name);
+                                                              ShaderName, SignDesc.Name);
 
                         const PipelineResourceSignatureVkImpl::ResourceAttribs& ResAttribs{ResAttribution.pSignature->GetResourceAttribs(ResAttribution.ResourceIndex)};
                         ResourceBinding = ResAttribs.BindingIndex;
@@ -718,7 +715,7 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
                     {
                         if (ResType != SHADER_RESOURCE_TYPE_SAMPLER)
                         {
-                            LOG_ERROR_AND_THROW("Shader '", pShader->GetDesc().Name, "' contains resource with name '", SPIRVAttribs.Name,
+                            LOG_ERROR_AND_THROW("Shader '", ShaderName, "' contains resource with name '", SPIRVAttribs.Name,
                                                 "' and type '", GetShaderResourceTypeLiteralName(ResType),
                                                 "' that is not compatible with immutable sampler defined in pipeline resource signature '",
                                                 SignDesc.Name, "'.");
@@ -740,13 +737,13 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
                         const Uint32 SpvDescrSet = SPIRV[SPIRVAttribs.DescriptorSetDecorationOffset];
                         if (SpvBinding != ResourceBinding)
                         {
-                            LOG_ERROR_AND_THROW("Shader '", pShader->GetDesc().Name, "' maps resource '", SPIRVAttribs.Name,
+                            LOG_ERROR_AND_THROW("Shader '", ShaderName, "' maps resource '", SPIRVAttribs.Name,
                                                 "' to binding ", SpvBinding, ", but the same resource in pipeline resource signature '",
                                                 SignDesc.Name, "' is mapped to binding ", ResourceBinding, '.');
                         }
                         if (SpvDescrSet != DescriptorSet)
                         {
-                            LOG_ERROR_AND_THROW("Shader '", pShader->GetDesc().Name, "' maps resource '", SPIRVAttribs.Name,
+                            LOG_ERROR_AND_THROW("Shader '", ShaderName, "' maps resource '", SPIRVAttribs.Name,
                                                 "' to descriptor set ", SpvDescrSet, ", but the same resource in pipeline resource signature '",
                                                 SignDesc.Name, "' is mapped to set ", DescriptorSet, '.');
                         }
@@ -777,7 +774,7 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
                 if (!StrippedSPIRV.empty())
                     SPIRV = std::move(StrippedSPIRV);
                 else
-                    LOG_ERROR("Failed to strip reflection information from shader '", pShader->GetDesc().Name, "'. This may indicate a problem with the byte code.");
+                    LOG_ERROR("Failed to strip reflection information from shader '", ShaderName, "'. This may indicate a problem with the byte code.");
 #endif
             }
         }
@@ -899,7 +896,13 @@ void PipelineStateVkImpl::InitializePipeline(const RayTracingPipelineStateCreate
 // Used by TPipelineStateBase::Construct()
 inline std::vector<const ShaderVkImpl*> GetStageShaders(const PipelineStateVkImpl::ShaderStageInfo& Stage)
 {
-    return Stage.Shaders;
+    std::vector<const ShaderVkImpl*> StageShaders;
+    StageShaders.reserve(Stage.Count());
+    for (const PipelineStateVkImpl::ShaderStageInfo::Item& StageItem : Stage.Items)
+    {
+        StageShaders.push_back(StageItem.pShader);
+    }
+    return StageShaders;
 }
 
 PipelineStateVkImpl::PipelineStateVkImpl(IReferenceCounters* pRefCounters, RenderDeviceVkImpl* pDeviceVk, const GraphicsPipelineStateCreateInfo& CreateInfo) :