From d6d1f1161a652348c719ed0da5f468334a4bc303 Mon Sep 17 00:00:00 2001 From: Peter Harris Date: Mon, 10 Aug 2026 16:46:31 +0100 Subject: [PATCH 1/2] Update to Vulkan v1.4.359 --- .../framework/device_dispatch_table.hpp | 6 ++ source_common/framework/device_functions.cpp | 36 +++++++++- source_common/framework/device_functions.hpp | 30 ++++++++- .../framework/device_functions_query.hpp | 46 ++++++++++++- .../framework/instance_dispatch_table.hpp | 11 ++++ .../framework/instance_functions.cpp | 59 +++++++++++++++++ .../framework/instance_functions.hpp | 55 ++++++++++++++++ .../framework/instance_functions_query.hpp | 66 +++++++++++++++++++ source_third_party/khronos/vulkan | 2 +- source_third_party/khronos/vulkan-utilities | 2 +- 10 files changed, 307 insertions(+), 6 deletions(-) diff --git a/source_common/framework/device_dispatch_table.hpp b/source_common/framework/device_dispatch_table.hpp index 8c91a92..6ddd3c9 100644 --- a/source_common/framework/device_dispatch_table.hpp +++ b/source_common/framework/device_dispatch_table.hpp @@ -273,6 +273,7 @@ static const struct DeviceInterceptTableEntry deviceIntercepts[] = { ENTRY(vkCmdSetDiscardRectangleEXT), ENTRY(vkCmdSetDiscardRectangleEnableEXT), ENTRY(vkCmdSetDiscardRectangleModeEXT), + ENTRY(vkCmdSetDispatchParametersARM), ENTRY(vkCmdSetEvent), ENTRY(vkCmdSetEvent2), ENTRY(vkCmdSetEvent2KHR), @@ -292,6 +293,7 @@ static const struct DeviceInterceptTableEntry deviceIntercepts[] = { ENTRY(vkCmdSetPolygonModeEXT), ENTRY(vkCmdSetPrimitiveRestartEnable), ENTRY(vkCmdSetPrimitiveRestartEnableEXT), + ENTRY(vkCmdSetPrimitiveRestartIndexEXT), ENTRY(vkCmdSetPrimitiveTopology), ENTRY(vkCmdSetPrimitiveTopologyEXT), ENTRY(vkCmdSetProvokingVertexModeEXT), @@ -828,6 +830,7 @@ struct DeviceDispatchTable { PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT; PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT; + PFN_vkCmdSetDispatchParametersARM vkCmdSetDispatchParametersARM; PFN_vkCmdSetEvent vkCmdSetEvent; PFN_vkCmdSetEvent2 vkCmdSetEvent2; PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; @@ -847,6 +850,7 @@ struct DeviceDispatchTable { PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; + PFN_vkCmdSetPrimitiveRestartIndexEXT vkCmdSetPrimitiveRestartIndexEXT; PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; @@ -1392,6 +1396,7 @@ static inline void initDriverDeviceDispatchTable( ENTRY(vkCmdSetDiscardRectangleEXT); ENTRY(vkCmdSetDiscardRectangleEnableEXT); ENTRY(vkCmdSetDiscardRectangleModeEXT); + ENTRY(vkCmdSetDispatchParametersARM); ENTRY(vkCmdSetEvent); ENTRY(vkCmdSetEvent2); ENTRY(vkCmdSetEvent2KHR); @@ -1411,6 +1416,7 @@ static inline void initDriverDeviceDispatchTable( ENTRY(vkCmdSetPolygonModeEXT); ENTRY(vkCmdSetPrimitiveRestartEnable); ENTRY(vkCmdSetPrimitiveRestartEnableEXT); + ENTRY(vkCmdSetPrimitiveRestartIndexEXT); ENTRY(vkCmdSetPrimitiveTopology); ENTRY(vkCmdSetPrimitiveTopologyEXT); ENTRY(vkCmdSetProvokingVertexModeEXT); diff --git a/source_common/framework/device_functions.cpp b/source_common/framework/device_functions.cpp index 716ac4b..0198aeb 100644 --- a/source_common/framework/device_functions.cpp +++ b/source_common/framework/device_functions.cpp @@ -3814,6 +3814,23 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetDiscardRectangleModeEXT( layer->driver.vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); } +/* See Vulkan API for documentation. */ +template <> +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetDispatchParametersARM( + VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters +) { + LAYER_TRACE(__func__); + + // Hold the lock to access layer-wide global store + std::unique_lock lock { g_vulkanLock }; + auto* layer = Device::retrieve(commandBuffer); + + // Release the lock to call into the driver + lock.unlock(); + layer->driver.vkCmdSetDispatchParametersARM(commandBuffer, pDispatchParameters); +} + /* See Vulkan API for documentation. */ template <> VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetEvent( @@ -4144,6 +4161,23 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveRestartEnableEXT( layer->driver.vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); } +/* See Vulkan API for documentation. */ +template <> +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveRestartIndexEXT( + VkCommandBuffer commandBuffer, + uint32_t primitiveRestartIndex +) { + LAYER_TRACE(__func__); + + // Hold the lock to access layer-wide global store + std::unique_lock lock { g_vulkanLock }; + auto* layer = Device::retrieve(commandBuffer); + + // Release the lock to call into the driver + lock.unlock(); + layer->driver.vkCmdSetPrimitiveRestartIndexEXT(commandBuffer, primitiveRestartIndex); +} + /* See Vulkan API for documentation. */ template <> VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveTopology( @@ -8340,7 +8374,7 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPipelineKeyKHR( template <> VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPipelinePropertiesEXT( VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, + const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties ) { LAYER_TRACE(__func__); diff --git a/source_common/framework/device_functions.hpp b/source_common/framework/device_functions.hpp index e400940..1688744 100644 --- a/source_common/framework/device_functions.hpp +++ b/source_common/framework/device_functions.hpp @@ -3261,6 +3261,19 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); +/* See Vulkan API for documentation. */ +/* Delete the generic match-all */ +template +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetDispatchParametersARM( + VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters) = delete; + +/* Default common code implementation. */ +template <> +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetDispatchParametersARM( + VkCommandBuffer commandBuffer, + const VkDispatchParametersARM* pDispatchParameters); + /* See Vulkan API for documentation. */ /* Delete the generic match-all */ template @@ -3522,6 +3535,19 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +/* See Vulkan API for documentation. */ +/* Delete the generic match-all */ +template +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveRestartIndexEXT( + VkCommandBuffer commandBuffer, + uint32_t primitiveRestartIndex) = delete; + +/* Default common code implementation. */ +template <> +VKAPI_ATTR void VKAPI_CALL layer_vkCmdSetPrimitiveRestartIndexEXT( + VkCommandBuffer commandBuffer, + uint32_t primitiveRestartIndex); + /* See Vulkan API for documentation. */ /* Delete the generic match-all */ template @@ -7164,14 +7190,14 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPipelineKeyKHR( template VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPipelinePropertiesEXT( VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, + const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) = delete; /* Default common code implementation. */ template <> VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPipelinePropertiesEXT( VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, + const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); /* See Vulkan API for documentation. */ diff --git a/source_common/framework/device_functions_query.hpp b/source_common/framework/device_functions_query.hpp index 8f03060..212732d 100644 --- a/source_common/framework/device_functions_query.hpp +++ b/source_common/framework/device_functions_query.hpp @@ -4563,6 +4563,28 @@ constexpr PFN_vkCmdSetDiscardRectangleModeEXT getLayerPtr_vkCmdSetDiscardRectang }.operator()(); } +/* Test for user_tag availability. */ +template +concept hasLayerPtr_vkCmdSetDispatchParametersARM = requires( + VkCommandBuffer commandBuffer, const VkDispatchParametersARM* pDispatchParameters +) { + layer_vkCmdSetDispatchParametersARM(commandBuffer, pDispatchParameters); +}; + +/* Function pointer resolution. */ +constexpr PFN_vkCmdSetDispatchParametersARM getLayerPtr_vkCmdSetDispatchParametersARM() +{ + return [] + { + if constexpr(hasLayerPtr_vkCmdSetDispatchParametersARM) + { + return layer_vkCmdSetDispatchParametersARM; + } + + return layer_vkCmdSetDispatchParametersARM; + }.operator()(); +} + /* Test for user_tag availability. */ template concept hasLayerPtr_vkCmdSetEvent = requires( @@ -4981,6 +5003,28 @@ constexpr PFN_vkCmdSetPrimitiveRestartEnableEXT getLayerPtr_vkCmdSetPrimitiveRes }.operator()(); } +/* Test for user_tag availability. */ +template +concept hasLayerPtr_vkCmdSetPrimitiveRestartIndexEXT = requires( + VkCommandBuffer commandBuffer, uint32_t primitiveRestartIndex +) { + layer_vkCmdSetPrimitiveRestartIndexEXT(commandBuffer, primitiveRestartIndex); +}; + +/* Function pointer resolution. */ +constexpr PFN_vkCmdSetPrimitiveRestartIndexEXT getLayerPtr_vkCmdSetPrimitiveRestartIndexEXT() +{ + return [] + { + if constexpr(hasLayerPtr_vkCmdSetPrimitiveRestartIndexEXT) + { + return layer_vkCmdSetPrimitiveRestartIndexEXT; + } + + return layer_vkCmdSetPrimitiveRestartIndexEXT; + }.operator()(); +} + /* Test for user_tag availability. */ template concept hasLayerPtr_vkCmdSetPrimitiveTopology = requires( @@ -10066,7 +10110,7 @@ constexpr PFN_vkGetPipelineKeyKHR getLayerPtr_vkGetPipelineKeyKHR() /* Test for user_tag availability. */ template concept hasLayerPtr_vkGetPipelinePropertiesEXT = requires( - VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties + VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties ) { layer_vkGetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); }; diff --git a/source_common/framework/instance_dispatch_table.hpp b/source_common/framework/instance_dispatch_table.hpp index 4dcd3c9..e48fb83 100644 --- a/source_common/framework/instance_dispatch_table.hpp +++ b/source_common/framework/instance_dispatch_table.hpp @@ -102,6 +102,7 @@ static const struct InstanceInterceptTableEntry instanceIntercepts[] = { ENTRY(vkGetInstanceProcAddr), ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT), ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR), + ENTRY(vkGetPhysicalDeviceCooperativeMatrixProperties2EXT), ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR), ENTRY(vkGetPhysicalDeviceDescriptorSizeEXT), ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR), @@ -133,6 +134,8 @@ static const struct InstanceInterceptTableEntry instanceIntercepts[] = { ENTRY(vkGetPhysicalDeviceProperties), ENTRY(vkGetPhysicalDeviceProperties2), ENTRY(vkGetPhysicalDeviceProperties2KHR), + ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM), + ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM), ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM), ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM), ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR), @@ -361,6 +364,7 @@ static const struct InstanceInterceptTableEntry instanceIntercepts[] = { ENTRY(vkCmdSetDiscardRectangleEXT), ENTRY(vkCmdSetDiscardRectangleEnableEXT), ENTRY(vkCmdSetDiscardRectangleModeEXT), + ENTRY(vkCmdSetDispatchParametersARM), ENTRY(vkCmdSetEvent), ENTRY(vkCmdSetEvent2), ENTRY(vkCmdSetEvent2KHR), @@ -380,6 +384,7 @@ static const struct InstanceInterceptTableEntry instanceIntercepts[] = { ENTRY(vkCmdSetPolygonModeEXT), ENTRY(vkCmdSetPrimitiveRestartEnable), ENTRY(vkCmdSetPrimitiveRestartEnableEXT), + ENTRY(vkCmdSetPrimitiveRestartIndexEXT), ENTRY(vkCmdSetPrimitiveTopology), ENTRY(vkCmdSetPrimitiveTopologyEXT), ENTRY(vkCmdSetProvokingVertexModeEXT), @@ -740,6 +745,7 @@ struct InstanceDispatchTable { PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT vkGetPhysicalDeviceCooperativeMatrixProperties2EXT; PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT; PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR; @@ -771,6 +777,8 @@ struct InstanceDispatchTable { PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM; PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM; PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM; PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; @@ -837,6 +845,7 @@ static inline void initDriverInstanceDispatchTable( ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR); ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); + ENTRY(vkGetPhysicalDeviceCooperativeMatrixProperties2EXT); ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR); ENTRY(vkGetPhysicalDeviceDescriptorSizeEXT); ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); @@ -868,6 +877,8 @@ static inline void initDriverInstanceDispatchTable( ENTRY(vkGetPhysicalDeviceProperties); ENTRY(vkGetPhysicalDeviceProperties2); ENTRY(vkGetPhysicalDeviceProperties2KHR); + ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM); + ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM); ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM); ENTRY(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM); ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR); diff --git a/source_common/framework/instance_functions.cpp b/source_common/framework/instance_functions.cpp index 3d88cfc..e636e87 100644 --- a/source_common/framework/instance_functions.cpp +++ b/source_common/framework/instance_functions.cpp @@ -457,6 +457,25 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCalibrateableTimeDomains return layer->driver.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); } +/* See Vulkan API for documentation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, + uint32_t* pPropertyCount, + VkCooperativeMatrixProperties2EXT* pProperties +) { + LAYER_TRACE(__func__); + + // Hold the lock to access layer-wide global store + std::unique_lock lock { g_vulkanLock }; + auto* layer = Instance::retrieve(physicalDevice); + + // Release the lock to call into the driver + lock.unlock(); + return layer->driver.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT(physicalDevice, pCooperativeMatrixInfo, pPropertyCount, pProperties); +} + /* See Vulkan API for documentation. */ template <> VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( @@ -1010,6 +1029,46 @@ VKAPI_ATTR void VKAPI_CALL layer_vkGetPhysicalDeviceProperties2KHR( layer->driver.vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } +/* See Vulkan API for documentation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + VkBaseOutStructure* pProperties +) { + LAYER_TRACE(__func__); + + // Hold the lock to access layer-wide global store + std::unique_lock lock { g_vulkanLock }; + auto* layer = Instance::retrieve(physicalDevice); + + // Release the lock to call into the driver + lock.unlock(); + return layer->driver.vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphProperties, pProperties); +} + +/* See Vulkan API for documentation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties +) { + LAYER_TRACE(__func__); + + // Hold the lock to access layer-wide global store + std::unique_lock lock { g_vulkanLock }; + auto* layer = Instance::retrieve(physicalDevice); + + // Release the lock to call into the driver + lock.unlock(); + return layer->driver.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphProperties, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); +} + /* See Vulkan API for documentation. */ template <> VKAPI_ATTR void VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( diff --git a/source_common/framework/instance_functions.hpp b/source_common/framework/instance_functions.hpp index f96efb9..71ddf5f 100644 --- a/source_common/framework/instance_functions.hpp +++ b/source_common/framework/instance_functions.hpp @@ -519,6 +519,23 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCalibrateableTimeDomains uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); +/* See Vulkan API for documentation. */ +/* Delete the generic match-all */ +template +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, + uint32_t* pPropertyCount, + VkCooperativeMatrixProperties2EXT* pProperties) = delete; + +/* Default common code implementation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, + uint32_t* pPropertyCount, + VkCooperativeMatrixProperties2EXT* pProperties); + /* See Vulkan API for documentation. */ /* Delete the generic match-all */ template @@ -974,6 +991,44 @@ VKAPI_ATTR void VKAPI_CALL layer_vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +/* See Vulkan API for documentation. */ +/* Delete the generic match-all */ +template +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + VkBaseOutStructure* pProperties) = delete; + +/* Default common code implementation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + VkBaseOutStructure* pProperties); + +/* See Vulkan API for documentation. */ +/* Delete the generic match-all */ +template +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties) = delete; + +/* Default common code implementation. */ +template <> +VKAPI_ATTR VkResult VKAPI_CALL layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); + /* See Vulkan API for documentation. */ /* Delete the generic match-all */ template diff --git a/source_common/framework/instance_functions_query.hpp b/source_common/framework/instance_functions_query.hpp index 20bbd41..78bfc7a 100644 --- a/source_common/framework/instance_functions_query.hpp +++ b/source_common/framework/instance_functions_query.hpp @@ -693,6 +693,28 @@ constexpr PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR getLayerPtr_vkGetPh }.operator()(); } +/* Test for user_tag availability. */ +template +concept hasLayerPtr_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT = requires( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, uint32_t* pPropertyCount, VkCooperativeMatrixProperties2EXT* pProperties +) { + layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT(physicalDevice, pCooperativeMatrixInfo, pPropertyCount, pProperties); +}; + +/* Function pointer resolution. */ +constexpr PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT getLayerPtr_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT() +{ + return [] + { + if constexpr(hasLayerPtr_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT) + { + return layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT; + } + + return layer_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT; + }.operator()(); +} + /* Test for user_tag availability. */ template concept hasLayerPtr_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = requires( @@ -1375,6 +1397,50 @@ constexpr PFN_vkGetPhysicalDeviceProperties2KHR getLayerPtr_vkGetPhysicalDeviceP }.operator()(); } +/* Test for user_tag availability. */ +template +concept hasLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM = requires( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, VkBaseOutStructure* pProperties +) { + layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphProperties, pProperties); +}; + +/* Function pointer resolution. */ +constexpr PFN_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM getLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM() +{ + return [] + { + if constexpr(hasLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM) + { + return layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM; + } + + return layer_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM; + }.operator()(); +} + +/* Test for user_tag availability. */ +template +concept hasLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = requires( + VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties +) { + layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphProperties, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); +}; + +/* Function pointer resolution. */ +constexpr PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM getLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM() +{ + return [] + { + if constexpr(hasLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM) + { + return layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM; + } + + return layer_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM; + }.operator()(); +} + /* Test for user_tag availability. */ template concept hasLayerPtr_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = requires( diff --git a/source_third_party/khronos/vulkan b/source_third_party/khronos/vulkan index 387259e..f9973cd 160000 --- a/source_third_party/khronos/vulkan +++ b/source_third_party/khronos/vulkan @@ -1 +1 @@ -Subproject commit 387259ecf4b0fe0cfac161b1d0b0a74e42796710 +Subproject commit f9973cd97e6f3584707e7ef1c425e336f1b92a5b diff --git a/source_third_party/khronos/vulkan-utilities b/source_third_party/khronos/vulkan-utilities index 9b9b0a0..48b2a63 160000 --- a/source_third_party/khronos/vulkan-utilities +++ b/source_third_party/khronos/vulkan-utilities @@ -1 +1 @@ -Subproject commit 9b9b0a04b36344a85705fe30f52e6f7aa59a9001 +Subproject commit 48b2a63b17eb79d612bd276d6e1adeb1f73c03e9 From a9208f45493b494ca3040cf3d6dd640eed328bb2 Mon Sep 17 00:00:00 2001 From: Peter Harris Date: Mon, 10 Aug 2026 17:07:57 +0100 Subject: [PATCH 2/2] Add Vulkan API update instructions --- README.md | 3 ++- docs/updating.md | 70 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 docs/updating.md diff --git a/README.md b/README.md index c9196d6..75c4154 100644 --- a/README.md +++ b/README.md @@ -64,6 +64,7 @@ Common documentation * [Building a layer](./docs/building.md) * [Creating a new layer](./docs/creating.md) +* [Updating an existing layer](./docs/updating.md) * [Running using a layer on Android](./docs/running_android.md) * [Running using a layer on Linux](./docs/running_linux.md) * [About layers design notes](./docs/about_layers.md) @@ -86,7 +87,7 @@ or general mobile graphics development or technology, please submit them on the - - - -_Copyright © 2024-2025, Arm Limited and contributors._ +_Copyright © 2024-2026, Arm Limited and contributors._ [1]: https://community.arm.com/support-forums/f/graphics-gaming-and-vr-forum/ [2]: https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio diff --git a/docs/updating.md b/docs/updating.md new file mode 100644 index 0000000..1ef62d9 --- /dev/null +++ b/docs/updating.md @@ -0,0 +1,70 @@ +# Updating layers + +This page gives you instructions for updating an existing layer to use a newer +version of Vulkan. + +## Updating Vulkan version + +When updating to a newer version of Vulkan, there are three things that need to +be updated in sync or things will break: + +* Upstream Vulkan headers (submodule) +* Upstream Vulkan utilities library (submodule) +* Generated common code in libGPULayers + +### Updating submodules + +Updating Khronos Vulkan headers, e.g.: + +```sh +pushd . +cd ./source_third_party/khronos/vulkan/ +git checkout v1.4.359 +popd +``` + +Updating Khronos Vulkan utilities library, e.g.: + +```sh +pushd . +cd ./source_third_party/khronos/vulkan-utilities/ +git checkout v1.4.359 +popd +``` + +### Updating generated code + +After you have updated the Khronos Vulkan headers, which includes the +machine-readable XML, you can regenerate the auto-generated common code: + +```sh +python3 ./generator/generate_vulkan_common.py +``` + +### Committing your changes + +All three of these changes need to land at the same time to avoid runtime +errors caused by any mismatches or unknown structures. + +For maintainers updating GitHub, ensure you commit all three together when +raising a new PR to update Vulkan. + +## Updating existing layers + +When updating to a newer Vulkan version, existing layers might need to be +updated. + +We recommend layers use a forwarding pattern, which returns Vulkan API handles +from the layer below to the application. This means that any new entrypoints +will see a valid handle, and will function as expected if a layer does not +intercept them. It is common that this style of layer needs no updates, unless +a new API function needs to be explicitly processed to implement the desired +functionality in the layer itself. + +For maintainers updating GitHub, we usually commit layer updates to support new +API entry points as per-layer commits, separately from the triggering Vulkan +API update. This makes patch sets smaller and easier to review. + +- - - + +_Copyright © 2026, Arm Limited and contributors._