Update built-in layers to support all Vk 1.4.347 functions

layer_gpu_profile/source/layer_device_functions.hpp

@@ -1,7 +1,7 @@
 /*
  * SPDX-License-Identifier: MIT
  * ----------------------------------------------------------------------------
- * Copyright (c) 2024-2025 Arm Limited
+ * Copyright (c) 2024-2026 Arm Limited
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -261,6 +261,14 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdFillBuffer<user_tag>(VkCommandBuffer comma
                                                            VkDeviceSize size,
                                                            uint32_t data);
 
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdFillMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    uint32_t data);
+
 /* See Vulkan API for documentation. */
 template<>
 VKAPI_ATTR void VKAPI_CALL layer_vkCmdClearColorImage<user_tag>(VkCommandBuffer commandBuffer,
@@ -359,6 +367,56 @@ VKAPI_ATTR void VKAPI_CALL
     layer_vkCmdCopyImageToBuffer2KHR<user_tag>(VkCommandBuffer commandBuffer,
                                                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
 
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyImageToMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyMemoryToImageKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyQueryPoolResultsToMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    const VkStridedDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    VkQueryResultFlags queryResultFlags);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdUpdateMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    VkDeviceSize dataSize,
+    const void* pData);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL
+    layer_vkCmdCopyMemoryIndirectKHR<user_tag>(VkCommandBuffer commandBuffer,
+                                               const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo);
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL
+    layer_vkCmdCopyMemoryToImageIndirectKHR<user_tag>(VkCommandBuffer commandBuffer,
+                                                      const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo);
+
 /* See Vulkan API for documentation. */
 template<>
 VKAPI_ATTR void VKAPI_CALL

layer_gpu_profile/source/layer_device_functions_transfer.cpp

@@ -1,7 +1,7 @@
 /*
  * SPDX-License-Identifier: MIT
  * ----------------------------------------------------------------------------
- * Copyright (c) 2024-2025 Arm Limited
+ * Copyright (c) 2024-2026 Arm Limited
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -127,14 +127,43 @@ VKAPI_ATTR void VKAPI_CALL layer_vkCmdFillBuffer<user_tag>(VkCommandBuffer comma
         byteCount = -2;
     }
 
-    registerBufferTransfer(layer, commandBuffer, Tracker::LCSBufferTransfer::Type::fill_buffer, byteCount);
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::fill_buffer,
+                           byteCount);
 
     // Release the lock to call into the driver
     lock.unlock();
     layer->driver.vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
     emitCPUTrap(*layer, commandBuffer);
 }
 
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdFillMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    uint32_t data
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t byteCount = static_cast<int64_t>(pDstRange->size);
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::fill_buffer,
+                           byteCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdFillMemoryKHR(commandBuffer, pDstRange, dstFlags, data);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
 /* See Vulkan API for documentation. */
 template<>
 VKAPI_ATTR void VKAPI_CALL layer_vkCmdClearColorImage<user_tag>(VkCommandBuffer commandBuffer,
@@ -560,11 +589,210 @@ VKAPI_ATTR void VKAPI_CALL
     emitCPUTrap(*layer, commandBuffer);
 }
 
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyImageToMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t pixelCount = 0;
+    for (uint32_t i = 0; i < pCopyMemoryInfo->regionCount; i++)
+    {
+        const auto& extent = pCopyMemoryInfo->pRegions[i].imageExtent;
+        int64_t regionPixelCount = static_cast<int64_t>(extent.width)
+                                 * static_cast<int64_t>(extent.height)
+                                 * static_cast<int64_t>(extent.depth);
+        pixelCount += regionPixelCount;
+    }
+
+    registerImageTransfer(layer,
+                          commandBuffer,
+                          Tracker::LCSImageTransfer::Type::copy_image_to_buffer,
+                          pixelCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyImageToMemoryKHR(commandBuffer, pCopyMemoryInfo);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t byteCount = 0;
+    for (uint32_t i = 0; i < pCopyMemoryInfo->regionCount; i++)
+    {
+        byteCount += static_cast<int64_t>(pCopyMemoryInfo->pRegions[i].dstRange.size);
+    }
+
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::copy_memory,
+                           byteCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyMemoryKHR(commandBuffer, pCopyMemoryInfo);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyMemoryToImageKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t pixelCount = 0;
+    for (uint32_t i = 0; i < pCopyMemoryInfo->regionCount; i++)
+    {
+        const auto& extent = pCopyMemoryInfo->pRegions[i].imageExtent;
+        int64_t regionPixelCount = static_cast<int64_t>(extent.width)
+                                 * static_cast<int64_t>(extent.height)
+                                 * static_cast<int64_t>(extent.depth);
+        pixelCount += regionPixelCount;
+    }
+
+    registerImageTransfer(layer,
+                          commandBuffer,
+                          Tracker::LCSImageTransfer::Type::copy_memory_to_image,
+                          pixelCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyMemoryToImageKHR(commandBuffer, pCopyMemoryInfo);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyQueryPoolResultsToMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    VkQueryPool queryPool,
+    uint32_t firstQuery,
+    uint32_t queryCount,
+    const VkStridedDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    VkQueryResultFlags queryResultFlags
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t byteCount = static_cast<int64_t>(pDstRange->size);
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::unknown,
+                           byteCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyQueryPoolResultsToMemoryKHR(
+        commandBuffer, queryPool, firstQuery, queryCount, pDstRange, dstFlags, queryResultFlags);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdUpdateMemoryKHR<user_tag>(
+    VkCommandBuffer commandBuffer,
+    const VkDeviceAddressRangeKHR* pDstRange,
+    VkAddressCommandFlagsKHR dstFlags,
+    VkDeviceSize dataSize,
+    const void* pData
+) {
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    int64_t byteCount = static_cast<int64_t>(dataSize);
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::copy_memory,
+                           byteCount);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdUpdateMemoryKHR(commandBuffer, pDstRange, dstFlags, dataSize, pData);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
 /* See Vulkan API for documentation. */
 template<>
 VKAPI_ATTR void VKAPI_CALL
-    layer_vkCmdCopyAccelerationStructureKHR<user_tag>(VkCommandBuffer commandBuffer,
-                                                      const VkCopyAccelerationStructureInfoKHR* pInfo)
+    layer_vkCmdCopyMemoryIndirectKHR<user_tag>(VkCommandBuffer commandBuffer,
+                                               const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo)
+{
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    // The transfer size is stored in device memory, so it is not known here.
+    registerBufferTransfer(layer,
+                           commandBuffer,
+                           Tracker::LCSBufferTransfer::Type::copy_memory,
+                           -1);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL
+    layer_vkCmdCopyMemoryToImageIndirectKHR<user_tag>(VkCommandBuffer commandBuffer,
+                                                      const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo)
+{
+    LAYER_TRACE(__func__);
+
+    // Hold the lock to access layer-wide global store
+    std::unique_lock<std::mutex> lock {g_vulkanLock};
+    auto* layer = Device::retrieve(commandBuffer);
+
+    // The transfer size is stored in device memory, so it is not known here.
+    registerImageTransfer(layer,
+                          commandBuffer,
+                          Tracker::LCSImageTransfer::Type::copy_memory_to_image,
+                          -1);
+
+    // Release the lock to call into the driver
+    lock.unlock();
+    layer->driver.vkCmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo);
+    emitCPUTrap(*layer, commandBuffer);
+}
+
+/* See Vulkan API for documentation. */
+template<>
+VKAPI_ATTR void VKAPI_CALL layer_vkCmdCopyAccelerationStructureKHR<user_tag>(VkCommandBuffer commandBuffer,
+                                                                             const VkCopyAccelerationStructureInfoKHR* pInfo)
 {
     LAYER_TRACE(__func__);
 

layer_gpu_support/README_LAYER.md

@@ -121,18 +121,22 @@ convenience options to force disable or enable all serialization.
     "queue": false,           // Force cross-queue serialization of submits
     "queue_wait_idle": false, // Insert vkDeviceWaitIdle after submits
     "commandstream": {
+        "asbuild": {
+            "pre": false,   // Insert full barrier before acceleration structure builds
+            "post": false   // Insert full barrier after acceleration structure builds
+        },
         "compute": {
             "pre": false,   // Insert full barrier before dispatches
             "post": false   // Insert full barrier after dispatches
         },
+        "datagraph": {
+            "pre": false,   // Insert full barrier before data graph dispatches
+            "post": false   // Insert full barrier after data graph dispatches
+        },
         "renderpass": {
             "pre": false,   // Insert full barrier before render passes
             "post": false   // Insert full barrier after render passes
         },
-        "asbuild": {
-            "pre": false,   // Insert full barrier before acceleration structure builds
-            "post": false   // Insert full barrier after acceleration structure builds
-        },
         "tracerays": {
             "pre": false,   // Insert full barrier before trace rays
             "post": false   // Insert full barrier after trace rays
@@ -190,4 +194,4 @@ allocated and handled by the driver.
 
 - - -
 
-_Copyright © 2025, Arm Limited and contributors._
+_Copyright © 2025-2026, Arm Limited and contributors._