layers: Add layer settings library

Author: christophe-lunarg

CMakeLists.txt

@@ -66,6 +66,8 @@ else()
  endif()
 endif()
 
+find_package(VulkanUtilityLibraries CONFIG REQUIRED)
+
 option(BUILD_WERROR "Treat compiler warnings as errors")
 if (BUILD_WERROR)
  add_compile_options("$<IF:$<CXX_COMPILER_ID:MSVC>,/WX,-Werror>")

layers/CMakeLists.txt

@@ -47,7 +47,7 @@ endif()
 foreach(extension_layer ${EXTENSION_LAYERS})
  target_include_directories(${extension_layer} PRIVATE .)
 
- target_link_libraries(${extension_layer} PRIVATE VkExtLayer_utils)
+ target_link_libraries(${extension_layer} PRIVATE VkExtLayer_utils Vulkan::LayerSettings)
 
  if(MSVC)
  target_link_options(${extension_layer} PRIVATE /DEF:${CMAKE_CURRENT_SOURCE_DIR}/${extension_layer}.def)

layers/VkLayer_khronos_synchronization2.def

@@ -1,9 +1,9 @@
 
 ;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
-; Copyright (c) 2015-2021 The Khronos Group Inc.
-; Copyright (c) 2015-2021 Valve Corporation
-; Copyright (c) 2015-2021 LunarG, Inc.
+; Copyright (c) 2015-2023 The Khronos Group Inc.
+; Copyright (c) 2015-2023 Valve Corporation
+; Copyright (c) 2015-2023 LunarG, Inc.
 ; Copyright (c) 2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");

layers/VkLayer_khronos_timeline_semaphore.def

@@ -1,9 +1,9 @@
 
 ;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
-; Copyright (c) 2015-2019, 2021 The Khronos Group Inc.
-; Copyright (c) 2015-2019, 2021 Valve Corporation
-; Copyright (c) 2015-2019, 2021 LunarG, Inc.
+; Copyright (c) 2015-2023 The Khronos Group Inc.
+; Copyright (c) 2015-2023 Valve Corporation
+; Copyright (c) 2015-2023 LunarG, Inc.
 ; Copyright (c) 2020 Intel Corporation
 ;
 ; Licensed under the Apache License, Version 2.0 (the "License");

layers/decompression/decompression.cpp

@@ -28,9 +28,9 @@ static bool logging_enabled = false;
  }
 
 #include <vulkan/vk_layer.h>
+#include <vulkan/layer/vk_layer_settings.hpp>
 #include "allocator.h"
 #include "log.h"
-#include "vk_layer_config.h"
 #include "vk_safe_struct.h"
 #include "vk_util.h"
 #include "decompression.h"
@@ -115,6 +115,10 @@ static const ByteCode kIndirectGInflateBytecode[] = {
  {(const uint8_t*)kIndirectGInflate64_HAVE_INT16_HAVE_INT64, sizeof(kIndirectGInflate64_HAVE_INT16_HAVE_INT64)},
 };
 
+#define kLayerSettingsForceEnable "force_device"
+#define kLayerSettingsCustomSTypeInfo "custom_stype_list"
+#define kLayerSettingsLogging "logging"
+
 // required by vk_safe_struct
 std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info{};
 
@@ -130,65 +134,9 @@ static const VkLayerProperties kGlobalLayer = {
 static const VkExtensionProperties kDeviceExtension = {VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME,
  VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION};
 
-static const char* const kEnvarForceEnable =
-#if defined(__ANDROID__)
- "debug.vulkan.memory_decompression.force_enable";
-#else
- "VK_MEMORY_DECOMPRESSION_FORCE_ENABLE";
-#endif
-static const char* const kLayerSettingsForceEnable = "khronos_memory_decompression.force_enable";
-
-static const char* const kEnvarLogging =
-#if defined(__ANDROID__)
- "debug.vulkan.memory_decompression.logging";
-#else
- "VK_MEMORY_DECOMPRESSION_LOGGING";
-#endif
-static const char* const kLayerSettingsLogging = "khronos_memory_decompression.logging";
-
 static vl_concurrent_unordered_map<uintptr_t, std::shared_ptr<InstanceData>> instance_data_map;
 static vl_concurrent_unordered_map<uintptr_t, std::shared_ptr<DeviceData>> device_data_map;
 
-static void string_tolower(std::string& s) {
- for (auto& c : s) {
- c = tolower(c);
- }
-}
-
-static bool GetForceEnable() {
- bool result = false;
- std::string setting = GetEnvironment(kEnvarForceEnable);
- if (setting.empty()) {
- setting = GetLayerOption(kLayerSettingsForceEnable);
- }
- if (!setting.empty()) {
- string_tolower(setting);
- if (setting == "true") {
- result = true;
- } else {
- result = std::atoi(setting.c_str()) != 0;
- }
- }
- return result;
-}
-
-static bool GetLoggingEnabled() {
- bool result = false;
- std::string setting = GetEnvironment(kEnvarLogging);
- if (setting.empty()) {
- setting = GetLayerOption(kLayerSettingsLogging);
- }
- if (!setting.empty()) {
- string_tolower(setting);
- if (setting == "true") {
- result = true;
- } else {
- result = std::atoi(setting.c_str()) != 0;
- }
- }
- return result;
-}
-
 uintptr_t DispatchKey(const void* object) {
  auto tmp = reinterpret_cast<const struct VkLayerDispatchTable_* const*>(object);
  return reinterpret_cast<uintptr_t>(*tmp);
@@ -274,7 +222,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalD
 
 #define INIT_HOOK(_vt, _inst, fn) _vt.fn = reinterpret_cast<PFN_vk##fn>(vtable.GetInstanceProcAddr(_inst, "vk" #fn))
 InstanceData::InstanceData(VkInstance inst, PFN_vkGetInstanceProcAddr gpa, const VkAllocationCallbacks* alloc)
- : instance(inst), api_version(0), force_enable(false), allocator(alloc) {
+ : instance(inst), api_version(0), allocator(alloc) {
  vtable.GetInstanceProcAddr = gpa;
  INIT_HOOK(vtable, instance, CreateInstance);
  INIT_HOOK(vtable, instance, DestroyInstance);
@@ -297,18 +245,25 @@ static VkLayerInstanceCreateInfo* GetChainInfo(const VkInstanceCreateInfo* pCrea
  return chain_info;
 }
 
-// Get all elements from a vkEnumerate*() lambda into a std::vector.
-template <typename T>
-VkResult EnumerateAll(std::vector<T>* vect, std::function<VkResult(uint32_t*, T*)> func) {
- VkResult result = VK_INCOMPLETE;
- do {
- uint32_t count = 0;
- result = func(&count, nullptr);
- ASSERT(result == VK_SUCCESS);
- vect->resize(count);
- result = func(&count, vect->data());
- } while (result == VK_INCOMPLETE);
- return result;
+void InitLayerSettings(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, LayerSettings* layer_settings) {
+ assert(layer_settings != nullptr);
+
+ VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+ vlCreateLayerSettingSet(kGlobalLayer.layerName, vlFindLayerSettingsCreateInfo(pCreateInfo), pAllocator, nullptr, &layerSettingSet);
+
+ if (vlHasLayerSetting(layerSettingSet, kLayerSettingsForceEnable)) {
+ vlGetLayerSettingValue(layerSettingSet, kLayerSettingsForceEnable, layer_settings->force_enable);
+ }
+
+ if (vlHasLayerSetting(layerSettingSet, kLayerSettingsLogging)) {
+ vlGetLayerSettingValue(layerSettingSet, kLayerSettingsLogging, layer_settings->logging);
+ }
+
+ if (vlHasLayerSetting(layerSettingSet, kLayerSettingsCustomSTypeInfo)) {
+ vlGetLayerSettingValues(layerSettingSet, kLayerSettingsCustomSTypeInfo, custom_stype_info);
+ }
+
+ vlDestroyLayerSettingSet(layerSettingSet, pAllocator);
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
@@ -322,8 +277,6 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreat
  return VK_ERROR_INITIALIZATION_FAILED;
  }
 
- logging_enabled = GetLoggingEnabled();
-
  // Advance the link info for the next element on the chain
  chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
 
@@ -337,8 +290,10 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreat
 
  instance_data_map.insert(DispatchKey(*pInstance), instance_data);
 
- instance_data->force_enable = GetForceEnable();
  instance_data->api_version = pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : 0;
+
+ InitLayerSettings(pCreateInfo, pAllocator, &instance_data->layer_settings);
+ logging_enabled = instance_data->layer_settings.logging;
  } catch (const std::bad_alloc&) {
  auto destroy_instance = reinterpret_cast<PFN_vkDestroyInstance>(gpa(NULL, "vkDestroyInstance"));
  destroy_instance(*pInstance, pAllocator);
@@ -749,7 +704,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, con
  PRINT("Memory decompression feature not available in the driver, enabling decompression layer.\n");
  enable_layer = true;
  } else {
- if (instance_data->force_enable) {
+ if (instance_data->layer_settings.force_enable) {
  PRINT("Memory decompression feature available in the driver, but force enabling decompression layer.\n");
  enable_layer = true;
  } else {

layers/decompression/decompression.h

@@ -36,6 +36,11 @@ enum class SynchronizationScope { kFirst, kSecond };
 struct DeviceData;
 struct DeviceFeatures;
 
+struct LayerSettings {
+ bool force_enable{false};
+ bool logging{false};
+};
+
 template <typename T>
 using CmdVector = std::vector<T, extension_layer::CmdAlloc<T>>;
 
@@ -74,7 +79,7 @@ struct InstanceData {
 
  VkInstance instance;
  uint32_t api_version;
- bool force_enable;
+ LayerSettings layer_settings;
  const VkAllocationCallbacks* allocator;
  struct InstanceDispatchTable {
  DECLARE_HOOK(GetInstanceProcAddr);

layers/shader_object.cpp

@@ -32,11 +32,14 @@
 
 #include <vulkan/vulkan.h>
 #include <vulkan/vk_layer.h>
+#include <vulkan/layer/vk_layer_settings.hpp>
 
 #include "log.h"
 #include "vk_safe_struct.h"
 #include "vk_api_hash.h"
-#include "vk_layer_config.h"
+
+#define kLayerSettingsForceEnable "force_enable"
+#define kLayerSettingsCustomSTypeInfo "custom_stype_list"
 
 // Required by vk_safe_struct
 std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info{};
@@ -80,37 +83,6 @@ namespace shader_object {
 static const char* kLayerName = "VK_LAYER_KHRONOS_shader_object";
 static const VkExtensionProperties kExtensionProperties = {VK_EXT_SHADER_OBJECT_EXTENSION_NAME, VK_EXT_SHADER_OBJECT_SPEC_VERSION};
 
-static const char* const kEnvarForceEnable =
-#if defined(__ANDROID__)
- "debug.vulkan.shader_object.force_enable";
-#else
- "VK_SHADER_OBJECT_FORCE_ENABLE";
-#endif
-static const char* const kLayerSettingsForceEnable = "khronos_shader_object.force_enable";
-
-static void string_tolower(std::string &s) {
- for (auto& c: s) {
- c = tolower(c);
- }
-}
-
-static bool GetForceEnable() {
- bool result = false;
- std::string setting = GetEnvironment(kEnvarForceEnable);
- if (setting.empty()) {
- setting = GetLayerOption(kLayerSettingsForceEnable);
- }
- if (!setting.empty()) {
- string_tolower(setting);
- if (setting == "true") {
- result = true;
- } else {
- result = std::atoi(setting.c_str()) != 0;
- }
- }
- return result;
-}
-
 class AlignedMemory {
  public:
  AlignedMemory() : size_(0), max_alignment_(1), memory_write_ptr_(nullptr) {}
@@ -1219,11 +1191,16 @@ class CommandBufferData {
  FullDrawStateData* draw_state_data_;
 };
 
+struct LayerSettings {
+ bool force_enable{false};
+};
+
 struct InstanceData {
  LayerDispatchInstance vtable;
  VkInstance instance;
  VkPhysicalDevice* physical_devices;
  uint32_t physical_device_count;
+ LayerSettings layer_settings;
 };
 
 struct PhysicalDeviceData {
@@ -2610,6 +2587,24 @@ static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance i
 
 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName);
 
+void InitLayerSettings(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, LayerSettings* layer_settings) {
+ assert(layer_settings != nullptr);
+
+ VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+ const VkLayerSettingsCreateInfoEXT *pLayerSettingsCreateInfo = vlFindLayerSettingsCreateInfo(pCreateInfo);
+ vlCreateLayerSettingSet(kLayerName, pLayerSettingsCreateInfo, pAllocator, nullptr, &layerSettingSet);
+
+ if (vlHasLayerSetting(layerSettingSet, kLayerSettingsForceEnable)) {
+ vlGetLayerSettingValue(layerSettingSet, kLayerSettingsForceEnable, layer_settings->force_enable);
+ }
+
+ if (vlHasLayerSetting(layerSettingSet, kLayerSettingsCustomSTypeInfo)) {
+ vlGetLayerSettingValues(layerSettingSet, kLayerSettingsCustomSTypeInfo, custom_stype_info);
+ }
+
+ vlDestroyLayerSettingSet(layerSettingSet, pAllocator);
+}
+
 static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
  const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
  auto allocator = pAllocator ? *pAllocator : kDefaultAllocator;
@@ -2653,6 +2648,8 @@ static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo*
  instance_data->physical_device_count = physical_device_count;
  instance_data->vtable.Initialize(*pInstance, fpGetInstanceProcAddr);
 
+ InitLayerSettings(pCreateInfo, pAllocator, &instance_data->layer_settings);
+
  result = fpEnumeratePhysicalDevices(*pInstance, &instance_data->physical_device_count, instance_data->physical_devices);
  ASSERT(result == VK_SUCCESS);
 
@@ -2917,7 +2914,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevi
  // only enable the layer if the application asked for the extension and feature AND the driver does not have a native
  // implementation (unless if the user specified to ignore the native implementation via environment variable)
  bool enable_layer = shader_object_feature_requested && shader_object_extension_requested;
- bool ignore_native_implementation = GetForceEnable();
+ bool ignore_native_implementation = instance_data->layer_settings.force_enable;
  if (ignore_native_implementation) {
  DEBUG_LOG("ignoring native driver implementation of shader object\n");
  }