Merge pull request #1003 from Devsh-Graphics-Programming/pipeline-exec-info

Added support for VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES

Author: AnastaZIuk

examples_tests

@@ -23,13 +23,13 @@ namespace nbl::asset
 	Vulkan supports multiple types of pipelines:
 	- graphics pipeline
 	- compute pipeline
-	- TODO: Raytracing
+	- raytracing pipeline
 */
 class IPipelineBase
 {
     public:
       // TODO: tbf these shouldn't even be laying around in `nbl::asset`, we should probably move to `nbl::video::IGPUPipelineBase`
-      enum class CreationFlags : uint64_t
+		enum class CreationFlags : uint64_t
       {
         NONE = 0, // disallowed in maintanance5
         DISABLE_OPTIMIZATIONS = 1 << 0,
@@ -47,10 +47,8 @@ class IPipelineBase
         // This is for NV-raytracing extension. Now this is done via IDeferredOperation
         //DEFER_COMPILE_NV = 1<<5,
 
-        // We use Renderdoc to take care of this for us,
-        // we won't be parsing the statistics and internal representation ourselves.
-        //CAPTURE_STATISTICS = 1<<6,
-        //CAPTURE_INTERNAL_REPRESENTATIONS = 1<<7,
+        CAPTURE_STATISTICS = 1<<6,
+        CAPTURE_INTERNAL_REPRESENTATIONS = 1<<7,
 
         // Will soon be deprecated due to
         // https://github.com/Devsh-Graphics-Programming/Nabla/issues/854

include/nbl/asset/IPipeline.h

@@ -31,6 +31,8 @@ class IRayTracingPipelineBase : public virtual core::IReferenceCounted
             NO_NULL_MISS_SHADERS = 1<<16,
             NO_NULL_INTERSECTION_SHADERS = 1<<17,
             ALLOW_MOTION = 1<<20,
+            CAPTURE_STATISTICS = base_flag(CAPTURE_STATISTICS),
+            CAPTURE_INTERNAL_REPRESENTATIONS = base_flag(CAPTURE_INTERNAL_REPRESENTATIONS),
         };
         #undef base_flag
 

include/nbl/asset/IRayTracingPipeline.h

@@ -25,6 +25,8 @@ class CVulkanRayTracingPipeline final : public IGPURayTracingPipeline
 
     inline VkPipeline getInternalObject() const { return m_vkPipeline; }
 
+    void populateExecutableInfo(bool includeInternalRepresentations) override;
+
     virtual const SShaderGroupHandle& getRaygen() const override;
     virtual std::span<const SShaderGroupHandle> getMissHandles() const override;
     virtual std::span<const SShaderGroupHandle> getHitHandles() const override;

include/nbl/video/CVulkanRayTracingPipeline.h

@@ -38,6 +38,8 @@ class IGPUComputePipeline : public IGPUPipeline<asset::IComputePipeline<const IG
                 DISPATCH_BASE = 1<<4,
                 FAIL_ON_PIPELINE_COMPILE_REQUIRED = base_flag(FAIL_ON_PIPELINE_COMPILE_REQUIRED),
                 EARLY_RETURN_ON_FAILURE = base_flag(EARLY_RETURN_ON_FAILURE),
+                CAPTURE_STATISTICS = base_flag(CAPTURE_STATISTICS),
+                CAPTURE_INTERNAL_REPRESENTATIONS = base_flag(CAPTURE_INTERNAL_REPRESENTATIONS),
                 // Not Supported Yet
                 //CREATE_LIBRARY = base_flag(CREATE_LIBRARY),
                 // Not Supported Yet

include/nbl/video/IGPUComputePipeline.h

@@ -29,6 +29,8 @@ class IGPUGraphicsPipeline : public IGPUPipeline<asset::IGraphicsPipeline<const
                 VIEW_INDEX_FROM_DEVICE_INDEX = 1<<3,
                 FAIL_ON_PIPELINE_COMPILE_REQUIRED = base_flag(FAIL_ON_PIPELINE_COMPILE_REQUIRED),
                 EARLY_RETURN_ON_FAILURE = base_flag(EARLY_RETURN_ON_FAILURE),
+                CAPTURE_STATISTICS = base_flag(CAPTURE_STATISTICS),
+                CAPTURE_INTERNAL_REPRESENTATIONS = base_flag(CAPTURE_INTERNAL_REPRESENTATIONS),
             };
             #undef base_flag
 

include/nbl/video/IGPUGraphicsPipeline.h

@@ -10,6 +10,7 @@
 #include "nbl/video/SPipelineCreationParams.h"
 #include "nbl/asset/ICPUPipeline.h"
 #include "nbl/asset/IPipeline.h"
+#include "nbl/system/to_string.h"
 
 namespace nbl::video
 {
@@ -127,6 +128,21 @@ class IGPUPipelineBase {
 
         using SShaderEntryMap = SShaderSpecInfo::entry_map_t;
 
+        // Per-executable info from VK_KHR_pipeline_executable_properties
+        struct SExecutableInfo
+        {
+            std::string name;
+            std::string description;
+            core::bitflag<hlsl::ShaderStage> stages = hlsl::ShaderStage::ESS_UNKNOWN;
+            uint32_t subgroupSize = 0;
+            std::string statistics;
+            std::string internalRepresentations;
+        };
+
+        inline std::span<const SExecutableInfo> getExecutableInfo() const { return m_executableInfo; }
+
+    protected:
+        core::vector<SExecutableInfo> m_executableInfo;
 };
 
 // Common Base class for pipelines
@@ -142,6 +158,55 @@ class IGPUPipeline : public IBackendObject, public PipelineNonBackendObjectBase,
         {}
         virtual ~IGPUPipeline() = default;
 
+        virtual void populateExecutableInfo(bool includeInternalRepresentations) = 0;
+
+};
+
+}
+
+namespace nbl::system::impl
+{
+
+template<>
+struct to_string_helper<video::IGPUPipelineBase::SExecutableInfo>
+{
+		static std::string __call(const video::IGPUPipelineBase::SExecutableInfo& info)
+		{
+			std::string result;
+			result += "======== ";
+			result += info.name;
+			result += " ========\n";
+			result += info.description;
+			result += "\nSubgroup Size: ";
+			result += std::to_string(info.subgroupSize);
+			if (!info.statistics.empty())
+			{
+				result += "\n";
+				result += info.statistics;
+			}
+			if (!info.internalRepresentations.empty())
+			{
+				result += "\n";
+				result += info.internalRepresentations;
+			}
+			return result;
+		}
+};
+
+// Another version for core::vector?
+template<>
+struct to_string_helper<std::span<const video::IGPUPipelineBase::SExecutableInfo>>
+{
+		static std::string __call(const std::span<const video::IGPUPipelineBase::SExecutableInfo>& infos)
+		{
+			std::string result;
+			for (const auto& info : infos)
+			{
+				result += to_string_helper<video::IGPUPipelineBase::SExecutableInfo>::__call(info);
+				result += "\n";
+			}
+			return result;
+		}
 };
 
 }

include/nbl/video/IGPUPipeline.h

@@ -14,6 +14,7 @@
 #include "nbl/video/IGPUCommandBuffer.h"
 #include "nbl/video/CThreadSafeQueueAdapter.h"
 #include "nbl/video/CJITIncludeLoader.h"
+#include "nbl/system/to_string.h"
 
 #include "git_info.h"
 #define NBL_LOG_FUNCTION m_logger.log
@@ -1273,6 +1274,20 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
                     return {};
                 }
 
+                // CAPTURE_STATISTICS and CAPTURE_INTERNAL_REPRESENTATIONS require pipelineExecutableInfo feature
+                constexpr auto CaptureStatsFlag = CreationParams::FLAGS::CAPTURE_STATISTICS;
+                constexpr auto CaptureIRFlag = CreationParams::FLAGS::CAPTURE_INTERNAL_REPRESENTATIONS;
+                if (ci.getFlags().hasFlags(CaptureStatsFlag) && !getEnabledFeatures().pipelineExecutableInfo)
+                {
+                    NBL_LOG_ERROR("CAPTURE_STATISTICS flag requires `pipelineExecutableInfo` feature (params[%d])", i);
+                    return {};
+                }
+                if (ci.getFlags().hasFlags(CaptureIRFlag) && !getEnabledFeatures().pipelineExecutableInfo)
+                {
+                    NBL_LOG_ERROR("CAPTURE_INTERNAL_REPRESENTATIONS flag requires `pipelineExecutableInfo` feature (params[%d])", i);
+                    return {};
+                }
+
                 retval += validation;
             }
             return retval;

include/nbl/video/ILogicalDevice.h

@@ -1,6 +1,7 @@
 #include "nbl/video/CVulkanComputePipeline.h"
 
 #include "nbl/video/CVulkanLogicalDevice.h"
+#include "nbl/video/CVulkanPipelineExecutableInfo.h"
 
 namespace nbl::video
 {
@@ -12,6 +13,12 @@ CVulkanComputePipeline::~CVulkanComputePipeline()
     vk->vk.vkDestroyPipeline(vulkanDevice->getInternalObject(), m_pipeline, nullptr);
 }
 
+void CVulkanComputePipeline::populateExecutableInfo(bool includeInternalRepresentations)
+{
+	const CVulkanLogicalDevice* vulkanDevice = static_cast<const CVulkanLogicalDevice*>(getOriginDevice());
+	populateExecutableInfoFromVulkan(m_executableInfo, vulkanDevice->getFunctionTable(), vulkanDevice->getInternalObject(), m_pipeline, includeInternalRepresentations);
+}
+
 void CVulkanComputePipeline::setObjectDebugName(const char* label) const
 {
     IBackendObject::setObjectDebugName(label);

src/nbl/video/CVulkanComputePipeline.cpp

@@ -17,12 +17,18 @@ class CVulkanComputePipeline final : public IGPUComputePipeline
         CVulkanComputePipeline(
             const SCreationParams& params,
             const VkPipeline pipeline
-        ) : IGPUComputePipeline(params), m_pipeline(pipeline) {}
+        ) : IGPUComputePipeline(params), m_pipeline(pipeline)
+        {
+            if (params.flags.hasFlags(SCreationParams::FLAGS::CAPTURE_STATISTICS))
+                populateExecutableInfo(params.flags.hasFlags(SCreationParams::FLAGS::CAPTURE_INTERNAL_REPRESENTATIONS));
+        }
 
         inline const void* getNativeHandle() const override { return &m_pipeline; }
 
         inline VkPipeline getInternalObject() const { return m_pipeline; }
-    
+
+        void populateExecutableInfo(bool includeInternalRepresentations) override;
+
         void setObjectDebugName(const char* label) const override;
 
     private: