From 0109de8b38f85391fbd0936cb1deabcb22b6b440 Mon Sep 17 00:00:00 2001 From: ZhangLiang Date: Fri, 28 Nov 2025 07:41:34 +0000 Subject: [PATCH] vulkan debug-layer Signed-off-by: ZhangLiang Change-Id: Ieba5bc9d9ffae3081674a636531818a0303c58b4 --- loader/generated/vk_layer_dispatch_table.h | 1 + loader/generated/vulkan_header_ext_huawei.h | 81 ++++ openharmony/debug_trace_layer/BUILD.gn | 9 +- .../vk_debug_trace_layer.cpp | 352 ++++++++++++++++-- .../debug_trace_layer/vk_debug_trace_layer.h | 144 +++++++ 5 files changed, 553 insertions(+), 34 deletions(-) create mode 100644 loader/generated/vulkan_header_ext_huawei.h diff --git a/loader/generated/vk_layer_dispatch_table.h b/loader/generated/vk_layer_dispatch_table.h index 275cf42d..be8534a0 100644 --- a/loader/generated/vk_layer_dispatch_table.h +++ b/loader/generated/vk_layer_dispatch_table.h @@ -28,6 +28,7 @@ #pragma once #include +#include "vulkan_header_ext_huawei.h" #if !defined(PFN_GetPhysicalDeviceProcAddr) typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); diff --git a/loader/generated/vulkan_header_ext_huawei.h b/loader/generated/vulkan_header_ext_huawei.h new file mode 100644 index 00000000..5fc8b140 --- /dev/null +++ b/loader/generated/vulkan_header_ext_huawei.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2023-2023. All rights reserved. + * Description: vulkan api partial render extended function. Will delete when vulkan-headers heuristic + * Create: 2023/11/27 + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum VkStructureTypeHUAWEI { + VK_STRUCTURE_TYPE_BLUR_COLOR_FILTER_INFO_HUAWEI = VK_STRUCTURE_TYPE_MAX_ENUM - 15, + VK_STRUCTURE_TYPE_BLUR_NOISE_INFO_HUAWEI = VK_STRUCTURE_TYPE_MAX_ENUM - 14, + VK_STRUCTURE_TYPE_DRAW_BLUR_IMAGE_INFO_HUAWEI = VK_STRUCTURE_TYPE_MAX_ENUM - 13, + /* for hts/ffts semaphore */ + VK_STRUCTURE_TYPE_SEMAPHORE_EXT_CREATE_INFO_HUAWEI = VK_STRUCTURE_TYPE_MAX_ENUM - 11, + VK_STRUCTURE_TYPE_RENDER_PASS_DAMAGE_REGION_BEGIN_INFO_TYPE = VK_STRUCTURE_TYPE_MAX_ENUM - 7 +} VkstructureTypeHUAWEI; + +typedef struct VkRenderPassDamageRegionBeginInfo { + enum VkStructureTypeHUAWEI sType; + const void* pNext; + uint32_t regionCount; + const VkRect2D* regions; +} VkRenderPassDamageRegionBeginInfo; + +#define VK_HUAWEI_DRAW_BLUR_IMAGE 1 +#define VK_HUAWEI_DRAW_BLUR_IMAGE_SPEC_VERSION 10 +#define VK_HUAWEI_DRAW_BLUR_IMAGE_EXTENSION_NAME "VK_HUAWEI_draw_blur_image" +#define VK_HUAWEI_GPU_ERROR_RECOVER (-199999999) + +typedef enum VkBlurOriginTypeHUAWEI { + BLUR_ORIGIN_NONE_FLIP_HUAWEI = 0, + BLUR_ORIGIN_Y_AXIS_FLIP_HUAWEI = 1, +} VkBlurOriginTypeHUAWEI; + +typedef struct VkDrawBlurImageInfoHUAWEI { + enum VkStructureTypeHUAWEI sType; + const void* pNext; + float sigma; + VkBlurOriginTypeHUAWEI origin; + VkRect2D srcRegion; + VkRect2D dstRegion; + VkImageView srcImageView; +} VkDrawBlurImageInfoHUAWEI; + +typedef struct VkBlurNoiseInfoHUAWEI { + enum VkStructureTypeHUAWEI sType; + const void* pNext; + float noiseRatio; +} VkBlurNoiseInfoHUAWEI; + +typedef struct VkBlurColorFilterInfoHUAWEI { + enum VkStructureTypeHUAWEI sType; + const void* pNext; + float saturation; + float brightness; +} VkBlurColorFilterInfoHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawBlurImageHUAWEI)(VkCommandBuffer commandBuffer,\ + const VkDrawBlurImageInfoHUAWEI *drawBlurImageInfo); + +typedef VkResult (VKAPI_PTR *PFN_vkGetBlurImageSizeHUAWEI)(VkDevice device, \ + const VkDrawBlurImageInfoHUAWEI *drawBlurImageInfo, VkRect2D *pSize); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawBlurImageHUAWEI( + VkCommandBuffer commandBuffer, + const VkDrawBlurImageInfoHUAWEI* drawBlurImageInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetBlurImageSizeHUAWEI( + VkDevice device, + const VkDrawBlurImageInfoHUAWEI* drawBlurImageInfo, + VkRect2D* pSize); +#endif + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/openharmony/debug_trace_layer/BUILD.gn b/openharmony/debug_trace_layer/BUILD.gn index efc1dcf6..a5e4fffb 100644 --- a/openharmony/debug_trace_layer/BUILD.gn +++ b/openharmony/debug_trace_layer/BUILD.gn @@ -12,14 +12,14 @@ # limitations under the License. import("//build/ohos.gni") -import("//foundation/graphic/graphic_2d/graphic_config.gni") ## Build libvulkan_debug_trace.so {{{ ohos_shared_library("vulkan_debug_trace_layer") { sources = [ "vk_debug_trace_layer.cpp" ] include_dirs = [ "debug_trace_layer", - "include", + "../../loader", + "../../loader/generated" ] defines = [ "VK_NO_PROTOTYPES", @@ -32,13 +32,12 @@ ohos_shared_library("vulkan_debug_trace_layer") { "-g3", ] cflags_cc = [ "-std=c++17" ] - deps = [ "$graphic_2d_root/utils:scoped_bytrace" ] external_deps = [ "c_utils:utils", "hilog:libhilog", - "vulkan-headers:vulkan_headers", - "vulkan-loader:vulkan_loader", + "hitrace:hitrace_meter", + "vulkan-headers:vulkan_headers" ] output_name = "vulkan_debug" diff --git a/openharmony/debug_trace_layer/vk_debug_trace_layer.cpp b/openharmony/debug_trace_layer/vk_debug_trace_layer.cpp index 66a72764..9ec201b7 100644 --- a/openharmony/debug_trace_layer/vk_debug_trace_layer.cpp +++ b/openharmony/debug_trace_layer/vk_debug_trace_layer.cpp @@ -17,12 +17,12 @@ #include #include -#include #include #include #include -struct LayerData { +struct LayerData +{ VkInstance instance = VK_NULL_HANDLE; VkDevice device = VK_NULL_HANDLE; uint32_t instanceVersion = VK_API_VERSION_1_0; @@ -30,16 +30,16 @@ struct LayerData { std::unique_ptr instanceDispatchTable; std::unordered_map debugCallbacks; PFN_vkSetDeviceLoaderData fpSetDeviceLoaderData = nullptr; - std::bitset enabledExtensions; + // std::bitset enabledExtensions; }; typedef uintptr_t DispatchKey; static std::mutex g_layerDataMutex; static std::unordered_map g_layerDataMap; -static const VkLayerProperties g_layerProperties = { DEBUG_LAYER_NAME, VK_LAYER_API_VERSION, 1, "Vulkan Debug Layer" }; +static const VkLayerProperties g_layerProperties = {DEBUG_LAYER_NAME, VK_LAYER_API_VERSION, 1, "Vulkan Debug Layer"}; -template +template DispatchKey GetDispatchKey(const T object) { return reinterpret_cast(*reinterpret_cast(object)); @@ -93,10 +93,10 @@ void FreeLayerData(DispatchKey key) } } -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( - const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { - ScopedBytrace trace(__func__); + RS_TRACE_NAME(__func__); if (!pCreateInfo || !pAllocator || !pInstance) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -118,14 +118,13 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( LayerData* instanceLayerData = GetLayerData(GetDispatchKey(*pInstance)); instanceLayerData->instance = *pInstance; instanceLayerData->instanceDispatchTable = std::make_unique(); - layer_init_instance_dispatch_table( - *pInstance, instanceLayerData->instanceDispatchTable.get(), getInstanceProc); + layer_init_instance_dispatch_table(*pInstance, instanceLayerData->instanceDispatchTable.get(), getInstanceProc); return result; } VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { - ScopedBytrace trace(__func__); + RS_TRACE_NAME(__func__); if (instance == VK_NULL_HANDLE) { return; } @@ -137,9 +136,9 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati } VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { - ScopedBytrace trace(__func__); + RS_TRACE_NAME(__func__); if (!pCreateInfo || !pAllocator || !pDevice) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -162,7 +161,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, con PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chainInfo->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chainInfo->u.pLayerInfo->pfnNextGetDeviceProcAddr; PFN_vkCreateDevice fpCreateDevice = - (PFN_vkCreateDevice)fpGetInstanceProcAddr(gpuLayerData->instance, "vkCreateDevice"); + (PFN_vkCreateDevice)fpGetInstanceProcAddr(physicalDeviceData->instance, "vkCreateDevice"); if (fpCreateDevice == nullptr) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -191,15 +190,15 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, con VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { - ScopedBytrace trace(__func__); + RS_TRACE_NAME(__func__); DispatchKey deviceKey = GetDispatchKey(device); LayerData* deviceData = GetLayerData(deviceKey); deviceData->deviceDispatchTable->DestroyDevice(device, pAllocator); FreeLayerData(deviceKey); } -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( - const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) +VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, + VkExtensionProperties* pProperties) { if (pLayerName == nullptr || pCount == nullptr) { return VK_ERROR_LAYER_NOT_PRESENT; @@ -238,8 +237,9 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pCount } } -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) +VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char* pLayerName, uint32_t* pCount, + VkExtensionProperties* pProperties) { if (pLayerName == nullptr || pCount == nullptr) { return VK_ERROR_LAYER_NOT_PRESENT; @@ -259,10 +259,231 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( } } +VKAPI_ATTR VkResult VKAPI_CALL hook_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + RS_TRACE_NAME("hook_vkAllocateMemory"); + DispatchKey deviceKey = GetDispatchKey(device); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkFreeMemory(VkDevice device, VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator) +{ + RS_TRACE_NAME("hook_vkFreeMemory"); + + DispatchKey deviceKey = GetDispatchKey(device); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->FreeMemory(device, memory, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL hook_vkAllocateCommandBuffers(VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) +{ + RS_TRACE_NAME("hook_vkAllocateCommandBuffers"); + DispatchKey deviceKey = GetDispatchKey(device); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); +} + +VKAPI_ATTR VkResult VKAPI_CALL hook_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, + VkFence fence) +{ + RS_TRACE_NAME("hook_vkQueueSubmit"); + DispatchKey deviceKey = GetDispatchKey(queue); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->QueueSubmit(queue, submitCount, pSubmits, fence); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ + RS_TRACE_NAME("hook_vkFreeCommandBuffers"); + DispatchKey deviceKey = GetDispatchKey(device); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->FreeCommandBuffers(device, commandPool, commandBufferCount, + pCommandBuffers); +} + +VKAPI_ATTR VkResult VKAPI_CALL hook_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) +{ + RS_TRACE_NAME("hook_vkBeginCommandBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->BeginCommandBuffer(commandBuffer, pBeginInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL hook_vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + RS_TRACE_NAME("hook_vkEndCommandBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->EndCommandBuffer(commandBuffer); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, + VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + RS_TRACE_NAME("hook_vkCmdUpdateBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, + uint32_t regionCount, const VkBufferCopy* pRegions) +{ + RS_TRACE_NAME("hook_vkCmdCopyBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + return deviceData->deviceDispatchTable->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageCopy* pRegions) +{ + RS_TRACE_NAME("hook_vkCmdCopyImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, + regionCount, pRegions); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageBlit* pRegions, VkFilter filter) +{ + RS_TRACE_NAME("hook_vkCmdBlitImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, + regionCount, pRegions, filter); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, + VkImage dstImage, VkImageLayout dstImageLayout, + uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + RS_TRACE_NAME("hook_vkCmdCopyBufferToImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, + regionCount, pRegions); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkBuffer dstBuffer, + uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + RS_TRACE_NAME("hook_vkCmdCopyImageToBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, + regionCount, pRegions); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, + VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + RS_TRACE_NAME("hook_vkCmdFillBuffer"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, + VkImageLayout imageLayout, const VkClearColorValue* pColor, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + RS_TRACE_NAME("hook_vkCmdClearColorImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + RS_TRACE_NAME("hook_vkCmdClearDepthStencilImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, + rangeCount, pRanges); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, + const VkClearAttachment* pAttachments, uint32_t rectCount, + const VkClearRect* pRects) +{ + RS_TRACE_NAME("hook_vkCmdClearAttachments"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, + pRects); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, + VkImageLayout srcImageLayout, VkImage dstImage, + VkImageLayout dstImageLayout, uint32_t regionCount, + const VkImageResolve* pRegions) +{ + RS_TRACE_NAME("hook_vkCmdResolveImage"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, + regionCount, pRegions); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents) +{ + RS_TRACE_NAME("hook_vkCmdBeginRenderPass"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, + uint32_t firstVertex, uint32_t firstInstance) +{ + RS_TRACE_NAME("hook_vkCmdDraw"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, + uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, + uint32_t firstInstance) +{ + RS_TRACE_NAME("hook_vkCmdDrawIndexed"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, + firstInstance); +} + +VKAPI_ATTR void VKAPI_CALL hook_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + RS_TRACE_NAME("hook_vkCmdEndRenderPass"); + DispatchKey deviceKey = GetDispatchKey(commandBuffer); + LayerData* deviceData = GetLayerData(deviceKey); + deviceData->deviceDispatchTable->CmdEndRenderPass(commandBuffer); +} + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName) { - if (!funcName) - return nullptr; + if (!funcName) return nullptr; if (std::strcmp(funcName, "vkGetDeviceProcAddr") == 0) { return reinterpret_cast(GetDeviceProcAddr); @@ -270,6 +491,42 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, cons if (std::strcmp(funcName, "vkDestroyDevice") == 0) { return reinterpret_cast(DestroyDevice); } + if (strcmp("vkAllocateMemory", funcName) == 0) { + return reinterpret_cast(hook_vkAllocateMemory); + } + + if (!strcmp(funcName, "vkFreeMemory")) return reinterpret_cast(hook_vkFreeMemory); + if (!strcmp(funcName, "vkAllocateCommandBuffers")) + return reinterpret_cast(hook_vkAllocateCommandBuffers); + if (!strcmp(funcName, "vkFreeCommandBuffers")) + return reinterpret_cast(hook_vkFreeCommandBuffers); + if (!strcmp(funcName, "vkBeginCommandBuffer")) + return reinterpret_cast(hook_vkBeginCommandBuffer); + if (!strcmp(funcName, "vkEndCommandBuffer")) return reinterpret_cast(hook_vkEndCommandBuffer); + if (!strcmp(funcName, "vkQueueSubmit")) return reinterpret_cast(hook_vkQueueSubmit); + + if (!strcmp(funcName, "vkCmdCopyBuffer")) return reinterpret_cast(hook_vkCmdCopyBuffer); + if (!strcmp(funcName, "vkCmdCopyImage")) return reinterpret_cast(hook_vkCmdCopyImage); + if (!strcmp(funcName, "vkCmdBlitImage")) return reinterpret_cast(hook_vkCmdBlitImage); + if (!strcmp(funcName, "vkCmdCopyBufferToImage")) + return reinterpret_cast(hook_vkCmdCopyBufferToImage); + if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) + return reinterpret_cast(hook_vkCmdCopyImageToBuffer); + if (!strcmp(funcName, "vkCmdUpdateBuffer")) return reinterpret_cast(hook_vkCmdUpdateBuffer); + if (!strcmp(funcName, "vkCmdFillBuffer")) return reinterpret_cast(hook_vkCmdFillBuffer); + if (!strcmp(funcName, "vkCmdClearColorImage")) + return reinterpret_cast(hook_vkCmdClearColorImage); + if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) + return reinterpret_cast(hook_vkCmdClearDepthStencilImage); + if (!strcmp(funcName, "vkCmdClearAttachments")) + return reinterpret_cast(hook_vkCmdClearAttachments); + if (!strcmp(funcName, "vkCmdResolveImage")) return reinterpret_cast(hook_vkCmdResolveImage); + + if (!strcmp(funcName, "vkCmdEndRenderPass")) return reinterpret_cast(hook_vkCmdEndRenderPass); + if (!strcmp(funcName, "vkCmdDrawIndexed")) return reinterpret_cast(hook_vkCmdDrawIndexed); + if (!strcmp(funcName, "vkCmdDraw")) return reinterpret_cast(hook_vkCmdDraw); + if (!strcmp(funcName, "vkCmdBeginRenderPass")) + return reinterpret_cast(hook_vkCmdBeginRenderPass); LayerData* devData = GetLayerData(GetDispatchKey(device)); VkLayerDispatchTable* pTable = devData->deviceDispatchTable.get(); @@ -281,8 +538,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, cons VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName) { - if (!funcName) - return nullptr; + if (!funcName) return nullptr; if (std::strcmp(funcName, "vkGetInstanceProcAddr") == 0) { return reinterpret_cast(GetInstanceProcAddr); @@ -306,6 +562,43 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance return reinterpret_cast(EnumerateDeviceExtensionProperties); } + if (strcmp("vkAllocateMemory", funcName) == 0) { + return reinterpret_cast(hook_vkAllocateMemory); + } + + if (!strcmp(funcName, "vkFreeMemory")) return reinterpret_cast(hook_vkFreeMemory); + if (!strcmp(funcName, "vkAllocateCommandBuffers")) + return reinterpret_cast(hook_vkAllocateCommandBuffers); + if (!strcmp(funcName, "vkFreeCommandBuffers")) + return reinterpret_cast(hook_vkFreeCommandBuffers); + if (!strcmp(funcName, "vkBeginCommandBuffer")) + return reinterpret_cast(hook_vkBeginCommandBuffer); + if (!strcmp(funcName, "vkEndCommandBuffer")) return reinterpret_cast(hook_vkEndCommandBuffer); + if (!strcmp(funcName, "vkQueueSubmit")) return reinterpret_cast(hook_vkQueueSubmit); + + if (!strcmp(funcName, "vkCmdCopyBuffer")) return reinterpret_cast(hook_vkCmdCopyBuffer); + if (!strcmp(funcName, "vkCmdCopyImage")) return reinterpret_cast(hook_vkCmdCopyImage); + if (!strcmp(funcName, "vkCmdBlitImage")) return reinterpret_cast(hook_vkCmdBlitImage); + if (!strcmp(funcName, "vkCmdCopyBufferToImage")) + return reinterpret_cast(hook_vkCmdCopyBufferToImage); + if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) + return reinterpret_cast(hook_vkCmdCopyImageToBuffer); + if (!strcmp(funcName, "vkCmdUpdateBuffer")) return reinterpret_cast(hook_vkCmdUpdateBuffer); + if (!strcmp(funcName, "vkCmdFillBuffer")) return reinterpret_cast(hook_vkCmdFillBuffer); + if (!strcmp(funcName, "vkCmdClearColorImage")) + return reinterpret_cast(hook_vkCmdClearColorImage); + if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) + return reinterpret_cast(hook_vkCmdClearDepthStencilImage); + if (!strcmp(funcName, "vkCmdClearAttachments")) + return reinterpret_cast(hook_vkCmdClearAttachments); + if (!strcmp(funcName, "vkCmdResolveImage")) return reinterpret_cast(hook_vkCmdResolveImage); + + if (!strcmp(funcName, "vkCmdEndRenderPass")) return reinterpret_cast(hook_vkCmdEndRenderPass); + if (!strcmp(funcName, "vkCmdDrawIndexed")) return reinterpret_cast(hook_vkCmdDrawIndexed); + if (!strcmp(funcName, "vkCmdDraw")) return reinterpret_cast(hook_vkCmdDraw); + if (!strcmp(funcName, "vkCmdBeginRenderPass")) + return reinterpret_cast(hook_vkCmdBeginRenderPass); + LayerData* layerData = GetLayerData(GetDispatchKey(instance)); VkLayerInstanceDispatchTable* pTable = layerData->instanceDispatchTable.get(); if (pTable == nullptr) { @@ -331,8 +624,8 @@ DEBUG_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( return GetDeviceProcAddr(device, funcName); } -DEBUG_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( - VkInstance instance, const char* funcName) +DEBUG_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, + const char* funcName) { return GetInstanceProcAddr(instance, funcName); } @@ -343,14 +636,15 @@ DEBUG_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionPr return EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); } -DEBUG_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +DEBUG_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL +vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { return EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); } -DEBUG_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, VkLayerProperties* pProperties) +DEBUG_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { return EnumerateInstanceLayerProperties(pPropertyCount, pProperties); } diff --git a/openharmony/debug_trace_layer/vk_debug_trace_layer.h b/openharmony/debug_trace_layer/vk_debug_trace_layer.h index 20c996e7..67af63aa 100644 --- a/openharmony/debug_trace_layer/vk_debug_trace_layer.h +++ b/openharmony/debug_trace_layer/vk_debug_trace_layer.h @@ -19,6 +19,150 @@ #include "vk_dispatch_table_helper.h" #include "vk_layer_dispatch_table.h" +#ifndef ROSEN_TRACE_DISABLE +#include "hitrace_meter.h" +// deprecated:USE RS_TRACE_BEGIN_XXX instead +#define ROSEN_TRACE_BEGIN(tag, name) StartTrace(tag, name) +#define RS_TRACE_BEGIN(name) ROSEN_TRACE_BEGIN(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name) +// deprecated:USE RS_TRACE_END_XXX instead +#define ROSEN_TRACE_END(tag) FinishTrace(tag) +#define RS_TRACE_END() ROSEN_TRACE_END(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL) +#define RS_TRACE_NAME(name) HITRACE_METER_NAME(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name) +#define RS_TRACE_NAME_FMT(fmt, ...) \ + HITRACE_METER_FMT(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, fmt, ##__VA_ARGS__) +#define RS_ASYNC_TRACE_BEGIN(name, value) StartAsyncTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name, value) +#define RS_ASYNC_TRACE_END(name, value) FinishAsyncTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name, value) +#define RS_TRACE_INT(name, value) CountTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name, value) +#define RS_TRACE_FUNC() RS_TRACE_NAME(__func__) + +// DEBUG level +#define RS_TRACE_BEGIN_DEBUG(name, customArgs) \ + StartTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_END_DEBUG(name) \ + FinishTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP) +#define RS_TRACE_NAME_DEBUG(name, customArgs) \ + HITRACE_METER_NAME_EX(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_NAME_FMT_DEBUG(customArgs, fmt, ...) \ + HITRACE_METER_FMT_EX(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, \ + customArgs, fmt, ##__VA_ARGS__) +#define RS_ASYNC_TRACE_BEGIN_DEBUG(name, value, customCategory, customArgs) \ + StartAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, name, value, \ + customCategory, customArgs) +#define RS_ASYNC_TRACE_END_DEBUG(name, value) \ + FinishAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_INT_DEBUG(name, value) \ + CountTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_DEBUG, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_FUNC_DEBUG() RS_TRACE_NAME_DEBUG(__func__, "") + +// INFO level +#define RS_TRACE_BEGIN_INFO(name, customArgs) \ + StartTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_END_INFO(name) \ + FinishTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP) +#define RS_TRACE_NAME_INFO(name, customArgs) \ + HITRACE_METER_NAME_EX(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_NAME_FMT_INFO(customArgs, fmt, ...) \ + HITRACE_METER_FMT_EX(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, \ + customArgs, fmt, ##__VA_ARGS__) +#define RS_ASYNC_TRACE_BEGIN_INFO(name, value, customCategory, customArgs) \ + StartAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, name, value, \ + customCategory, customArgs) +#define RS_ASYNC_TRACE_END_INFO(name, value) \ + FinishAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_INT_INFO(name, value) \ + CountTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_INFO, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_FUNC_INFO() RS_TRACE_NAME_INFO(__func__, "") + +// CRITICAL level +#define RS_TRACE_BEGIN_CRITICAL(name, customArgs) \ + StartTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_END_CRITICAL(name) \ + FinishTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP) +#define RS_TRACE_NAME_CRITICAL(name, customArgs) \ + HITRACE_METER_NAME_EX(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_NAME_FMT_CRITICAL(customArgs, fmt, ...) \ + HITRACE_METER_FMT_EX(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, \ + customArgs, fmt, ##__VA_ARGS__) +#define RS_ASYNC_TRACE_BEGIN_CRITICAL(name, value, customCategory, customArgs) \ + StartAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, name, value, \ + customCategory, customArgs) +#define RS_ASYNC_TRACE_END_CRITICAL(name, value) \ + FinishAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_INT_CRITICAL(name, value) \ + CountTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_CRITICAL, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_FUNC_CRITICAL() RS_TRACE_NAME_CRITICAL(__func__, "") + +// COMMERCIAL level +#define RS_TRACE_BEGIN_COMMERCIAL(name, customArgs) \ + StartTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_END_COMMERCIAL(name) \ + FinishTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP) +#define RS_TRACE_NAME_COMMERCIAL(name, customArgs) \ + HITRACE_METER_NAME_EX(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, name, customArgs) +#define RS_TRACE_NAME_FMT_COMMERCIAL(customArgs, fmt, ...) \ + HITRACE_METER_FMT_EX(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, \ + customArgs, fmt, ##__VA_ARGS__) +#define RS_ASYNC_TRACE_BEGIN_COMMERCIAL(name, value, customCategory, customArgs) \ + StartAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, name, value, \ + customCategory, customArgs) +#define RS_ASYNC_TRACE_END_COMMERCIAL(name, value) \ + FinishAsyncTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_INT_COMMERCIAL(name, value) \ + CountTraceEx(HiTraceOutputLevel::HITRACE_LEVEL_COMMERCIAL, HITRACE_TAG_GRAPHIC_AGP, name, value) +#define RS_TRACE_FUNC_COMMERCIAL() RS_TRACE_NAME_COMMERCIAL(__func__, "") +#else +#define ROSEN_TRACE_BEGIN(tag, name) +#define RS_TRACE_BEGIN(name) +#define ROSEN_TRACE_END(tag) +#define RS_TRACE_END() +#define RS_TRACE_NAME(name) +#define RS_TRACE_NAME_FMT(fmt, ...) +#define RS_ASYNC_TRACE_BEGIN(name, value) +#define RS_ASYNC_TRACE_END(name, value) +#define RS_TRACE_INT(name, value) +#define RS_TRACE_FUNC() + +// DEBUG level +#define RS_TRACE_BEGIN_DEBUG(name, customArgs) +#define RS_TRACE_END_DEBUG(name) +#define RS_TRACE_NAME_DEBUG(name, customArgs) +#define RS_TRACE_NAME_FMT_DEBUG(customArgs, fmt, ...) +#define RS_ASYNC_TRACE_BEGIN_DEBUG(name, value, customCategory, customArgs) +#define RS_ASYNC_TRACE_END_DEBUG(name, value) +#define RS_TRACE_INT_DEBUG(name, value) +#define RS_TRACE_FUNC_DEBUG() + +// INFO level +#define RS_TRACE_BEGIN_INFO(name, customArgs) +#define RS_TRACE_END_INFO(name) +#define RS_TRACE_NAME_INFO(name, customArgs) +#define RS_TRACE_NAME_FMT_INFO(customArgs, fmt, ...) +#define RS_ASYNC_TRACE_BEGIN_INFO(name, value, customCategory, customArgs) +#define RS_ASYNC_TRACE_END_INFO(name, value) +#define RS_TRACE_INT_INFO(name, value) +#define RS_TRACE_FUNC_INFO() + +// CRITICAL level +#define RS_TRACE_BEGIN_CRITICAL(name, customArgs) +#define RS_TRACE_END_CRITICAL(name) +#define RS_TRACE_NAME_CRITICAL(name, customArgs) +#define RS_TRACE_NAME_FMT_CRITICAL(customArgs, fmt, ...) +#define RS_ASYNC_TRACE_BEGIN_CRITICAL(name, value, customCategory, customArgs) +#define RS_ASYNC_TRACE_END_CRITICAL(name, value) +#define RS_TRACE_INT_CRITICAL(name, value) +#define RS_TRACE_FUNC_CRITICAL() + +// COMMERCIAL level +#define RS_TRACE_BEGIN_COMMERCIAL(name, customArgs) +#define RS_TRACE_END_COMMERCIAL(name) +#define RS_TRACE_NAME_COMMERCIAL(name, customArgs) +#define RS_TRACE_NAME_FMT_COMMERCIAL(customArgs, fmt, ...) +#define RS_ASYNC_TRACE_BEGIN_COMMERCIAL(name, value, customCategory, customArgs) +#define RS_ASYNC_TRACE_END_COMMERCIAL(name, value) +#define RS_TRACE_INT_COMMERCIAL(name, value) +#define RS_TRACE_FUNC_COMMERCIAL() +#endif + #define DEBUG_LAYER_NAME "VK_LAYER_DEBUG_layer" #define VK_LAYER_API_VERSION VK_MAKE_VERSION(1, 0, 0)