Vulkan: added EnableDeviceSimulation(), fixed queue priority

Author: azhirnov

Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanInstance.hpp

@@ -44,11 +44,17 @@ class VulkanInstance : public std::enable_shared_from_this<VulkanInstance>
     VulkanInstance& operator = (      VulkanInstance&&) = delete;
     // clang-format on
 
-    static std::shared_ptr<VulkanInstance> Create(uint32_t               ApiVersion,
-                                                  bool                   EnableValidation,
-                                                  uint32_t               InstanceExtensionCount,
-                                                  const char* const*     ppInstanceExtensionNames,
-                                                  VkAllocationCallbacks* pVkAllocator);
+    struct CreateInfo
+    {
+        uint32_t               ApiVersion               = 0;
+        bool                   EnableValidation         = false;
+        bool                   EnableDeviceSimulation   = false;
+        uint32_t               InstanceExtensionCount   = 0;
+        const char* const*     ppInstanceExtensionNames = nullptr;
+        VkAllocationCallbacks* pVkAllocator             = nullptr;
+    };
+    static std::shared_ptr<VulkanInstance> Create(const CreateInfo& CI);
+
     ~VulkanInstance();
 
     std::shared_ptr<VulkanInstance> GetSharedPtr()
@@ -76,11 +82,7 @@ class VulkanInstance : public std::enable_shared_from_this<VulkanInstance>
     const std::vector<VkPhysicalDevice>& GetVkPhysicalDevices() const { return m_PhysicalDevices; }
 
 private:
-    VulkanInstance(uint32_t               ApiVersion,
-                   bool                   EnableValidation,
-                   uint32_t               InstanceExtensionCount,
-                   const char* const*     ppInstanceExtensionNames,
-                   VkAllocationCallbacks* pVkAllocator);
+    explicit VulkanInstance(const CreateInfo& CI);
 
     bool                         m_DebugUtilsEnabled = false;
     VkAllocationCallbacks* const m_pVkAllocator;

Graphics/GraphicsEngineVulkan/interface/EngineFactoryVk.h

@@ -98,6 +98,14 @@ DILIGENT_BEGIN_INTERFACE(IEngineFactoryVk, IEngineFactory)
                                            const SwapChainDesc REF SwapChainDesc,
                                            const NativeWindow REF  Window,
                                            ISwapChain**            ppSwapChain) PURE;
+
+    /// Enable device simulation layer (if available).
+
+    /// Vulkan instance will be created with the device simulation layer.
+    /// Use VK_DEVSIM_FILENAME environment variable to define the path to the .json file.
+    /// 
+    /// \remarks Use this function before calling EnumerateAdapters() and CreateDeviceAndContextsVk().
+    VIRTUAL void METHOD(EnableDeviceSimulation)(THIS) PURE;
 };
 DILIGENT_END_INTERFACE
 
@@ -109,6 +117,7 @@ DILIGENT_END_INTERFACE
 
 #    define IEngineFactoryVk_CreateDeviceAndContextsVk(This, ...) CALL_IFACE_METHOD(EngineFactoryVk, CreateDeviceAndContextsVk, This, __VA_ARGS__)
 #    define IEngineFactoryVk_CreateSwapChainVk(This, ...)         CALL_IFACE_METHOD(EngineFactoryVk, CreateSwapChainVk,         This, __VA_ARGS__)
+#    define IEngineFactoryVk_EnableDeviceSimulation(This)         CALL_IFACE_METHOD(EngineFactoryVk, EnableDeviceSimulation,    This)
 
 // clang-format on
 

Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp

@@ -105,6 +105,11 @@ class EngineFactoryVkImpl final : public EngineFactoryBase<IEngineFactoryVk>
                                                       Uint32&              NumAdapters,
                                                       GraphicsAdapterInfo* Adapters) const override final;
 
+    virtual void DILIGENT_CALL_TYPE EnableDeviceSimulation() override final
+    {
+        m_EnableDeviceSimulation = true;
+    }
+
 #if PLATFORM_ANDROID
     virtual void InitAndroidFileSystem(struct ANativeActivity* NativeActivity,
                                        const char*             NativeActivityClassName,
@@ -116,6 +121,8 @@ class EngineFactoryVkImpl final : public EngineFactoryBase<IEngineFactoryVk>
 
     // To track that there is only one render device
     RefCntWeakPtr<IRenderDevice> m_wpDevice;
+
+    bool m_EnableDeviceSimulation = false;
 };
 
 
@@ -346,7 +353,7 @@ void EngineFactoryVkImpl::EnumerateAdapters(Version              MinVersion,
     // Create instance with maximum available version.
     // If Volk is not enabled then version will be 1.0
     const uint32_t APIVersion = VK_MAKE_VERSION(0xFF, 0xFF, 0);
-    auto           Instance   = VulkanUtilities::VulkanInstance::Create(APIVersion, false, 0, nullptr, nullptr);
+    auto           Instance   = VulkanUtilities::VulkanInstance::Create({APIVersion, false, m_EnableDeviceSimulation, 0, nullptr, nullptr});
 
     if (Adapters == nullptr)
     {
@@ -397,15 +404,24 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
             EngineCI.GraphicsAPIVersion;
 
         auto Instance = VulkanUtilities::VulkanInstance::Create(
-            VK_MAKE_VERSION(GraphicsAPIVersion.Major, GraphicsAPIVersion.Minor, 0),
-            EngineCI.EnableValidation,
-            EngineCI.InstanceExtensionCount,
-            EngineCI.ppInstanceExtensionNames,
-            reinterpret_cast<VkAllocationCallbacks*>(EngineCI.pVkAllocator));
+            {
+                VK_MAKE_VERSION(GraphicsAPIVersion.Major, GraphicsAPIVersion.Minor, 0),
+                EngineCI.EnableValidation,
+                m_EnableDeviceSimulation,
+                EngineCI.InstanceExtensionCount,
+                EngineCI.ppInstanceExtensionNames,
+                reinterpret_cast<VkAllocationCallbacks*>(EngineCI.pVkAllocator) //
+            });
 
         auto vkDevice       = Instance->SelectPhysicalDevice(EngineCI.AdapterId);
         auto PhysicalDevice = VulkanUtilities::VulkanPhysicalDevice::Create(vkDevice, *Instance);
 
+        std::vector<const char*> DeviceExtensions =
+            {
+                VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+                VK_KHR_MAINTENANCE1_EXTENSION_NAME // To allow negative viewport height
+            };
+
         // Enable device features if they are supported and throw an error if not supported, but required by user.
         const auto AdapterInfo = GetPhysicalDeviceGraphicsAdapterInfo(*PhysicalDevice);
         VerifyEngineCreateInfo(EngineCI, AdapterInfo);
@@ -455,8 +471,9 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
                 Priority = ContextInfo.Priority;
             }
 
-            if (Instance->IsExtensionEnabled(VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME))
+            if (PhysicalDevice->IsExtensionSupported(VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME))
             {
+                DeviceExtensions.push_back(VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME);
                 QueueGlobalPriority.resize(QueueInfos.size());
                 for (Uint32 QInd = 0; QInd < QueueInfos.size(); ++QInd)
                 {
@@ -538,12 +555,6 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
         vkEnabledFeatures.shaderStorageBufferArrayDynamicIndexing = vkDeviceFeatures.shaderStorageBufferArrayDynamicIndexing;
         vkEnabledFeatures.shaderStorageImageArrayDynamicIndexing  = vkDeviceFeatures.shaderStorageImageArrayDynamicIndexing;
 
-        std::vector<const char*> DeviceExtensions =
-            {
-                VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-                VK_KHR_MAINTENANCE1_EXTENSION_NAME // To allow negative viewport height
-            };
-
         using ExtensionFeatures                    = VulkanUtilities::VulkanPhysicalDevice::ExtensionFeatures;
         const ExtensionFeatures& DeviceExtFeatures = PhysicalDevice->GetExtFeatures();
         ExtensionFeatures        EnabledExtFeats   = {};

Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanInstance.cpp

@@ -79,22 +79,14 @@ bool VulkanInstance::IsExtensionEnabled(const char* ExtensionName) const
     return false;
 }
 
-std::shared_ptr<VulkanInstance> VulkanInstance::Create(uint32_t               ApiVersion,
-                                                       bool                   EnableValidation,
-                                                       uint32_t               InstanceExtensionCount,
-                                                       const char* const*     ppInstanceExtensionNames,
-                                                       VkAllocationCallbacks* pVkAllocator)
+std::shared_ptr<VulkanInstance> VulkanInstance::Create(const CreateInfo& CI)
 {
-    auto Instance = new VulkanInstance{ApiVersion, EnableValidation, InstanceExtensionCount, ppInstanceExtensionNames, pVkAllocator};
+    auto Instance = new VulkanInstance{CI};
     return std::shared_ptr<VulkanInstance>{Instance};
 }
 
-VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
-                               bool                   EnableValidation,
-                               uint32_t               InstanceExtensionCount,
-                               const char* const*     ppInstanceExtensionNames,
-                               VkAllocationCallbacks* pVkAllocator) :
-    m_pVkAllocator{pVkAllocator}
+VulkanInstance::VulkanInstance(const CreateInfo& CI) :
+    m_pVkAllocator{CI.pVkAllocator}
 {
 #if DILIGENT_USE_VOLK
     if (volkInitialize() != VK_SUCCESS)
@@ -161,21 +153,18 @@ VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
         InstanceExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
     }
 
-    if (IsExtensionAvailable(VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME))
+    if (CI.ppInstanceExtensionNames != nullptr)
     {
-        InstanceExtensions.push_back(VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME);
-    }
-
-    if (ppInstanceExtensionNames != nullptr)
-    {
-        for (uint32_t ext = 0; ext < InstanceExtensionCount; ++ext)
-            InstanceExtensions.push_back(ppInstanceExtensionNames[ext]);
+        for (uint32_t ext = 0; ext < CI.InstanceExtensionCount; ++ext)
+            InstanceExtensions.push_back(CI.ppInstanceExtensionNames[ext]);
     }
     else
     {
-        if (InstanceExtensionCount != 0)
-            LOG_ERROR_MESSAGE("Global extensions pointer is null while extensions count is ", InstanceExtensionCount,
+        if (CI.InstanceExtensionCount != 0)
+        {
+            LOG_ERROR_MESSAGE("Global extensions pointer is null while extensions count is ", CI.InstanceExtensionCount,
                               ". Please initialize 'ppInstanceExtensionNames' member of EngineVkCreateInfo struct.");
+        }
     }
 
     for (const auto* ExtName : InstanceExtensions)
@@ -184,7 +173,7 @@ VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
             LOG_ERROR_AND_THROW("Required extension ", ExtName, " is not available");
     }
 
-    if (EnableValidation)
+    if (CI.EnableValidation)
     {
         m_DebugUtilsEnabled = IsExtensionAvailable(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
         if (m_DebugUtilsEnabled)
@@ -197,6 +186,7 @@ VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
         }
     }
 
+    auto ApiVersion = CI.ApiVersion;
 #if DILIGENT_USE_VOLK
     if (vkEnumerateInstanceVersion != nullptr && ApiVersion > VK_API_VERSION_1_0)
     {
@@ -216,8 +206,8 @@ VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
 
     std::vector<const char*> InstanceLayers;
 
-    // Set to 1 and define environment variable VK_DEVSIM_FILENAME to enable device simulation layer
-#if 0
+    // Use VK_DEVSIM_FILENAME environment variable to define the simulation layer
+    if (CI.EnableDeviceSimulation)
     {
         static const char* DeviceSimulationLayer = "VK_LAYER_LUNARG_device_simulation";
 
@@ -227,9 +217,8 @@ VulkanInstance::VulkanInstance(uint32_t               ApiVersion,
             InstanceLayers.push_back(DeviceSimulationLayer);
         }
     }
-#endif
 
-    if (EnableValidation)
+    if (CI.EnableValidation)
     {
         for (size_t l = 0; l < _countof(VulkanUtilities::ValidationLayerNames); ++l)
         {

Tests/DiligentCoreAPITest/include/TestingEnvironment.hpp

@@ -56,6 +56,7 @@ class TestingEnvironment : public ::testing::Environment
         Uint32             AdapterId                 = DEFAULT_ADAPTER_ID;
         Uint32             NumDeferredContexts       = 4;
         bool               ForceNonSeparablePrograms = false;
+        bool               EnableDeviceSimulation    = false;
     };
     TestingEnvironment(const CreateInfo& CI, const SwapChainDesc& SCDesc);
 

Tests/DiligentCoreAPITest/src/TestingEnvironment.cpp

@@ -386,6 +386,10 @@ TestingEnvironment::TestingEnvironment(const CreateInfo& CI, const SwapChainDesc
 #    endif
 
             auto* pFactoryVk = GetEngineFactoryVk();
+
+            if (CI.EnableDeviceSimulation)
+                pFactoryVk->EnableDeviceSimulation();
+
             EnumerateAdapters(pFactoryVk, Version{});
             AddContext(COMMAND_QUEUE_TYPE_GRAPHICS, "Graphics", CI.AdapterId);
             AddContext(COMMAND_QUEUE_TYPE_COMPUTE, "Compute", CI.AdapterId);

Tests/DiligentCoreAPITest/src/main.cpp

@@ -127,6 +127,10 @@ int main(int argc, char** argv)
         {
             TestEnvCI.ForceNonSeparablePrograms = true;
         }
+        else if (strcmp(arg, "--vk_dev_sim") == 0)
+        {
+            TestEnvCI.EnableDeviceSimulation = true;
+        }
     }
 
     if (TestEnvCI.deviceType == RENDER_DEVICE_TYPE_UNDEFINED)