Move required subgroups size stages checking to commonCreatePipelines

Author: kevyuu

include/nbl/video/IGPUComputePipeline.h

@@ -62,6 +62,15 @@ class IGPUComputePipeline : public IGPUPipeline<asset::IComputePipeline<const IG
                 return retval;
             }
 
+            inline core::bitflag<hlsl::ShaderStage> getRequiredSubgroupStages() const
+            {
+                if (shader.requiredSubgroupSize >= asset::IPipelineBase::SUBGROUP_SIZE::REQUIRE_4)
+                {
+                    return hlsl::ESS_COMPUTE;
+                }
+                return {};
+            }
+
             IGPUPipelineLayout* layout = nullptr;
             // TODO: Could guess the required flags from SPIR-V introspection of declared caps
             core::bitflag<FLAGS> flags = FLAGS::NONE;

include/nbl/video/IGPUGraphicsPipeline.h

@@ -67,6 +67,23 @@ class IGPUGraphicsPipeline : public IGPUPipeline<asset::IGraphicsPipeline<const
                 return retval;
             }
 
+            inline core::bitflag<hlsl::ShaderStage> getRequiredSubgroupStages() const
+            {
+                core::bitflag<hlsl::ShaderStage> stages;
+                auto processSpecInfo = [&](const SShaderSpecInfo& spec, hlsl::ShaderStage stage)
+                {
+                    if (spec.requiredSubgroupSize >= SUBGROUP_SIZE::REQUIRE_4) {
+                      stages |= stage;
+                    }
+                };
+                processSpecInfo(vertexShader, hlsl::ESS_VERTEX);
+                processSpecInfo(tesselationControlShader, hlsl::ESS_TESSELLATION_CONTROL);
+                processSpecInfo(tesselationEvaluationShader, hlsl::ESS_TESSELLATION_EVALUATION);
+                processSpecInfo(geometryShader, hlsl::ESS_GEOMETRY);
+                processSpecInfo(fragmentShader, hlsl::ESS_FRAGMENT);
+                return stages;
+            }
+
             IGPUPipelineLayout* layout = nullptr;
             SShaderSpecInfo vertexShader;
             SShaderSpecInfo tesselationControlShader;

include/nbl/video/IGPURayTracingPipeline.h

@@ -143,6 +143,30 @@ class IGPURayTracingPipeline :  public IGPUPipeline<asset::IRayTracingPipeline<c
 
                 return retval;
             }
+
+            inline core::bitflag<hlsl::ShaderStage> getRequiredSubgroupStages() const
+            {
+                core::bitflag<hlsl::ShaderStage> stages;
+                auto processSpecInfo = [&](const SShaderSpecInfo& spec, hlsl::ShaderStage stage)
+                {
+                    if (spec.requiredSubgroupSize >= SUBGROUP_SIZE::REQUIRE_4) {
+                      stages |= stage;
+                    }
+                };
+                processSpecInfo(shaderGroups.raygen, hlsl::ESS_RAYGEN);
+                for (const auto& miss : shaderGroups.misses)
+                    processSpecInfo(miss, hlsl::ESS_MISS);
+                for (const auto& hit : shaderGroups.hits)
+                {
+                    processSpecInfo(hit.closestHit, hlsl::ESS_CLOSEST_HIT);
+                    processSpecInfo(hit.anyHit, hlsl::ESS_ANY_HIT);
+                    processSpecInfo(hit.intersection, hlsl::ESS_INTERSECTION);
+                }
+                for (const auto& callable : shaderGroups.callables)
+                    processSpecInfo(callable, hlsl::ESS_CALLABLE);
+                return stages;
+            }
+
         };
 
         struct SShaderGroupHandle

include/nbl/video/ILogicalDevice.h

@@ -1259,6 +1259,14 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
                     return {};
                 }
 
+                // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02755
+                const auto requiredSubgroupSizeStages = getPhysicalDeviceLimits().requiredSubgroupSizeStages;
+                if (!requiredSubgroupSizeStages.hasFlags(ci.getRequiredSubgroupStages()))
+                {
+                    NBL_LOG_ERROR("Invalid shader stage");
+                    return {};
+                }
+
                 retval += validation;
             }
             return retval;

src/nbl/video/ILogicalDevice.cpp

@@ -812,13 +812,6 @@ bool ILogicalDevice::createComputePipelines(IGPUPipelineCache* const pipelineCac
     {
         const auto& ci = params[ix];
 
-        // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02755
-        if (ci.shader.requiredSubgroupSize>=asset::IPipelineBase::SUBGROUP_SIZE::REQUIRE_4 && !getPhysicalDeviceLimits().requiredSubgroupSizeStages.hasFlags(hlsl::ShaderStage::ESS_COMPUTE))
-        {
-            NBL_LOG_ERROR("Invalid shader stage");
-            return false;
-        }
-
         const core::set entryPoints = { asset::ISPIRVDebloater::EntryPoint{.name = ci.shader.entryPoint, .stage = hlsl::ShaderStage::ESS_COMPUTE} };
         debloatedShaders.push_back(m_spirvDebloater->debloat(ci.shader.shader, entryPoints, m_logger));
         auto debloatedShaderSpec = ci.shader;