Moved vulkan code to CVulkanPipelineExecutableInfo.h and moved data to pipeline base

Author: karimsayedre

examples_tests

@@ -25,6 +25,8 @@ class CVulkanRayTracingPipeline final : public IGPURayTracingPipeline
 
     inline VkPipeline getInternalObject() const { return m_vkPipeline; }
 
+    void populateExecutableInfo(bool includeInternalRepresentations);
+
     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

@@ -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
@@ -146,4 +162,51 @@ class IGPUPipeline : public IBackendObject, public PipelineNonBackendObjectBase,
 
 }
 
+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;
+		}
+};
+
+}
+
 #endif

include/nbl/video/IGPUPipeline.h

@@ -1034,47 +1034,6 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
           const std::span<const IGPURayTracingPipeline::SCreationParams> params,
           core::smart_refctd_ptr<IGPURayTracingPipeline>* const output);
 
-        // Per-executable info from VK_KHR_pipeline_executable_properties
-        struct SPipelineExecutableInfo
-        {
-            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;
-        };
-
-        // Query pipeline executable properties (VK_KHR_pipeline_executable_properties).
-        // Pipeline must have been created with CAPTURE_STATISTICS flag for statistics.
-        // Pipeline must have been created with CAPTURE_INTERNAL_REPRESENTATIONS flag for IR.
-        template<typename Pipeline>
-        core::vector<SPipelineExecutableInfo> getPipelineExecutableProperties(const Pipeline* pipeline, bool includeInternalRepresentations = false)
-        {
-            if (!pipeline)
-            {
-                NBL_LOG_ERROR("Null pipeline");
-                return {};
-            }
-            using flags_t = Pipeline::SCreationParams::FLAGS;
-            if (!pipeline->getCreationFlags().hasFlags(flags_t::CAPTURE_STATISTICS))
-            {
-                NBL_LOG_ERROR("Pipeline was not created with CAPTURE_STATISTICS flag");
-                return {};
-            }
-            if (includeInternalRepresentations && !pipeline->getCreationFlags().hasFlags(flags_t::CAPTURE_INTERNAL_REPRESENTATIONS))
-            {
-                NBL_LOG_ERROR("Pipeline was not created with CAPTURE_INTERNAL_REPRESENTATIONS flag");
-                return {};
-            }
-            auto properties = getPipelineExecutableProperties_impl(pipeline, includeInternalRepresentations);
-            if (properties.empty())
-            {
-            	NBL_LOG_ERROR("Driver returned 0 executables for pipeline created with CAPTURE_STATISTICS flag. This pipeline type may not be supported by the driver's VK_KHR_pipeline_executable_properties implementation.");
-			}
-            return properties;
-        }
-
         // queries
         inline core::smart_refctd_ptr<IQueryPool> createQueryPool(const IQueryPool::SCreationParams& params)
         {
@@ -1352,10 +1311,6 @@ class NBL_API2 ILogicalDevice : public core::IReferenceCounted, public IDeviceMe
             const SSpecializationValidationResult& validation
         ) = 0;
 
-        virtual core::vector<SPipelineExecutableInfo> getPipelineExecutableProperties_impl(const IGPUComputePipeline* pipeline, bool includeInternalRepresentations) = 0;
-        virtual core::vector<SPipelineExecutableInfo> getPipelineExecutableProperties_impl(const IGPUGraphicsPipeline* pipeline, bool includeInternalRepresentations) = 0;
-        virtual core::vector<SPipelineExecutableInfo> getPipelineExecutableProperties_impl(const IGPURayTracingPipeline* pipeline, bool includeInternalRepresentations) = 0;
-
         virtual core::smart_refctd_ptr<IQueryPool> createQueryPool_impl(const IQueryPool::SCreationParams& params) = 0;
         virtual bool getQueryPoolResults_impl(const IQueryPool* const queryPool, const uint32_t firstQuery, const uint32_t queryCount, void* const pData, const size_t stride, const core::bitflag<IQueryPool::RESULTS_FLAGS> flags) = 0;
 
@@ -1665,51 +1620,5 @@ inline bool ILogicalDevice::validateMemoryBarrier(const uint32_t queueFamilyInde
 
 } // namespace nbl::video
 
-namespace nbl::system::impl
-{
-
-template<>
-struct to_string_helper<video::ILogicalDevice::SPipelineExecutableInfo>
-{
-    static std::string __call(const video::ILogicalDevice::SPipelineExecutableInfo& 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;
-    }
-};
-
-template<>
-struct to_string_helper<core::vector<video::ILogicalDevice::SPipelineExecutableInfo>>
-{
-    static std::string __call(const core::vector<video::ILogicalDevice::SPipelineExecutableInfo>& infos)
-    {
-        std::string result;
-        for (const auto& info : infos)
-        {
-            result += to_string_helper<video::ILogicalDevice::SPipelineExecutableInfo>::__call(info);
-            result += "\n";
-        }
-        return result;
-    }
-};
-
-}
-
 #include "nbl/undef_logging_macros.h"
 #endif //_NBL_VIDEO_I_LOGICAL_DEVICE_H_INCLUDED_

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

@@ -22,7 +22,9 @@ class CVulkanComputePipeline final : public IGPUComputePipeline
         inline const void* getNativeHandle() const override { return &m_pipeline; }
 
         inline VkPipeline getInternalObject() const { return m_pipeline; }
-    
+
+        void populateExecutableInfo(bool includeInternalRepresentations);
+
         void setObjectDebugName(const char* label) const override;
 
     private:

src/nbl/video/CVulkanComputePipeline.h

@@ -1,10 +1,17 @@
 #include "nbl/video/CVulkanGraphicsPipeline.h"
 
 #include "nbl/video/CVulkanLogicalDevice.h"
+#include "CVulkanPipelineExecutableInfo.h"
 
 namespace nbl::video
 {
 
+void CVulkanGraphicsPipeline::populateExecutableInfo(bool includeInternalRepresentations)
+{
+    const CVulkanLogicalDevice* vulkanDevice = static_cast<const CVulkanLogicalDevice*>(getOriginDevice());
+    populateExecutableInfoFromVulkan(m_executableInfo, vulkanDevice->getFunctionTable(), vulkanDevice->getInternalObject(), m_vkPipeline, includeInternalRepresentations);
+}
+
 CVulkanGraphicsPipeline::~CVulkanGraphicsPipeline()
 {
     const CVulkanLogicalDevice* vulkanDevice = static_cast<const CVulkanLogicalDevice*>(getOriginDevice());

src/nbl/video/CVulkanGraphicsPipeline.cpp

@@ -18,6 +18,8 @@ class CVulkanGraphicsPipeline final : public IGPUGraphicsPipeline
 
         inline VkPipeline getInternalObject() const {return m_vkPipeline;}
 
+        void populateExecutableInfo(bool includeInternalRepresentations);
+
     private:
         ~CVulkanGraphicsPipeline();