Support layer: Add robustBufferAccess overrides

Author: solidpixel

layer_gpu_support/layer_config.json

@@ -1,5 +1,9 @@
 {
     "layer": "VK_LAYER_LGL_gpu_support",
+    "feature": {
+        "robustBufferAccess_enable": false,
+        "robustBufferAccess_disable": false
+    },
     "serialize": {
         "all": false,
         "none": false,

layer_gpu_support/source/device.cpp

@@ -35,10 +35,17 @@
  */
 static std::unordered_map<void*, std::unique_ptr<Device>> g_devices;
 
+/* Predeclare custom DeviceCreatePatch functions */
+static void modifyDeviceRobustBufferAccess(Instance& instance,
+                                           VkPhysicalDevice physicalDevice,
+                                           vku::safe_VkDeviceCreateInfo& createInfo,
+                                           std::vector<std::string>& supported);
+
 /* See header for documentation. */
 const std::vector<DeviceCreatePatchPtr> Device::createInfoPatches {
     enableDeviceVkKhrTimelineSemaphore,
-    enableDeviceVkExtImageCompressionControl
+    enableDeviceVkExtImageCompressionControl,
+    modifyDeviceRobustBufferAccess
 };
 
 /* See header for documentation. */
@@ -112,3 +119,95 @@ Device::Device(Instance* _instance,
         queueSerializationTimelineSem = nullptr;
     }
 }
+
+/**
+ * Allow a force enable/disable of robustBufferAccess feature.
+ *
+ * @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.
+ */
+static void modifyDeviceRobustBufferAccess(Instance& instance,
+                                           VkPhysicalDevice physicalDevice,
+                                           vku::safe_VkDeviceCreateInfo& createInfo,
+                                           std::vector<std::string>& supported)
+{
+    UNUSED(supported);
+
+    // Only one of these can be set as an override
+    // If neither are set then don't change the app settings
+    bool enableRobustness = instance.config.feature_enable_robustBufferAccess();
+    bool disableRobustness = instance.config.feature_disable_robustBufferAccess();
+
+    // No patch to apply
+    if (!enableRobustness && !disableRobustness)
+    {
+        return;
+    }
+
+    // Query if robustness is supported if we need to force enable
+    VkPhysicalDeviceFeatures supportedFeatures;
+    instance.driver.vkGetPhysicalDeviceFeatures(physicalDevice, &supportedFeatures);
+    if (enableRobustness && !supportedFeatures.robustBufferAccess)
+    {
+        LAYER_LOG("Device feature not available: robustBufferAccess");
+        return;
+    }
+
+    // We know we can const_cast here because createInfo is a safe-struct clone
+    // Option1 = legacy-style enable
+    auto* config = const_cast<VkPhysicalDeviceFeatures*>(createInfo.pEnabledFeatures);
+
+    // Option2 = modern-style enable
+    void* pNextBase = const_cast<void*>(createInfo.pNext);
+    auto* configNext = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(pNextBase);
+
+    // Pick the feature struct from either of the valid options
+    if (!config && configNext)
+    {
+        config = &configNext->features;
+    }
+
+    // User provided feature enable struct, so just change that directly
+    if (config)
+    {
+        if (enableRobustness)
+        {
+            if(config->robustBufferAccess)
+            {
+                LAYER_LOG("Device feature already enabled: robustBufferAccess");
+            }
+            else
+            {
+                LAYER_LOG("Device feature enabled: robustBufferAccess");
+                config->robustBufferAccess = VK_TRUE;
+            }
+        }
+        if (disableRobustness)
+        {
+            if(!config->robustBufferAccess)
+            {
+                LAYER_LOG("Device feature already disabled: robustBufferAccess");
+            }
+
+            LAYER_LOG("Device feature disabled: robustBufferAccess");
+            config->robustBufferAccess = VK_FALSE;
+        }
+    }
+    // User provided no feature enables, so provide our own structure
+    else if (enableRobustness)
+    {
+        LAYER_LOG("Device feature enabled: robustBufferAccess");
+
+        // Create a dynamic copy and transfer ownership to the safe-struct
+        auto* newFeatures = new VkPhysicalDeviceFeatures;
+        memset(newFeatures, 0, sizeof(VkPhysicalDeviceFeatures));
+        createInfo.pEnabledFeatures = newFeatures;
+    }
+    // User provided no feature enables, but we don't need one
+    else if (disableRobustness)
+    {
+        LAYER_LOG("Device feature already disabled: robustBufferAccess");
+    }
+}

layer_gpu_support/source/device.hpp

@@ -54,14 +54,13 @@
 
 #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.
  */

layer_gpu_support/source/layer_config.cpp

@@ -37,6 +37,37 @@
 
 #include <vulkan/vulkan.h>
 
+/* See header for documentation. */
+void LayerConfig::parse_feature_options(const json& config)
+{
+    // Decode serialization state
+    json feature = config.at("feature");
+
+    bool enable_rba = feature.at("robustBufferAccess_enable");
+    bool disable_rba = feature.at("robustBufferAccess_disable");
+
+    const char* rba_state = "default";
+    if (enable_rba)
+    {
+        rba_state = "enabled";
+        // Ensure we only set one option
+        disable_rba = false;
+    }
+    else if (disable_rba)
+    {
+        rba_state = "disabled";
+    }
+
+    // Write after all options read from JSON so we know it parsed correctly
+    conf_feat_robustBufferAccess_enable = enable_rba;
+    conf_feat_robustBufferAccess_disable = disable_rba;
+
+    LAYER_LOG("Layer feature configuration");
+    LAYER_LOG("===========================");
+    LAYER_LOG(" - Robust buffer access: %s", rba_state);
+}
+
+
 /* See header for documentation. */
 void LayerConfig::parse_serialization_options(const json& config)
 {
@@ -238,6 +269,17 @@ LayerConfig::LayerConfig()
         return;
     }
 
+    try
+    {
+        parse_feature_options(data);
+    }
+    catch (const json::out_of_range& e)
+    {
+        LAYER_ERR("Failed to read feature config, using defaults");
+        LAYER_ERR("Error: %s", e.what());
+    }
+
+
     try
     {
         parse_serialization_options(data);
@@ -269,6 +311,18 @@ LayerConfig::LayerConfig()
     }
 }
 
+/* See header for documentation. */
+bool LayerConfig::feature_enable_robustBufferAccess() const
+{
+    return conf_feat_robustBufferAccess_enable;
+}
+
+/* See header for documentation. */
+bool LayerConfig::feature_disable_robustBufferAccess() const
+{
+    return conf_feat_robustBufferAccess_disable;
+}
+
 /* See header for documentation. */
 bool LayerConfig::serialize_queue() const
 {

layer_gpu_support/source/layer_config.hpp

@@ -49,6 +49,18 @@ class LayerConfig
      */
     LayerConfig();
 
+    // Config queries for features
+
+    /**
+     * @brief True if config wants to serialize across queue submits.
+     */
+    bool feature_enable_robustBufferAccess() const;
+
+    /**
+     * @brief True if config wants to serialize queue submits with the CPU.
+     */
+    bool feature_disable_robustBufferAccess() const;
+
     // Config queries for serializer
 
     /**
@@ -154,6 +166,15 @@ class LayerConfig
     uint32_t framebuffer_force_fixed_rate_compression() const;
 
 private:
+    /**
+     * @brief Parse the configuration options for the feature module.
+     *
+     * @param config   The JSON configuration.
+     *
+     * @throws json::out_of_bounds if required fields are missing.
+     */
+    void parse_feature_options(const json& config);
+
     /**
      * @brief Parse the configuration options for the serializer.
      *
@@ -182,6 +203,16 @@ class LayerConfig
     void parse_framebuffer_options(const json& config);
 
 private:
+    /**
+     * @brief True if we force enable robustBufferAccess.
+     */
+    bool conf_feat_robustBufferAccess_enable {false};
+
+    /**
+     * @brief True if we force disable robustBufferAccess.
+     */
+    bool conf_feat_robustBufferAccess_disable {false};
+
     /**
      * @brief True if we force serialize all queue submits.
      */