Hello community, here is the log from the commit of package vulkan-loader for openSUSE:Factory checked in at 2020-06-04 17:51:32 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/vulkan-loader (Old) and /work/SRC/openSUSE:Factory/.vulkan-loader.new.3606 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "vulkan-loader" Thu Jun 4 17:51:32 2020 rev:22 rq:810821 version:1.2.141 Changes: -------- --- /work/SRC/openSUSE:Factory/vulkan-loader/vulkan-loader.changes 2020-04-25 20:10:02.183759541 +0200 +++ /work/SRC/openSUSE:Factory/.vulkan-loader.new.3606/vulkan-loader.changes 2020-06-04 17:51:54.972166809 +0200 @@ -1,0 +2,6 @@ +Thu May 28 13:31:34 UTC 2020 - Jan Engelhardt <[email protected]> + +- Update to release 1.2.141 + * loader: Preload ICDs to speed up common path + +------------------------------------------------------------------- Old: ---- v1.2.137.tar.gz New: ---- v1.2.141.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ vulkan-loader.spec ++++++ --- /var/tmp/diff_new_pack.ye9EME/_old 2020-06-04 17:51:56.104170411 +0200 +++ /var/tmp/diff_new_pack.ye9EME/_new 2020-06-04 17:51:56.108170425 +0200 @@ -18,7 +18,7 @@ %define lname libvulkan1 Name: vulkan-loader -Version: 1.2.137 +Version: 1.2.141 Release: 0 Summary: Reference ICD loader for Vulkan License: Apache-2.0 ++++++ v1.2.137.tar.gz -> v1.2.141.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/.appveyor.yml new/Vulkan-Loader-1.2.141/.appveyor.yml --- old/Vulkan-Loader-1.2.137/.appveyor.yml 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/.appveyor.yml 2020-05-26 18:50:54.000000000 +0200 @@ -14,9 +14,6 @@ os: - Visual Studio 2015 -init: - - git config --global core.autocrlf true - environment: PYTHON_PATH: "C:/Python35" PYTHON_PACKAGE_PATH: "C:/Python35/Scripts" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/.gitattributes new/Vulkan-Loader-1.2.141/.gitattributes --- old/Vulkan-Loader-1.2.137/.gitattributes 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/.gitattributes 2020-05-26 18:50:54.000000000 +0200 @@ -5,6 +5,7 @@ * text=auto # Files to be converted to native line endings on checkout. +*.c text *.cpp text *.h text @@ -14,3 +15,6 @@ # Text files to always have LF (unix) line endings on checkout. *.sh text eol=lf +# Generated source files will always have LF (unix) line endings on checkout. +loader/generated/*.c text eol=lf +loader/generated/*.h text eol=lf diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/BUILD.gn new/Vulkan-Loader-1.2.141/BUILD.gn --- old/Vulkan-Loader-1.2.137/BUILD.gn 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/BUILD.gn 2020-05-26 18:50:54.000000000 +0200 @@ -53,7 +53,7 @@ ] defines = [ "API_NAME=\"Vulkan\"", - "USE_UNSAFE_FILE_SEARCH=1" + "USE_UNSAFE_FILE_SEARCH=1", ] if (is_win) { @@ -112,28 +112,37 @@ "/wd4100", # Unreferenced formal parameter "/wd4152", # Nonstandard extension used (pointer conversion) "/wd4201", # Nonstandard extension used: nameless struct/union - "/wd4214", # Nonstandard extension used: bit field types other than int - "/wd4232", # Nonstandard extension used: address of dllimport is not static + "/wd4214", # Nonstandard extension used: bit field types other than + # int + "/wd4232", # Nonstandard extension used: address of dllimport is not + # static "/wd4305", # Type cast truncation "/wd4706", # Assignment within conditional expression "/wd4996", # Unsafe stdlib function ] } if (is_clang) { - cflags = [ "-Wno-incompatible-pointer-types" ] + cflags = [ "-Wno-incompatible-pointer-types" ] } libs = [ "Cfgmgr32.lib" ] } if (is_mac) { libs = [ "CoreFoundation.framework" ] } - public_deps = [ - "$vulkan_headers_dir:vulkan_headers", - ] + public_deps = [ "$vulkan_headers_dir:vulkan_headers" ] configs -= [ "//build/config/compiler:chromium_code" ] configs += [ "//build/config/compiler:no_chromium_code" ] configs += [ ":vulkan_internal_config" ] public_configs = [ ":vulkan_loader_config" ] configs -= vulkan_undefine_configs } + + if (is_linux && vulkan_loader_shared) { + copy("libvulkan-abi1") { + sources = [ "${root_out_dir}/libvulkan.so" ] + outputs = [ "${root_out_dir}/libvulkan.so.1" ] + + deps = [ ":libvulkan" ] + } + } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/CMakeLists.txt new/Vulkan-Loader-1.2.141/CMakeLists.txt --- old/Vulkan-Loader-1.2.137/CMakeLists.txt 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/CMakeLists.txt 2020-05-26 18:50:54.000000000 +0200 @@ -47,9 +47,6 @@ "or tested as part of the loader. Use it at your own risk.") endif() -# Add the externals directory early so we pickup the headers if they're present -add_subdirectory(external) - if (TARGET Vulkan::Headers) message(STATUS "Using Vulkan headers from Vulkan::Headers target") get_target_property(VulkanHeaders_INCLUDE_DIRS Vulkan::Headers INTERFACE_INCLUDE_DIRECTORIES) @@ -229,6 +226,7 @@ add_subdirectory(loader) endif() +add_subdirectory(external) if(BUILD_TESTS) add_subdirectory(tests) endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/cmake/FindVulkanHeaders.cmake new/Vulkan-Loader-1.2.141/cmake/FindVulkanHeaders.cmake --- old/Vulkan-Loader-1.2.137/cmake/FindVulkanHeaders.cmake 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/cmake/FindVulkanHeaders.cmake 2020-05-26 18:50:54.000000000 +0200 @@ -74,7 +74,7 @@ else() # If VULKAN_HEADERS_INSTALL_DIR, or one of its variants was not specified, # do a normal search without hints. - find_path(VulkanHeaders_INCLUDE_DIR NAMES vulkan/vulkan.h) + find_path(VulkanHeaders_INCLUDE_DIR NAMES vulkan/vulkan.h HINTS "${CMAKE_CURRENT_SOURCE_DIR}/external/Vulkan-Headers/include") get_filename_component(VULKAN_REGISTRY_PATH_HINT ${VulkanHeaders_INCLUDE_DIR} DIRECTORY) find_path(VulkanRegistry_DIR NAMES vk.xml HINTS ${VULKAN_REGISTRY_PATH_HINT}/share/vulkan/registry "${VULKAN_REGISTRY_PATH_HINT}/registry") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/external/CMakeLists.txt new/Vulkan-Loader-1.2.141/external/CMakeLists.txt --- old/Vulkan-Loader-1.2.137/external/CMakeLists.txt 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/external/CMakeLists.txt 2020-05-26 18:50:54.000000000 +0200 @@ -37,7 +37,3 @@ "Provide Google Test in external/googletest or set BUILD_TESTS=OFF") endif() endif() - -if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers") - add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers") -endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/CMakeLists.txt new/Vulkan-Loader-1.2.141/loader/CMakeLists.txt --- old/Vulkan-Loader-1.2.137/loader/CMakeLists.txt 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/CMakeLists.txt 2020-05-26 18:50:54.000000000 +0200 @@ -170,6 +170,7 @@ target_link_libraries(asm_offset Vulkan::Headers) add_custom_command(OUTPUT gen_defines.asm DEPENDS asm_offset COMMAND asm_offset GAS) add_custom_target(loader_asm_gen_files DEPENDS gen_defines.asm) + target_compile_definitions(asm_offset PRIVATE _XOPEN_SOURCE=500) # hush compiler warnings for readlink else() message(WARNING "Could not find working x86 GAS assembler\n${ASM_FAILURE_MSG}") set(OPT_LOADER_SRCS ${OPT_LOADER_SRCS} unknown_ext_chain.c) @@ -235,7 +236,6 @@ "${VulkanHeaders_VERSION_MAJOR}.${VulkanHeaders_VERSION_MINOR}.${VulkanHeaders_VERSION_PATCH}") target_link_libraries(vulkan ${CMAKE_DL_LIBS} pthread m) target_link_libraries(vulkan Vulkan::Headers) - if(APPLE) find_library(COREFOUNDATION_LIBRARY NAMES CoreFoundation) target_link_libraries(vulkan "-framework CoreFoundation") @@ -290,6 +290,8 @@ endif() if(NOT APPLE) + target_compile_definitions(vulkan PRIVATE _XOPEN_SOURCE=500) # hush compiler warnings for readlink + # Generate pkg-config file. include(FindPkgConfig QUIET) if(PKG_CONFIG_FOUND) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/LoaderAndLayerInterface.md new/Vulkan-Loader-1.2.141/loader/LoaderAndLayerInterface.md --- old/Vulkan-Loader-1.2.137/loader/LoaderAndLayerInterface.md 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/LoaderAndLayerInterface.md 2020-05-26 18:50:54.000000000 +0200 @@ -2009,7 +2009,7 @@ * [ICD Manifest File Format](#icd-manifest-file-format) * [ICD Manifest File Versions](#icd-manifest-file-versions) * [ICD Manifest File Version 1.0.0](#icd-manifest-file-version-1.0.0) - * [ICD Vulkan Entry Point Discovery](#icd-vulkan-entry point-discovery) + * [ICD Vulkan Entry Point Discovery](#icd-vulkan-entry-point-discovery) * [ICD API Version](#icd-api-version) * [ICD Unknown Physical Device Extensions](#icd-unknown-physical-device-extensions) * [ICD Dispatchable Object Creation](#icd-dispatchable-object-creation) @@ -2374,7 +2374,7 @@ will perform the following steps: 1. Check the ICD's JSON manifest file for the "api_version" field. -2. If the JSON version is greater greater than or equal to 1.1, Load the ICD's dynamic library +2. If the JSON version is greater than or equal to 1.1, Load the ICD's dynamic library 3. Call the ICD's `vkGetInstanceProcAddr` command to get a pointer to `vkEnumerateInstanceVersion` 4. If the pointer to `vkEnumerateInstanceVersion` is not `NULL`, it will be diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/generated/vk_dispatch_table_helper.h new/Vulkan-Loader-1.2.141/loader/generated/vk_dispatch_table_helper.h --- old/Vulkan-Loader-1.2.137/loader/generated/vk_dispatch_table_helper.h 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/generated/vk_dispatch_table_helper.h 2020-05-26 18:50:54.000000000 +0200 @@ -210,6 +210,10 @@ static VKAPI_ATTR void VKAPI_CALL StubCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { }; static VKAPI_ATTR VkResult VKAPI_CALL StubCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { return VK_SUCCESS; }; static VKAPI_ATTR void VKAPI_CALL StubDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { }; +static VKAPI_ATTR VkResult VKAPI_CALL StubCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) { return VK_SUCCESS; }; +static VKAPI_ATTR void VKAPI_CALL StubDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator) { }; +static VKAPI_ATTR VkResult VKAPI_CALL StubSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) { return VK_SUCCESS; }; +static VKAPI_ATTR void VKAPI_CALL StubGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) { }; #ifdef VK_ENABLE_BETA_EXTENSIONS static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; }; #endif // VK_ENABLE_BETA_EXTENSIONS @@ -756,6 +760,14 @@ if (table->CreateIndirectCommandsLayoutNV == nullptr) { table->CreateIndirectCommandsLayoutNV = (PFN_vkCreateIndirectCommandsLayoutNV)StubCreateIndirectCommandsLayoutNV; } table->DestroyIndirectCommandsLayoutNV = (PFN_vkDestroyIndirectCommandsLayoutNV) gpa(device, "vkDestroyIndirectCommandsLayoutNV"); if (table->DestroyIndirectCommandsLayoutNV == nullptr) { table->DestroyIndirectCommandsLayoutNV = (PFN_vkDestroyIndirectCommandsLayoutNV)StubDestroyIndirectCommandsLayoutNV; } + table->CreatePrivateDataSlotEXT = (PFN_vkCreatePrivateDataSlotEXT) gpa(device, "vkCreatePrivateDataSlotEXT"); + if (table->CreatePrivateDataSlotEXT == nullptr) { table->CreatePrivateDataSlotEXT = (PFN_vkCreatePrivateDataSlotEXT)StubCreatePrivateDataSlotEXT; } + table->DestroyPrivateDataSlotEXT = (PFN_vkDestroyPrivateDataSlotEXT) gpa(device, "vkDestroyPrivateDataSlotEXT"); + if (table->DestroyPrivateDataSlotEXT == nullptr) { table->DestroyPrivateDataSlotEXT = (PFN_vkDestroyPrivateDataSlotEXT)StubDestroyPrivateDataSlotEXT; } + table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT) gpa(device, "vkSetPrivateDataEXT"); + if (table->SetPrivateDataEXT == nullptr) { table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)StubSetPrivateDataEXT; } + table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT) gpa(device, "vkGetPrivateDataEXT"); + if (table->GetPrivateDataEXT == nullptr) { table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)StubGetPrivateDataEXT; } #ifdef VK_ENABLE_BETA_EXTENSIONS table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR) gpa(device, "vkCreateAccelerationStructureKHR"); if (table->CreateAccelerationStructureKHR == nullptr) { table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)StubCreateAccelerationStructureKHR; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/generated/vk_layer_dispatch_table.h new/Vulkan-Loader-1.2.141/loader/generated/vk_layer_dispatch_table.h --- old/Vulkan-Loader-1.2.137/loader/generated/vk_layer_dispatch_table.h 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/generated/vk_layer_dispatch_table.h 2020-05-26 18:50:54.000000000 +0200 @@ -695,6 +695,12 @@ PFN_vkCreateIndirectCommandsLayoutNV CreateIndirectCommandsLayoutNV; PFN_vkDestroyIndirectCommandsLayoutNV DestroyIndirectCommandsLayoutNV; + // ---- VK_EXT_private_data extension commands + PFN_vkCreatePrivateDataSlotEXT CreatePrivateDataSlotEXT; + PFN_vkDestroyPrivateDataSlotEXT DestroyPrivateDataSlotEXT; + PFN_vkSetPrivateDataEXT SetPrivateDataEXT; + PFN_vkGetPrivateDataEXT GetPrivateDataEXT; + // ---- VK_KHR_ray_tracing extension commands #ifdef VK_ENABLE_BETA_EXTENSIONS PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/generated/vk_loader_extensions.c new/Vulkan-Loader-1.2.141/loader/generated/vk_loader_extensions.c --- old/Vulkan-Loader-1.2.137/loader/generated/vk_loader_extensions.c 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/generated/vk_loader_extensions.c 2020-05-26 18:50:54.000000000 +0200 @@ -758,6 +758,12 @@ table->CreateIndirectCommandsLayoutNV = (PFN_vkCreateIndirectCommandsLayoutNV)gdpa(dev, "vkCreateIndirectCommandsLayoutNV"); table->DestroyIndirectCommandsLayoutNV = (PFN_vkDestroyIndirectCommandsLayoutNV)gdpa(dev, "vkDestroyIndirectCommandsLayoutNV"); + // ---- VK_EXT_private_data extension commands + table->CreatePrivateDataSlotEXT = (PFN_vkCreatePrivateDataSlotEXT)gdpa(dev, "vkCreatePrivateDataSlotEXT"); + table->DestroyPrivateDataSlotEXT = (PFN_vkDestroyPrivateDataSlotEXT)gdpa(dev, "vkDestroyPrivateDataSlotEXT"); + table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)gdpa(dev, "vkSetPrivateDataEXT"); + table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)gdpa(dev, "vkGetPrivateDataEXT"); + // ---- VK_KHR_ray_tracing extension commands #ifdef VK_ENABLE_BETA_EXTENSIONS table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(dev, "vkCreateAccelerationStructureKHR"); @@ -1486,6 +1492,12 @@ if (!strcmp(name, "CreateIndirectCommandsLayoutNV")) return (void *)table->CreateIndirectCommandsLayoutNV; if (!strcmp(name, "DestroyIndirectCommandsLayoutNV")) return (void *)table->DestroyIndirectCommandsLayoutNV; + // ---- VK_EXT_private_data extension commands + if (!strcmp(name, "CreatePrivateDataSlotEXT")) return (void *)table->CreatePrivateDataSlotEXT; + if (!strcmp(name, "DestroyPrivateDataSlotEXT")) return (void *)table->DestroyPrivateDataSlotEXT; + if (!strcmp(name, "SetPrivateDataEXT")) return (void *)table->SetPrivateDataEXT; + if (!strcmp(name, "GetPrivateDataEXT")) return (void *)table->GetPrivateDataEXT; + // ---- VK_KHR_ray_tracing extension commands #ifdef VK_ENABLE_BETA_EXTENSIONS if (!strcmp(name, "CreateAccelerationStructureKHR")) return (void *)table->CreateAccelerationStructureKHR; @@ -3619,6 +3631,46 @@ } +// ---- VK_EXT_private_data extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlotEXT* pPrivateDataSlot) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); +} + +VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlotEXT privateDataSlot, + const VkAllocationCallbacks* pAllocator) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t data) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); +} + +VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t* pData) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); +} + + // ---- VK_KHR_ray_tracing extension trampoline/terminators #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -4752,6 +4804,24 @@ return true; } + // ---- VK_EXT_private_data extension commands + if (!strcmp("vkCreatePrivateDataSlotEXT", name)) { + *addr = (void *)CreatePrivateDataSlotEXT; + return true; + } + if (!strcmp("vkDestroyPrivateDataSlotEXT", name)) { + *addr = (void *)DestroyPrivateDataSlotEXT; + return true; + } + if (!strcmp("vkSetPrivateDataEXT", name)) { + *addr = (void *)SetPrivateDataEXT; + return true; + } + if (!strcmp("vkGetPrivateDataEXT", name)) { + *addr = (void *)GetPrivateDataEXT; + return true; + } + // ---- VK_KHR_ray_tracing extension commands #ifdef VK_ENABLE_BETA_EXTENSIONS if (!strcmp("vkCreateAccelerationStructureKHR", name)) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/generated/vk_object_types.h new/Vulkan-Loader-1.2.141/loader/generated/vk_object_types.h --- old/Vulkan-Loader-1.2.137/loader/generated/vk_object_types.h 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/generated/vk_object_types.h 2020-05-26 18:50:54.000000000 +0200 @@ -75,7 +75,8 @@ kVulkanObjectTypeAccelerationStructureKHR = 36, kVulkanObjectTypePerformanceConfigurationINTEL = 37, kVulkanObjectTypeIndirectCommandsLayoutNV = 38, - kVulkanObjectTypeMax = 39, + kVulkanObjectTypePrivateDataSlotEXT = 39, + kVulkanObjectTypeMax = 40, // Aliases for backwards compatibilty of "promoted" types kVulkanObjectTypeDescriptorUpdateTemplateKHR = kVulkanObjectTypeDescriptorUpdateTemplate, kVulkanObjectTypeSamplerYcbcrConversionKHR = kVulkanObjectTypeSamplerYcbcrConversion, @@ -123,6 +124,7 @@ "AccelerationStructureKHR", "PerformanceConfigurationINTEL", "IndirectCommandsLayoutNV", + "PrivateDataSlotEXT", }; // Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version @@ -166,6 +168,7 @@ VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, // kVulkanObjectTypeAccelerationStructureKHR VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypePerformanceConfigurationINTEL VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeIndirectCommandsLayoutNV + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypePrivateDataSlotEXT }; // Helper array to get Official Vulkan VkObjectType enum from the internal layers version @@ -209,6 +212,7 @@ VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, // kVulkanObjectTypeAccelerationStructureKHR VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, // kVulkanObjectTypePerformanceConfigurationINTEL VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, // kVulkanObjectTypeIndirectCommandsLayoutNV + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, // kVulkanObjectTypePrivateDataSlotEXT }; // Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/loader.c new/Vulkan-Loader-1.2.141/loader/loader.c --- old/Vulkan-Loader-1.2.137/loader/loader.c 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/loader.c 2020-05-26 18:50:54.000000000 +0200 @@ -121,6 +121,14 @@ // additionally CreateDevice and DestroyDevice needs to be locked loader_platform_thread_mutex loader_lock; loader_platform_thread_mutex loader_json_lock; +loader_platform_thread_mutex loader_preload_icd_lock; + +// A list of ICDs that gets initialized when the loader does its global initialization. This list should never be used by anything +// other than EnumerateInstanceExtensionProperties(), vkDestroyInstance, and loader_release(). This list does not change +// functionality, but the fact that the libraries already been loaded causes any call that needs to load ICD libraries to speed up +// significantly. This can have a huge impact when making repeated calls to vkEnumerateInstanceExtensionProperties and +// vkCreateInstance. +static struct loader_icd_tramp_list scanned_icds; LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init); @@ -396,7 +404,7 @@ } else if ((msg_type & LOADER_ERROR_BIT) != 0) { severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; } else if ((msg_type & LOADER_DEBUG_BIT) != 0) { - severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; + severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; } if ((msg_type & LOADER_PERF_BIT) != 0) { @@ -1226,6 +1234,10 @@ loader_instance_heap_free(inst, layer_list->list[i].override_paths); layer_list->list[i].override_paths = NULL; } + if (NULL != layer_list->list[i].app_key_paths) { + loader_instance_heap_free(inst, layer_list->list[i].app_key_paths); + layer_list->list[i].app_key_paths = NULL; + } loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_list->list[i].instance_extension_list); dev_ext_list = &layer_list->list[i].device_extension_list; if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list) { @@ -1249,6 +1261,31 @@ } } +void loaderRemoveLayerInList(const struct loader_instance *inst, struct loader_layer_list *layer_list, uint32_t layer_to_remove) { + if (layer_list == NULL || layer_to_remove >= layer_list->count) { + return; + } + if (layer_list->list[layer_to_remove].type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) { + // Delete the component layers + loader_instance_heap_free(inst, layer_list->list[layer_to_remove].component_layer_names); + loader_instance_heap_free(inst, layer_list->list[layer_to_remove].override_paths); + loader_instance_heap_free(inst, layer_list->list[layer_to_remove].blacklist_layer_names); + loader_instance_heap_free(inst, layer_list->list[layer_to_remove].app_key_paths); + } + + // Remove the current invalid meta-layer from the layer list. Use memmove since we are + // overlapping the source and destination addresses. + memmove(&layer_list->list[layer_to_remove], &layer_list->list[layer_to_remove + 1], + sizeof(struct loader_layer_properties) * (layer_list->count - 1 - layer_to_remove)); + + // Make sure to clear out the removed layer, in case new layers are added in the previous location + memset(&layer_list->list[layer_list->count - 1], 0, sizeof(struct loader_layer_properties)); + + // Decrement the count (because we now have one less) and decrement the loop index since we need to + // re-check this index. + layer_list->count--; +} + // Remove all layers in the layer list that are blacklisted by the override layer. // NOTE: This should only be called if an override layer is found and not expired. void loaderRemoveLayersInBlacklist(const struct loader_instance *inst, struct loader_layer_list *layer_list) { @@ -2426,7 +2463,7 @@ // initialize mutexes loader_platform_thread_create_mutex(&loader_lock); loader_platform_thread_create_mutex(&loader_json_lock); - + loader_platform_thread_create_mutex(&loader_preload_icd_lock); // initialize logging loader_debug_init(); @@ -2450,9 +2487,38 @@ }; void loader_release() { + // Guarantee release of the preloaded ICD libraries. This may have already been called in vkDestroyInstance. + loader_unload_preloaded_icds(); + // release mutexes loader_platform_thread_delete_mutex(&loader_lock); loader_platform_thread_delete_mutex(&loader_json_lock); + loader_platform_thread_delete_mutex(&loader_preload_icd_lock); +} + +// Preload the ICD libraries that are likely to be needed so we don't repeatedly load/unload them later +void loader_preload_icds(void) { + loader_platform_thread_lock_mutex(&loader_preload_icd_lock); + + // Already preloaded, skip loading again. + if (scanned_icds.scanned_list != NULL) { + loader_platform_thread_unlock_mutex(&loader_preload_icd_lock); + return; + } + + memset(&scanned_icds, 0, sizeof(scanned_icds)); + VkResult result = loader_icd_scan(NULL, &scanned_icds); + if (result != VK_SUCCESS) { + loader_scanned_icd_clear(NULL, &scanned_icds); + } + loader_platform_thread_unlock_mutex(&loader_preload_icd_lock); +} + +// Release the ICD libraries that were preloaded +void loader_unload_preloaded_icds(void) { + loader_platform_thread_lock_mutex(&loader_preload_icd_lock); + loader_scanned_icd_clear(NULL, &scanned_icds); + loader_platform_thread_unlock_mutex(&loader_preload_icd_lock); } // Get next file or dirname given a string list or registry key path @@ -2728,6 +2794,75 @@ } } +// If the current working directory matches any app_key_path of the layers, remove all other override layers. +// Otherwise if no matching app_key was found, remove all but the global override layer, which has no app_key_path. +static void RemoveAllNonValidOverrideLayers(struct loader_instance *inst, struct loader_layer_list *instance_layers) { + if (instance_layers == NULL) { + return; + } + + char cur_path[MAX_STRING_SIZE]; + char *ret = loader_platform_executable_path(cur_path, sizeof(cur_path)); + if (ret == NULL) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "RemoveAllNonValidOverrideLayers: Failed to get executable path and name"); + return; + } + + // Find out if there is an override layer with same the app_key_path as the path to the current executable. + // If more than one is found, remove it and use the first layer + // Remove any layers which aren't global and do not have the same app_key_path as the path to the current executable. + bool found_active_override_layer = false; + int global_layer_index = -1; + for (uint32_t i = 0; i < instance_layers->count; i++) { + struct loader_layer_properties *props = &instance_layers->list[i]; + if (strcmp(props->info.layerName, VK_OVERRIDE_LAYER_NAME) == 0) { + if (props->num_app_key_paths > 0) { // not the global layer + for (uint32_t j = 0; j < props->num_app_key_paths; j++) { + if (strcmp(props->app_key_paths[j], cur_path) == 0) { + if (!found_active_override_layer) { + found_active_override_layer = true; + } else { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "RemoveAllNonValidOverrideLayers: Multiple override layers where the same" + "path in app_keys was found. Using the first layer found"); + + // Remove duplicate active override layers that have the same app_key_path + loaderRemoveLayerInList(inst, instance_layers, i); + i--; + } + } + } + if (!found_active_override_layer) { + // Remove non-global override layers that don't have an app_key that matches cur_path + loaderRemoveLayerInList(inst, instance_layers, i); + i--; + } + } else { + if (global_layer_index == -1) { + global_layer_index = i; + } else { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "RemoveAllNonValidOverrideLayers: Multiple global override layers " + "found. Using the first global layer found"); + loaderRemoveLayerInList(inst, instance_layers, i); + i--; + } + } + } + } + // Remove global layer if layer with same the app_key_path as the path to the current executable is found + if (found_active_override_layer && global_layer_index >= 0) { + loaderRemoveLayerInList(inst, instance_layers, global_layer_index); + } + // Should be at most 1 override layer in the list now. + if (found_active_override_layer) { + loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Using the override layer for app key %s", cur_path); + } else if (global_layer_index >= 0) { + loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Using the global override layer"); + } +} + // This structure is used to store the json file version // in a more manageable way. typedef struct { @@ -3129,6 +3264,7 @@ char *vkNegotiateLoaderLayerInterfaceVersion = NULL; char *spec_version = NULL; char **entry_array = NULL; + cJSON *app_keys = NULL; // Layer interface functions // vkGetInstanceProcAddr @@ -3317,6 +3453,45 @@ } } + props->num_app_key_paths = 0; + props->app_key_paths = NULL; + app_keys = cJSON_GetObjectItem(layer_node, "app_keys"); + if (app_keys != NULL) { + if (strcmp(name, VK_OVERRIDE_LAYER_NAME)) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Layer %s contains app_keys, but any app_keys can only be provided by the override metalayer. " + "These will be ignored.", + name); + } else { + props->num_app_key_paths = cJSON_GetArraySize(app_keys); + + // Allocate the blacklist array + props->app_key_paths = loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * props->num_app_key_paths, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (props->app_key_paths == NULL) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + + // Copy the app_key_paths into the array + for (i = 0; i < (int)props->num_app_key_paths; ++i) { + cJSON *app_key_path = cJSON_GetArrayItem(app_keys, i); + if (app_key_path == NULL) { + continue; + } + temp = cJSON_Print(app_key_path); + if (temp == NULL) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + temp[strlen(temp) - 1] = '\0'; + strncpy(props->app_key_paths[i], temp + 1, MAX_STRING_SIZE - 1); + props->app_key_paths[i][MAX_STRING_SIZE - 1] = '\0'; + cJSON_Free(temp); + } + } + } + result = VK_SUCCESS; out: @@ -3333,12 +3508,17 @@ if (NULL != props->override_paths) { loader_instance_heap_free(inst, props->override_paths); } + if (NULL != props->app_key_paths) { + loader_instance_heap_free(inst, props->app_key_paths); + } props->num_blacklist_layers = 0; props->blacklist_layer_names = NULL; props->num_component_layers = 0; props->component_layer_names = NULL; props->num_override_paths = 0; props->override_paths = NULL; + props->num_app_key_paths = 0; + props->app_key_paths = NULL; } return result; @@ -4531,6 +4711,9 @@ } } + // Remove any extraneous override layers. + RemoveAllNonValidOverrideLayers(inst, instance_layers); + // Check to see if the override layer is present, and use it's override paths. for (int32_t i = 0; i < (int32_t)instance_layers->count; i++) { struct loader_layer_properties *prop = &instance_layers->list[i]; @@ -4670,6 +4853,9 @@ } } + // Remove any extraneous override layers. + RemoveAllNonValidOverrideLayers(inst, instance_layers); + // Check to see if either the override layer is present, or another implicit meta-layer. // Each of these may require explicit layers to be enabled at this time. for (int32_t i = 0; i < (int32_t)instance_layers->count; i++) { @@ -7310,6 +7496,9 @@ } } } else { + // Preload ICD libraries so subsequent calls to EnumerateInstanceExtensionProperties don't have to load them + loader_preload_icds(); + // Scan/discover all ICD libraries memset(&icd_tramp_list, 0, sizeof(icd_tramp_list)); res = loader_icd_scan(NULL, &icd_tramp_list); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/loader.h new/Vulkan-Loader-1.2.141/loader/loader.h --- old/Vulkan-Loader-1.2.137/loader/loader.h 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/loader.h 2020-05-26 18:50:54.000000000 +0200 @@ -156,6 +156,8 @@ bool keep; uint32_t num_blacklist_layers; char (*blacklist_layer_names)[MAX_STRING_SIZE]; + uint32_t num_app_key_paths; + char (*app_key_paths)[MAX_STRING_SIZE]; }; struct loader_layer_list { @@ -422,6 +424,7 @@ extern THREAD_LOCAL_DECL struct loader_instance *tls_instance; extern loader_platform_thread_mutex loader_lock; extern loader_platform_thread_mutex loader_json_lock; +extern loader_platform_thread_mutex loader_preload_icd_lock; struct loader_msg_callback_map_entry { VkDebugReportCallbackEXT icd_obj; @@ -452,6 +455,8 @@ const VkInstanceCreateInfo *pCreateInfo); void loader_initialize(void); +void loader_preload_icds(void); +void loader_unload_preloaded_icds(void); bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count, const VkExtensionProperties *ext_array); bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/trampoline.c new/Vulkan-Loader-1.2.141/loader/trampoline.c --- old/Vulkan-Loader-1.2.137/loader/trampoline.c 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/trampoline.c 2020-05-26 18:50:54.000000000 +0200 @@ -656,9 +656,14 @@ ptr_instance->tmp_report_callbacks); util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_report_create_infos, ptr_instance->tmp_report_callbacks); } + loader_instance_heap_free(ptr_instance, ptr_instance->disp); loader_instance_heap_free(ptr_instance, ptr_instance); loader_platform_thread_unlock_mutex(&loader_lock); + + // Unload preloaded layers, so if vkEnumerateInstanceExtensionProperties or vkCreateInstance is called again, the ICD's are up + // to date + loader_unload_preloaded_icds(); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, @@ -859,7 +864,9 @@ disp = loader_get_dispatch(device); disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); - loader_set_dispatch(*pQueue, disp); + if (pQueue != NULL) { + loader_set_dispatch(*pQueue, disp); + } } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, @@ -2445,8 +2452,7 @@ LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); disp->GetDeviceQueue2(device, pQueueInfo, pQueue); - if (*pQueue != VK_NULL_HANDLE) - { + if (pQueue != NULL) { loader_set_dispatch(*pQueue, disp); } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/loader/vk_loader_platform.h new/Vulkan-Loader-1.2.141/loader/vk_loader_platform.h --- old/Vulkan-Loader-1.2.137/loader/vk_loader_platform.h 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/loader/vk_loader_platform.h 2020-05-26 18:50:54.000000000 +0200 @@ -38,7 +38,6 @@ //#ifndef _GNU_SOURCE //#define _GNU_SOURCE 1 //#endif -// TBD: Are the contents of the following file used? #include <unistd.h> // Note: The following file is for dynamic loading: #include <dlfcn.h> @@ -100,6 +99,27 @@ static inline char *loader_platform_dirname(char *path) { return dirname(path); } +#if defined(__linux__) + +// find application path + name. Path cannot be longer than 1024, returns NULL if it is greater than that. +static inline char *loader_platform_executable_path(char *buffer, size_t size) { + ssize_t count = readlink("/proc/self/exe", buffer, size); + if (count == -1) return NULL; + if (count == 0) return NULL; + buffer[count] = '\0'; + return buffer; +} +#elif defined(__APPLE__) // defined(__linux__) +#include <libproc.h> +static inline char *loader_platform_executable_path(char *buffer, size_t size) { + pid_t pid = getpid(); + int ret = proc_pidpath(pid, buffer, size); + if (ret <= 0) return NULL; + buffer[ret] = '\0'; + return buffer; +} +#endif // defined (__APPLE__) + // Dynamic Loading of libraries: typedef void *loader_platform_dl_handle; static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) { @@ -162,6 +182,7 @@ #include <io.h> #include <stdbool.h> #include <shlwapi.h> +#include <direct.h> #ifdef __cplusplus #include <iostream> #include <string> @@ -279,6 +300,14 @@ return path; } +static inline char *loader_platform_executable_path(char *buffer, size_t size) { + DWORD ret = GetModuleFileName(NULL, buffer, (DWORD)size); + if (ret == 0) return NULL; + if (ret > size) return NULL; + buffer[ret] = '\0'; + return buffer; +} + // Dynamic Loading: typedef HMODULE loader_platform_dl_handle; static loader_platform_dl_handle loader_platform_open_library(const char *lib_path) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/scripts/known_good.json new/Vulkan-Loader-1.2.141/scripts/known_good.json --- old/Vulkan-Loader-1.2.137/scripts/known_good.json 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/scripts/known_good.json 2020-05-26 18:50:54.000000000 +0200 @@ -6,7 +6,7 @@ "sub_dir" : "Vulkan-Headers", "build_dir" : "Vulkan-Headers/build", "install_dir" : "Vulkan-Headers/build/install", - "commit" : "v1.2.137" + "commit" : "v1.2.141" } ], "install_names" : { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/scripts/loader_genvk.py new/Vulkan-Loader-1.2.141/scripts/loader_genvk.py --- old/Vulkan-Loader-1.2.137/scripts/loader_genvk.py 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/scripts/loader_genvk.py 2020-05-26 18:50:54.000000000 +0200 @@ -231,7 +231,8 @@ helper_file_type = 'object_types_header') ] -# Generate a target based on the options in the matching genOpts{} object. +# Create an API generator and corresponding generator options based on +# the requested target and command line options. # This is encapsulated in a function so it can be profiled and/or timed. # The args parameter is an parsed argument object containing the following # fields that are used: @@ -243,9 +244,10 @@ def genTarget(args): global genOpts - # Create generator options with specified parameters + # Create generator options with parameters specified on command line makeGenOpts(args) + # Select a generator matching the requested target if (args.target in genOpts.keys()): createGenerator = genOpts[args.target][0] options = genOpts[args.target][1] @@ -259,19 +261,15 @@ write('* options.removeExtensions =', options.removeExtensions, file=sys.stderr) write('* options.emitExtensions =', options.emitExtensions, file=sys.stderr) - startTimer(args.time) gen = createGenerator(errFile=errWarn, warnFile=errWarn, diagFile=diag) - reg.setGenerator(gen) - reg.apiGen(options) - if not args.quiet: write('* Generated', options.filename, file=sys.stderr) - endTimer(args.time, '* Time to generate ' + options.filename + ' =') + return (gen, options) else: - write('No generator options for unknown target:', - args.target, file=sys.stderr) + write('No generator options for unknown target:', args.target, file=sys.stderr) + return none # -feature name # -extension name @@ -357,19 +355,33 @@ args.feature = [name for arg in args.feature for name in arg.split()] args.extension = [name for arg in args.extension for name in arg.split()] - # Load & parse registry - reg = Registry() + # create error/warning & diagnostic files + if args.errfile: + errWarn = open(args.errfile, 'w', encoding='utf-8') + else: + errWarn = sys.stderr + + if args.diagfile: + diag = open(args.diagfile, 'w', encoding='utf-8') + else: + diag = None + # Create the API generator & generator options + (gen, options) = genTarget(args) + + # Create the registry object with the specified generator and generator + # options. The options are set before XML loading as they may affect it. + reg = Registry(gen, options) + + # Parse the specified registry XML into an ElementTree objec startTimer(args.time) tree = etree.parse(args.registry) endTimer(args.time, '* Time to make ElementTree =') - if args.debug: - pdb.run('reg.loadElementTree(tree)') - else: - startTimer(args.time) - reg.loadElementTree(tree) - endTimer(args.time, '* Time to parse ElementTree =') + # Load the XML tree into the registry object + startTimer(args.time) + reg.loadElementTree(tree) + endTimer(args.time, '* Time to parse ElementTree =') if (args.validate): reg.validateGroups() @@ -378,23 +390,13 @@ write('* Dumping registry to regdump.txt', file=sys.stderr) reg.dumpReg(filehandle = open('regdump.txt', 'w', encoding='utf-8')) - # create error/warning & diagnostic files - if (args.errfile): - errWarn = open(args.errfile, 'w', encoding='utf-8') - else: - errWarn = sys.stderr - - if (args.diagfile): - diag = open(args.diagfile, 'w', encoding='utf-8') - else: - diag = None - + # Finally, use the output generator to create the requested targe if (args.debug): - pdb.run('genTarget(args)') - elif (args.profile): - import cProfile, pstats - cProfile.run('genTarget(args)', 'profile.txt') - p = pstats.Stats('profile.txt') - p.strip_dirs().sort_stats('time').print_stats(50) + pdb.run('reg.apiGen()') else: - genTarget(args) + startTimer(args.time) + reg.apiGen() + endTimer(args.time, '* Time to generate ' + options.filename + ' =') + + if not args.quiet: + write('* Generated', options.filename, file=sys.stderr) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Loader-1.2.137/tests/CMakeLists.txt new/Vulkan-Loader-1.2.141/tests/CMakeLists.txt --- old/Vulkan-Loader-1.2.137/tests/CMakeLists.txt 2020-04-08 23:52:42.000000000 +0200 +++ new/Vulkan-Loader-1.2.141/tests/CMakeLists.txt 2020-05-26 18:50:54.000000000 +0200 @@ -116,8 +116,8 @@ GTEST_COPY_SRC2) file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG> GTEST_COPY_DEST) else() - file(TO_NATIVE_PATH ${PROJECT_BINARY_DIR}/external/googletest/googeltest/gtest_main.dll GTEST_COPY_SRC1) - file(TO_NATIVE_PATH ${PROJECT_BINARY_DIR}/external/googletest/googletest/gtest.dll GTEST_COPY_SRC2) + file(TO_NATIVE_PATH ${PROJECT_BINARY_DIR}/external/googletest/googletest/gtest_main$<$<CONFIG:Debug>:d>.dll GTEST_COPY_SRC1) + file(TO_NATIVE_PATH ${PROJECT_BINARY_DIR}/external/googletest/googletest/gtest$<$<CONFIG:Debug>:d>.dll GTEST_COPY_SRC2) file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR} GTEST_COPY_DEST) endif() add_custom_command(TARGET vk_loader_validation_tests POST_BUILD
