Switch VkDeviceCreateInfo to use patch callbacks

Author: solidpixel

generator/vk_layer/source/device.cpp

@@ -40,7 +40,7 @@
 static std::unordered_map<void*, std::unique_ptr<Device>> g_devices;
 
 /* See header for documentation. */
-const std::vector<std::string> Device::extraExtensions { };
+const std::vector<DeviceCreatePatchPtr> Device::createInfoPatches {};
 
 /* See header for documentation. */
 void Device::store(

generator/vk_layer/source/device.hpp

@@ -52,12 +52,22 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+#include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/vk_layer.h>
 
 #include "framework/device_dispatch_table.hpp"
-
 #include "instance.hpp"
 
+/**
+ * @brief Function pointer type for patching VkDeviceCreateInfo.
+ */
+using DeviceCreatePatchPtr = void (*)(Instance& instance,
+                                      VkPhysicalDevice physicalDevice,
+                                      vku::safe_VkDeviceCreateInfo& createInfo,
+                                      std::vector<std::string>& supported);
+
 /**
  * @brief This class implements the layer state tracker for a single device.
  */
@@ -144,7 +154,7 @@ class Device
     /**
      * @brief The minimum set of device extensions needed by this layer.
      */
-    static const std::vector<std::string> extraExtensions;
+    static const std::vector<DeviceCreatePatchPtr> createInfoPatches;
 
 private:
     /**

layer_example/source/device.cpp

@@ -41,7 +41,7 @@
 static std::unordered_map<void*, std::unique_ptr<Device>> g_devices;
 
 /* See header for documentation. */
-const std::vector<std::string> Device::extraExtensions {};
+const std::vector<DeviceCreatePatchPtr> Device::createInfoPatches {};
 
 /* See header for documentation. */
 void Device::store(VkDevice handle, std::unique_ptr<Device> device)

layer_example/source/device.hpp

@@ -52,10 +52,21 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/vk_layer.h>
+
 #include "framework/device_dispatch_table.hpp"
 #include "instance.hpp"
 
-#include <vulkan/vk_layer.h>
+/**
+ * @brief Function pointer type for patching VkDeviceCreateInfo.
+ */
+using DeviceCreatePatchPtr = void (*)(Instance& instance,
+                                      VkPhysicalDevice physicalDevice,
+                                      vku::safe_VkDeviceCreateInfo& createInfo,
+                                      std::vector<std::string>& supported);
 
 /**
  * @brief This class implements the layer state tracker for a single device.
@@ -134,9 +145,9 @@ class Device
     DeviceDispatchTable driver {};
 
     /**
-     * @brief The minimum set of device extensions needed by this layer.
+     * @brief The set of VkCreateDeviceInfo patches needed by this layer.
      */
-    static const std::vector<std::string> extraExtensions;
+    static const std::vector<DeviceCreatePatchPtr> createInfoPatches;
 
 private:
     /**

layer_gpu_support/source/device.cpp

@@ -23,8 +23,10 @@
  * ----------------------------------------------------------------------------
  */
 
-#include "device.hpp"
+#include <vulkan/utility/vk_struct_helper.hpp>
 
+#include "device.hpp"
+#include "framework/manual_functions.hpp"
 #include "framework/utils.hpp"
 #include "instance.hpp"
 
@@ -34,9 +36,9 @@
 static std::unordered_map<void*, std::unique_ptr<Device>> g_devices;
 
 /* See header for documentation. */
-const std::vector<std::string> Device::extraExtensions {
-    VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
-    VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME,
+const std::vector<DeviceCreatePatchPtr> Device::createInfoPatches {
+    enableDeviceVkKhrTimelineSemaphore,
+    enableDeviceVkExtImageCompressionControl
 };
 
 /* See header for documentation. */

layer_gpu_support/source/device.hpp

@@ -52,10 +52,23 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/vk_layer.h>
+
 #include "framework/device_dispatch_table.hpp"
 #include "instance.hpp"
 
-#include <vulkan/vk_layer.h>
+
+
+/**
+ * @brief Function pointer type for patching VkDeviceCreateInfo.
+ */
+using DeviceCreatePatchPtr = void (*)(Instance& instance,
+                                      VkPhysicalDevice physicalDevice,
+                                      vku::safe_VkDeviceCreateInfo& createInfo,
+                                      std::vector<std::string>& supported);
 
 /**
  * @brief This class implements the layer state tracker for a single device.
@@ -149,9 +162,9 @@ class Device
     DeviceDispatchTable driver {};
 
     /**
-     * @brief The minimum set of device extensions needed by this layer.
+     * @brief The set of VkCreateDeviceInfo patches needed by this layer.
      */
-    static const std::vector<std::string> extraExtensions;
+    static const std::vector<DeviceCreatePatchPtr> createInfoPatches;
 
     /**
      * @brief The timeline sem use for queue serialization.

layer_gpu_timeline/source/device.cpp

@@ -22,26 +22,23 @@
  * IN THE SOFTWARE.
  * ----------------------------------------------------------------------------
  */
-
-#include "device.hpp"
+#include <vector>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #include "comms/comms_module.hpp"
+#include "device.hpp"
 #include "framework/utils.hpp"
 #include "instance.hpp"
 #include "timeline_protobuf_encoder.hpp"
 
-#include <vector>
-
-#include <sys/stat.h>
-#include <unistd.h>
-
 /**
  * @brief The dispatch lookup for all of the created Vulkan devices.
  */
 static std::unordered_map<void*, std::unique_ptr<Device>> g_devices;
 
 /* See header for documentation. */
-const std::vector<std::string> Device::extraExtensions {};
+const std::vector<DeviceCreatePatchPtr> Device::createInfoPatches {};
 
 /* See header for documentation. */
 std::unique_ptr<Comms::CommsModule> Device::commsModule;

layer_gpu_timeline/source/device.hpp

@@ -52,13 +52,24 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/vk_layer.h>
+
 #include "comms/comms_module.hpp"
 #include "framework/device_dispatch_table.hpp"
 #include "instance.hpp"
 #include "timeline_comms.hpp"
 #include "trackers/device.hpp"
 
-#include <vulkan/vk_layer.h>
+/**
+ * @brief Function pointer type for patching VkDeviceCreateInfo.
+ */
+using DeviceCreatePatchPtr = void (*)(Instance& instance,
+                                      VkPhysicalDevice physicalDevice,
+                                      vku::safe_VkDeviceCreateInfo& createInfo,
+                                      std::vector<std::string>& supported);
 
 /**
  * @brief This class implements the layer state tracker for a single device.
@@ -164,9 +175,9 @@ class Device
     DeviceDispatchTable driver {};
 
     /**
-     * @brief The minimum set of device extensions needed by this layer.
+     * @brief The set of VkCreateDeviceInfo patches needed by this layer.
      */
-    static const std::vector<std::string> extraExtensions;
+    static const std::vector<DeviceCreatePatchPtr> createInfoPatches;
 
 private:
     /**

source_common/framework/manual_functions.cpp

@@ -29,7 +29,6 @@
  * implemented as library code which can be swapped for alternative
  * implementations on a per-layer basis if needed.
  */
-#include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 
 #include "framework/manual_functions.hpp"
@@ -370,22 +369,15 @@ static void enableInstanceVkExtDebugUtils(vku::safe_VkInstanceCreateInfo& create
     }
 }
 
-/**
- * Enable VK_KHR_timeline_semaphore if not enabled.
- *
- * Enabling this requires passing the extension string to vkCreateDevice(),
- * and passing either VkPhysicalDeviceTimelineSemaphoreFeatures or
- * VkPhysicalDeviceVulkan12Features with the feature enabled.
- *
- * If the user has the extension enabled but the feature disabled we patch
- * their existing structures to enable it.
- *
- * @param createInfo   The createInfo we can search to find user config.
- * @param supported    The list of supported extensions.
- */
-static void enableDeviceVkKhrTimelineSemaphore(vku::safe_VkDeviceCreateInfo& createInfo,
-                                               const std::vector<std::string>& supported)
+/* See header for documentation. */
+void enableDeviceVkKhrTimelineSemaphore(Instance& instance,
+                                        VkPhysicalDevice physicalDevice,
+                                        vku::safe_VkDeviceCreateInfo& createInfo,
+                                        std::vector<std::string>& supported)
 {
+    UNUSED(instance);
+    UNUSED(physicalDevice);
+
     static const std::string target {VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME};
 
     // We know we can const-cast here because createInfo is a safe-struct clone
@@ -445,21 +437,15 @@ static void enableDeviceVkKhrTimelineSemaphore(vku::safe_VkDeviceCreateInfo& cre
     }
 }
 
-/**
- * Enable VK_EXT_image_compression_control if not enabled.
- *
- * Enabling this requires passing the extension string to vkCreateDevice(),
- * and passing VkPhysicalDeviceImageCompressionControlFeaturesEXT.
- *
- * If the user has the extension enabled but the feature disabled we patch
- * their existing structures to enable it.
- *
- * @param createInfo   The createInfo we can search to find user config.
- * @param supported    The list of supported extensions.
- */
-static void enableDeviceVkExtImageCompressionControl(vku::safe_VkDeviceCreateInfo& createInfo,
-                                                     std::vector<std::string>& supported)
+/* See header for documentation. */
+void enableDeviceVkExtImageCompressionControl(Instance& instance,
+                                              VkPhysicalDevice physicalDevice,
+                                              vku::safe_VkDeviceCreateInfo& createInfo,
+                                              std::vector<std::string>& supported)
 {
+    UNUSED(instance);
+    UNUSED(physicalDevice);
+
     static const std::string target {VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME};
 
     // We know we can const-cast here because createInfo is a safe-struct clone
@@ -792,32 +778,19 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkCreateDevice_default(VkPhysicalDevice phy
     vku::safe_VkDeviceCreateInfo newCreateInfoSafe(pCreateInfo);
     auto* newCreateInfo = reinterpret_cast<VkDeviceCreateInfo*>(&newCreateInfoSafe);
 
-    // Enable extra extensions
-    for (const auto& newExt : Device::extraExtensions)
+    // Apply all required patches to the VkDeviceCreateInfo
+    for (const auto patch : Device::createInfoPatches)
     {
-        if (newExt == VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)
-        {
-
-            enableDeviceVkKhrTimelineSemaphore(newCreateInfoSafe,
-                                               supportedExtensions);
-        }
-        else if (newExt == VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME)
-        {
-            enableDeviceVkExtImageCompressionControl(newCreateInfoSafe,
-                                                     supportedExtensions);
-        }
-        else
-        {
-            LAYER_ERR("Unknown instance extension: %s", newExt.c_str());
-        }
+        patch(*layer, physicalDevice, newCreateInfoSafe, supportedExtensions);
     }
 
-    // Log extensions for debug purposes
+    // Log extensions after patching for debug purposes
     for (uint32_t i = 0; i < newCreateInfo->enabledExtensionCount; i++)
     {
         LAYER_LOG("Requested device extension list: [%u] = %s", i, newCreateInfo->ppEnabledExtensionNames[i]);
     }
 
+    // TODO: Issue #123: Why can't we just use layer.driver.vkGetInstanceProcAddr?
     auto fpCreateDeviceRaw = fpGetInstanceProcAddr(layer->instance, "vkCreateDevice");
     auto fpCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(fpCreateDeviceRaw);
     if (!fpCreateDevice)

source_common/framework/manual_functions.hpp

@@ -29,7 +29,9 @@
  * implemented as library code which can be swapped for alternative
  * implementations on a per-layer basis if needed.
  */
-#include "device.hpp"
+#include <vulkan/utility/vk_safe_struct.hpp>
+
+ #include "device.hpp"
 #include "framework/device_dispatch_table.hpp"
 #include "framework/device_functions.hpp"
 #include "framework/instance_functions.hpp"
@@ -181,3 +183,42 @@ std::vector<std::string> getDeviceExtensionList(VkInstance instance,
  * @return the cloned list.
  */
 std::vector<const char*> cloneExtensionList(uint32_t extensionCount, const char* const* extensionList);
+
+/**
+ * Enable VK_KHR_timeline_semaphore if not enabled.
+ *
+ * Enabling this requires passing the extension string to vkCreateDevice(),
+ * and passing either VkPhysicalDeviceTimelineSemaphoreFeatures or
+ * VkPhysicalDeviceVulkan12Features with the feature enabled.
+ *
+ * If the user has the extension enabled but the feature disabled we patch
+ * their existing structures to enable it.
+ *
+ * @param instance         The layer instance we are running within.
+ * @param physicalDevice   The physical device we are creating a device for.
+ * @param createInfo       The createInfo we can search to find user config.
+ * @param supported        The list of supported extensions.
+ */
+void enableDeviceVkKhrTimelineSemaphore(Instance& instance,
+                                        VkPhysicalDevice physicalDevice,
+                                        vku::safe_VkDeviceCreateInfo& createInfo,
+                                        std::vector<std::string>& supported);
+
+/**
+ * Enable VK_EXT_image_compression_control if not enabled.
+ *
+ * Enabling this requires passing the extension string to vkCreateDevice(),
+ * and passing VkPhysicalDeviceImageCompressionControlFeaturesEXT.
+ *
+ * If the user has the extension enabled but the feature disabled we patch
+ * their existing structures to enable it.
+ *
+ * @param instance         The layer instance we are running within.
+ * @param physicalDevice   The physical device we are creating a device for.
+ * @param createInfo       The createInfo we can search to find user config.
+ * @param supported        The list of supported extensions.
+ */
+void enableDeviceVkExtImageCompressionControl(Instance& instance,
+                                              VkPhysicalDevice physicalDevice,
+                                              vku::safe_VkDeviceCreateInfo& createInfo,
+                                              std::vector<std::string>& supported);