intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 14:55:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Initial support for oneAPI Level Zero

Browse Source 
Change-Id: I221df8427b1844237a4d9d900c58512706b0be0f
This commit is contained in:
Brandon Fliflet
2020-03-06 11:09:57 +01:00
committed by ocldev
parent 612f47ced3
commit 27f4bce42f
277 changed files with 27508 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
level_zero/tools/source/tracing/CMakeLists.txt Normal file
View File

@@ -0,0 +1,57 @@
#
# Copyright (C) 2019-2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
# DO NOT EDIT: Generated from "scripts/templates/CMakeLists.cpp.mako"
set(L0_SRCS_TOOLS_TRACING
${CMAKE_CURRENT_SOURCE_DIR}/tracing.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cl_interop_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cl_interop_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.h
)
target_include_directories(${TARGET_NAME_L0}
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/
)
target_sources(${TARGET_NAME_L0}
PRIVATE
${L0_SRCS_TOOLS_TRACING}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
# Make our source files visible to parent
set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_TRACING ${L0_SRCS_TOOLS_TRACING})

35
level_zero/tools/source/tracing/tracing.h Normal file
View File

@@ -0,0 +1,35 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zet_tracing.h>
struct _zet_tracer_handle_t {};
namespace L0 {
struct APITracer : _zet_tracer_handle_t {
static APITracer *create();
virtual ~APITracer() = default;
static APITracer *fromHandle(zet_tracer_handle_t handle) { return static_cast<APITracer *>(handle); }
inline zet_tracer_handle_t toHandle() { return this; }
virtual ze_result_t destroyTracer(zet_tracer_handle_t phTracer) = 0;
virtual ze_result_t setPrologues(zet_core_callbacks_t *pCoreCbs) = 0;
virtual ze_result_t setEpilogues(zet_core_callbacks_t *pCoreCbs) = 0;
virtual ze_result_t enableTracer(ze_bool_t enable) = 0;
};
ze_result_t createAPITracer(zet_driver_handle_t hDriver, const zet_tracer_desc_t *desc, zet_tracer_handle_t *phTracer);
struct APITracerContext {
virtual ~APITracerContext() = default;
virtual void *getActiveTracersList() = 0;
virtual void releaseActivetracersList() = 0;
};
} // namespace L0

107
level_zero/tools/source/tracing/tracing_barrier_imp.cpp Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendBarrier,
hCommandList,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_barrier_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendBarrierCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendBarrierCb_t, CommandList, pfnAppendBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryRangesBarrier_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numRanges,
const size_t *pRangeSizes,
const void **pRanges,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier,
hCommandList,
numRanges,
pRangeSizes,
pRanges,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_memory_ranges_barrier_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pnumRanges = &numRanges;
tracerParams.ppRangeSizes = &pRangeSizes;
tracerParams.ppRanges = &pRanges;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemoryRangesBarrierCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryRangesBarrierCb_t, CommandList, pfnAppendMemoryRangesBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pnumRanges,
*tracerParams.ppRangeSizes,
*tracerParams.ppRanges,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeDeviceSystemBarrier_Tracing(ze_device_handle_t hDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnSystemBarrier,
hDevice);
ze_device_system_barrier_params_t tracerParams;
tracerParams.phDevice = &hDevice;
L0::APITracerCallbackDataImp<ze_pfnDeviceSystemBarrierCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceSystemBarrierCb_t, Device, pfnSystemBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnSystemBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice);
}

27
level_zero/tools/source/tracing/tracing_barrier_imp.h Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryRangesBarrier_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numRanges,
const size_t *pRangeSizes,
const void **pRanges,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeDeviceSystemBarrier_Tracing(ze_device_handle_t hDevice);
}

107
level_zero/tools/source/tracing/tracing_cl_interop_imp.cpp Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLMemory_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_mem mem,
void **ptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLMemory,
hDevice,
context,
mem,
ptr);
ze_device_register_cl_memory_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pcontext = &context;
tracerParams.pmem = &mem;
tracerParams.pptr = &ptr;
L0::APITracerCallbackDataImp<ze_pfnDeviceRegisterCLMemoryCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceRegisterCLMemoryCb_t, Device, pfnRegisterCLMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLMemory,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pcontext,
*tracerParams.pmem,
*tracerParams.pptr);
}
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLProgram_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_program program,
ze_module_handle_t *phModule) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLProgram,
hDevice,
context,
program,
phModule);
ze_device_register_cl_program_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pcontext = &context;
tracerParams.pprogram = &program;
tracerParams.pphModule = &phModule;
L0::APITracerCallbackDataImp<ze_pfnDeviceRegisterCLProgramCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceRegisterCLProgramCb_t, Device, pfnRegisterCLProgramCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLProgram,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pcontext,
*tracerParams.pprogram,
*tracerParams.pphModule);
}
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLCommandQueue_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_command_queue commandQueue,
ze_command_queue_handle_t *phCommandQueue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLCommandQueue,
hDevice,
context,
commandQueue,
phCommandQueue);
ze_device_register_cl_command_queue_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pcontext = &context;
tracerParams.pcommand_queue = &commandQueue;
tracerParams.pphCommandQueue = &phCommandQueue;
L0::APITracerCallbackDataImp<ze_pfnDeviceRegisterCLCommandQueueCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceRegisterCLCommandQueueCb_t, Device, pfnRegisterCLCommandQueueCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnRegisterCLCommandQueue,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pcontext,
*tracerParams.pcommand_queue,
*tracerParams.pphCommandQueue);
}

29
level_zero/tools/source/tracing/tracing_cl_interop_imp.h Normal file
View File

@@ -0,0 +1,29 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLMemory_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_mem mem,
void **ptr);
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLProgram_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_program program,
ze_module_handle_t *phModule);
__zedllexport ze_result_t __zecall
zeDeviceRegisterCLCommandQueue_Tracing(ze_device_handle_t hDevice,
cl_context context,
cl_command_queue commandQueue,
ze_command_queue_handle_t *phCommandQueue);
}

128
level_zero/tools/source/tracing/tracing_cmdlist_imp.cpp Normal file
View File

@@ -0,0 +1,128 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeCommandListCreate_Tracing(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnCreate,
hDevice,
desc,
phCommandList);
ze_command_list_create_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &desc;
tracerParams.pphCommandList = &phCommandList;
L0::APITracerCallbackDataImp<ze_pfnCommandListCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCreateCb_t, CommandList, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.pphCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListCreateImmediate_Tracing(
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnCreateImmediate,
hDevice,
altdesc,
phCommandList);
ze_command_list_create_immediate_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.paltdesc = &altdesc;
tracerParams.pphCommandList = &phCommandList;
L0::APITracerCallbackDataImp<ze_pfnCommandListCreateImmediateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCreateImmediateCb_t, CommandList, pfnCreateImmediateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreateImmediate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.paltdesc,
*tracerParams.pphCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnDestroy, hCommandList);
ze_command_list_destroy_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
L0::APITracerCallbackDataImp<ze_pfnCommandListDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListDestroyCb_t, CommandList, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnClose, hCommandList);
ze_command_list_close_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
L0::APITracerCallbackDataImp<ze_pfnCommandListCloseCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCloseCb_t, CommandList, pfnCloseCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnClose,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnReset,
hCommandList);
ze_command_list_reset_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
L0::APITracerCallbackDataImp<ze_pfnCommandListResetCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListResetCb_t, CommandList, pfnResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList);
}

33
level_zero/tools/source/tracing/tracing_cmdlist_imp.h Normal file
View File

@@ -0,0 +1,33 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeCommandListCreate_Tracing(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList);
__zedllexport ze_result_t __zecall
zeCommandListCreateImmediate_Tracing(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList);
__zedllexport ze_result_t __zecall
zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList);
__zedllexport ze_result_t __zecall
zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList);
__zedllexport ze_result_t __zecall
zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList);
__zedllexport ze_result_t __zecall
zeCommandListResetParameters_Tracing(ze_command_list_handle_t hCommandList);
}

111
level_zero/tools/source/tracing/tracing_cmdqueue_imp.cpp Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeCommandQueueCreate_Tracing(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnCreate,
hDevice,
desc,
phCommandQueue);
ze_command_queue_create_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &desc;
tracerParams.pphCommandQueue = &phCommandQueue;
L0::APITracerCallbackDataImp<ze_pfnCommandQueueCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueCreateCb_t, CommandQueue, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.pphCommandQueue);
}
__zedllexport ze_result_t __zecall
zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy,
hCommandQueue);
ze_command_queue_destroy_params_t tracerParams;
tracerParams.phCommandQueue = &hCommandQueue;
L0::APITracerCallbackDataImp<ze_pfnCommandQueueDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueDestroyCb_t, CommandQueue, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandQueue);
}
__zedllexport ze_result_t __zecall
zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnExecuteCommandLists,
hCommandQueue,
numCommandLists,
phCommandLists,
hFence);
ze_command_queue_execute_command_lists_params_t tracerParams;
tracerParams.phCommandQueue = &hCommandQueue;
tracerParams.pnumCommandLists = &numCommandLists;
tracerParams.pphCommandLists = &phCommandLists;
tracerParams.phFence = &hFence;
L0::APITracerCallbackDataImp<ze_pfnCommandQueueExecuteCommandListsCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueExecuteCommandListsCb_t, CommandQueue, pfnExecuteCommandListsCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnExecuteCommandLists,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandQueue,
*tracerParams.pnumCommandLists,
*tracerParams.pphCommandLists,
*tracerParams.phFence);
}
__zedllexport ze_result_t __zecall
zeCommandQueueSynchronize_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize,
hCommandQueue,
timeout);
ze_command_queue_synchronize_params_t tracerParams;
tracerParams.phCommandQueue = &hCommandQueue;
tracerParams.ptimeout = &timeout;
L0::APITracerCallbackDataImp<ze_pfnCommandQueueSynchronizeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueSynchronizeCb_t, CommandQueue, pfnSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandQueue,
*tracerParams.ptimeout);
}

29
level_zero/tools/source/tracing/tracing_cmdqueue_imp.h Normal file
View File

@@ -0,0 +1,29 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeCommandQueueCreate_Tracing(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue);
__zedllexport ze_result_t __zecall
zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue);
__zedllexport ze_result_t __zecall
zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence);
__zedllexport ze_result_t __zecall
zeCommandQueueSynchronize_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t timeout);
}

358
level_zero/tools/source/tracing/tracing_copy_imp.cpp Normal file
View File

@@ -0,0 +1,358 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy,
hCommandList,
dstptr,
srcptr,
size,
hEvent);
ze_command_list_append_memory_copy_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pdstptr = &dstptr;
tracerParams.psrcptr = &srcptr;
tracerParams.psize = &size;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemoryCopyCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendMemoryCopyCb_t, CommandList, pfnAppendMemoryCopyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pdstptr,
*tracerParams.psrcptr,
*tracerParams.psize,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill,
hCommandList,
ptr,
pattern,
patternSize,
size,
hEvent);
ze_command_list_append_memory_fill_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pptr = &ptr;
tracerParams.ppattern = &pattern;
tracerParams.ppattern_size = &patternSize;
tracerParams.psize = &size;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemoryFillCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendMemoryFillCb_t, CommandList, pfnAppendMemoryFillCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pptr,
*tracerParams.ppattern,
*tracerParams.ppattern_size,
*tracerParams.psize,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryCopyRegion_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const ze_copy_region_t *dstRegion,
uint32_t dstPitch,
uint32_t dstSlicePitch,
const void *srcptr,
const ze_copy_region_t *srcRegion,
uint32_t srcPitch,
uint32_t srcSlicePitch,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion,
hCommandList,
dstptr,
dstRegion,
dstPitch,
dstSlicePitch,
srcptr,
srcRegion,
srcPitch,
srcSlicePitch,
hEvent);
ze_command_list_append_memory_copy_region_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pdstptr = &dstptr;
tracerParams.pdstRegion = &dstRegion;
tracerParams.pdstPitch = &dstPitch;
tracerParams.pdstSlicePitch = &dstSlicePitch;
tracerParams.psrcptr = &srcptr;
tracerParams.psrcRegion = &srcRegion;
tracerParams.psrcPitch = &srcPitch;
tracerParams.psrcSlicePitch = &srcSlicePitch;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemoryCopyRegionCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendMemoryCopyRegionCb_t, CommandList, pfnAppendMemoryCopyRegionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pdstptr,
*tracerParams.pdstRegion,
*tracerParams.pdstPitch,
*tracerParams.pdstSlicePitch,
*tracerParams.psrcptr,
*tracerParams.psrcRegion,
*tracerParams.psrcPitch,
*tracerParams.psrcSlicePitch,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy,
hCommandList,
hDstImage,
hSrcImage,
hEvent);
ze_command_list_append_image_copy_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phDstImage = &hDstImage;
tracerParams.phSrcImage = &hSrcImage;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendImageCopyCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendImageCopyCb_t, CommandList, pfnAppendImageCopyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phDstImage,
*tracerParams.phSrcImage,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyRegion_Tracing(
ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pDstRegion,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion,
hCommandList,
hDstImage,
hSrcImage,
pDstRegion,
pSrcRegion,
hEvent);
ze_command_list_append_image_copy_region_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phDstImage = &hDstImage;
tracerParams.phSrcImage = &hSrcImage;
tracerParams.ppDstRegion = &pDstRegion;
tracerParams.ppSrcRegion = &pSrcRegion;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendImageCopyRegionCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendImageCopyRegionCb_t, CommandList, pfnAppendImageCopyRegionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phDstImage,
*tracerParams.phSrcImage,
*tracerParams.ppDstRegion,
*tracerParams.ppSrcRegion,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyToMemory_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory,
hCommandList,
dstptr,
hSrcImage,
pSrcRegion,
hEvent);
ze_command_list_append_image_copy_to_memory_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pdstptr = &dstptr;
tracerParams.phSrcImage = &hSrcImage;
tracerParams.ppSrcRegion = &pSrcRegion;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendImageCopyToMemoryCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendImageCopyToMemoryCb_t, CommandList, pfnAppendImageCopyToMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pdstptr,
*tracerParams.phSrcImage,
*tracerParams.ppSrcRegion,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyFromMemory_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
const void *srcptr,
const ze_image_region_t *pDstRegion,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory,
hCommandList,
hDstImage,
srcptr,
pDstRegion,
hEvent);
ze_command_list_append_image_copy_from_memory_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phDstImage = &hDstImage;
tracerParams.psrcptr = &srcptr;
tracerParams.ppDstRegion = &pDstRegion;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendImageCopyFromMemoryCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendImageCopyFromMemoryCb_t, CommandList, pfnAppendImageCopyFromMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phDstImage,
*tracerParams.psrcptr,
*tracerParams.ppDstRegion,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch,
hCommandList,
ptr,
size);
ze_command_list_append_memory_prefetch_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pptr = &ptr;
tracerParams.psize = &size;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemoryPrefetchCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendMemoryPrefetchCb_t, CommandList, pfnAppendMemoryPrefetchCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pptr,
*tracerParams.psize);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendMemAdvise_Tracing(ze_command_list_handle_t hCommandList,
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemAdvise,
hCommandList,
hDevice,
ptr,
size,
advice);
ze_command_list_append_mem_advise_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phDevice = &hDevice;
tracerParams.pptr = &ptr;
tracerParams.psize = &size;
tracerParams.padvice = &advice;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendMemAdviseCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnCommandListAppendMemAdviseCb_t, CommandList, pfnAppendMemAdviseCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemAdvise,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phDevice,
*tracerParams.pptr,
*tracerParams.psize,
*tracerParams.padvice);
}

79
level_zero/tools/source/tracing/tracing_copy_imp.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryCopyRegion_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const ze_copy_region_t *dstRegion,
uint32_t dstPitch,
uint32_t dstSlicePitch,
const void *srcptr,
const ze_copy_region_t *srcRegion,
uint32_t srcPitch,
uint32_t srcSlicePitch,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyRegion_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pDstRegion,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyToMemory_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendImageCopyFromMemory_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
const void *srcptr,
const ze_image_region_t *pDstRegion,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size);
__zedllexport ze_result_t __zecall
zeCommandListAppendMemAdvise_Tracing(ze_command_list_handle_t hCommandList,
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice);
} // extern "C"

355
level_zero/tools/source/tracing/tracing_device_imp.cpp Normal file
View File

@@ -0,0 +1,355 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGet,
hDriver,
pCount,
phDevices);
ze_device_get_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.ppCount = &pCount;
tracerParams.pphDevices = &phDevices;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetCb_t, Device, pfnGetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGet,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.ppCount,
*tracerParams.pphDevices);
}
__zedllexport ze_result_t __zecall
zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetProperties,
hDevice,
pDeviceProperties);
ze_device_get_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppDeviceProperties = &pDeviceProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetPropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetPropertiesCb_t, Device, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppDeviceProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties,
hDevice,
pComputeProperties);
ze_device_get_compute_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppComputeProperties = &pComputeProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetComputePropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetComputePropertiesCb_t, Device, pfnGetComputePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppComputeProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_memory_properties_t *pMemProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryProperties,
hDevice,
pCount,
pMemProperties);
ze_device_get_memory_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppCount = &pCount;
tracerParams.ppMemProperties = &pMemProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetMemoryPropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetMemoryPropertiesCb_t, Device, pfnGetMemoryPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppCount,
*tracerParams.ppMemProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
ze_device_cache_properties_t *pCacheProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties,
hDevice,
pCacheProperties);
ze_device_get_cache_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppCacheProperties = &pCacheProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetCachePropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetCachePropertiesCb_t, Device, pfnGetCachePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppCacheProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties,
hDevice,
pImageProperties);
ze_device_get_image_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppImageProperties = &pImageProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetImagePropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetImagePropertiesCb_t, Device, pfnGetImagePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppImageProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices,
hDevice,
pCount,
phSubdevices);
ze_device_get_sub_devices_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppCount = &pCount;
tracerParams.pphSubdevices = &phSubdevices;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetSubDevicesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetSubDevicesCb_t, Device, pfnGetSubDevicesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppCount,
*tracerParams.pphSubdevices);
}
__zedllexport ze_result_t __zecall
zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetP2PProperties,
hDevice,
hPeerDevice,
pP2PProperties);
ze_device_get_p2_p_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.phPeerDevice = &hPeerDevice;
tracerParams.ppP2PProperties = &pP2PProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetP2PPropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetP2PPropertiesCb_t, Device, pfnGetP2PPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetP2PProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.phPeerDevice,
*tracerParams.ppP2PProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer,
hDevice,
hPeerDevice,
value);
ze_device_can_access_peer_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.phPeerDevice = &hPeerDevice;
tracerParams.pvalue = &value;
L0::APITracerCallbackDataImp<ze_pfnDeviceCanAccessPeerCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceCanAccessPeerCb_t, Device, pfnCanAccessPeerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.phPeerDevice,
*tracerParams.pvalue);
}
__zedllexport ze_result_t __zecall
zeKernelSetIntermediateCacheConfig_Tracing(ze_kernel_handle_t hKernel,
ze_cache_config_t cacheConfig) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetIntermediateCacheConfig,
hKernel,
cacheConfig);
ze_kernel_set_intermediate_cache_config_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pCacheConfig = &cacheConfig;
L0::APITracerCallbackDataImp<ze_pfnKernelSetIntermediateCacheConfigCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnKernelSetIntermediateCacheConfigCb_t, Kernel, pfnSetIntermediateCacheConfigCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetIntermediateCacheConfig,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pCacheConfig);
}
__zedllexport ze_result_t __zecall
zeDeviceSetLastLevelCacheConfig_Tracing(ze_device_handle_t hDevice,
ze_cache_config_t cacheConfig) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnSetLastLevelCacheConfig,
hDevice,
cacheConfig);
ze_device_set_last_level_cache_config_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pCacheConfig = &cacheConfig;
L0::APITracerCallbackDataImp<ze_pfnDeviceSetLastLevelCacheConfigCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceSetLastLevelCacheConfigCb_t, Device, pfnSetLastLevelCacheConfigCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnSetLastLevelCacheConfig,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pCacheConfig);
}
__zedllexport ze_result_t __zecall
zeDeviceGetKernelProperties_Tracing(ze_device_handle_t hDevice,
ze_device_kernel_properties_t *pKernelProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetKernelProperties,
hDevice,
pKernelProperties);
ze_device_get_kernel_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppKernelProperties = &pKernelProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetKernelPropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetKernelPropertiesCb_t, Device,
pfnGetKernelPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetKernelProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppKernelProperties);
}
__zedllexport ze_result_t __zecall
zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties,
hDevice,
pMemAccessProperties);
ze_device_get_memory_access_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.ppMemAccessProperties = &pMemAccessProperties;
L0::APITracerCallbackDataImp<ze_pfnDeviceGetMemoryAccessPropertiesCb_t> api_callbackData;
ZE_GEN_PER_API_CALLBACK_STATE(api_callbackData, ze_pfnDeviceGetMemoryAccessPropertiesCb_t, Device,
pfnGetMemoryAccessPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties,
&tracerParams,
api_callbackData.apiOrdinal,
api_callbackData.prologCallbacks,
api_callbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.ppMemAccessProperties);
}

68
level_zero/tools/source/tracing/tracing_device_imp.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices);
__zedllexport ze_result_t __zecall
zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_memory_properties_t *pMemProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
ze_device_cache_properties_t *pCacheProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices);
__zedllexport ze_result_t __zecall
zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties);
__zedllexport ze_result_t __zecall
zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value);
__zedllexport ze_result_t __zecall
zeKernelSetIntermediateCacheConfig_Tracing(ze_kernel_handle_t hKernel,
ze_cache_config_t cacheConfig);
__zedllexport ze_result_t __zecall
zeDeviceSetLastLevelCacheConfig_Tracing(ze_device_handle_t hDevice,
ze_cache_config_t cacheConfig);
__zedllexport ze_result_t __zecall
zeDeviceGetKernelProperties_Tracing(ze_device_handle_t hDevice,
ze_device_kernel_properties_t *pKernelProperties);
__zedllexport ze_result_t __zecall
zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties);
}

134
level_zero/tools/source/tracing/tracing_driver_imp.cpp Normal file
View File

@@ -0,0 +1,134 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeDriverGet_Tracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGet,
pCount,
phDrivers);
ze_driver_get_params_t tracerParams;
tracerParams.ppCount = &pCount;
tracerParams.pphDrivers = &phDrivers;
L0::APITracerCallbackDataImp<ze_pfnDriverGetCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetCb_t, Driver, pfnGetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGet,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.ppCount,
*tracerParams.pphDrivers);
}
__zedllexport ze_result_t __zecall
zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetProperties,
hDriver,
properties);
ze_driver_get_properties_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.ppDriverProperties = &properties;
L0::APITracerCallbackDataImp<ze_pfnDriverGetPropertiesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetPropertiesCb_t, Driver, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.ppDriverProperties);
}
__zedllexport ze_result_t __zecall
zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion, hDrivers, version);
ze_driver_get_api_version_params_t tracerParams;
tracerParams.phDriver = &hDrivers;
tracerParams.pversion = &version;
L0::APITracerCallbackDataImp<ze_pfnDriverGetApiVersionCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetApiVersionCb_t, Driver, pfnGetApiVersionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pversion);
}
__zedllexport ze_result_t __zecall
zeDriverGetIPCProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIPCProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetIPCProperties,
hDriver,
pIPCProperties);
ze_driver_get_ipc_properties_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.ppIPCProperties = &pIPCProperties;
L0::APITracerCallbackDataImp<ze_pfnDriverGetIPCPropertiesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetIPCPropertiesCb_t, Driver, pfnGetIPCPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetIPCProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.ppIPCProperties);
}
__zedllexport ze_result_t __zecall
zeDriverGetExtensionFunctionAddress_Tracing(ze_driver_handle_t hDriver,
const char *pFuncName,
void **pfunc) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionFunctionAddress,
hDriver,
pFuncName,
pfunc);
ze_driver_get_extension_function_address_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.ppFuncName = &pFuncName;
tracerParams.ppfunc = &pfunc;
L0::APITracerCallbackDataImp<ze_pfnDriverGetExtensionFunctionAddressCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetExtensionFunctionAddressCb_t, Driver, pfnGetExtensionFunctionAddressCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionFunctionAddress,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.ppFuncName,
*tracerParams.ppfunc);
}

32
level_zero/tools/source/tracing/tracing_driver_imp.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeDriverGet_Tracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers);
__zedllexport ze_result_t __zecall
zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties);
__zedllexport ze_result_t __zecall
zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version);
__zedllexport ze_result_t __zecall
zeDriverGetIPCProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIPCProperties);
__zedllexport ze_result_t __zecall
zeDriverGetExtensionFunctionAddress_Tracing(ze_driver_handle_t hDriver,
const char *pFuncName,
void **pfunc);
}

388
level_zero/tools/source/tracing/tracing_event_imp.cpp Normal file
View File

@@ -0,0 +1,388 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeEventPoolCreate_Tracing(ze_driver_handle_t hDriver,
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnCreate,
hDriver,
desc,
numDevices,
phDevices,
phEventPool);
ze_event_pool_create_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pdesc = &desc;
tracerParams.pnumDevices = &numDevices;
tracerParams.pphDevices = &phDevices;
tracerParams.pphEventPool = &phEventPool;
L0::APITracerCallbackDataImp<ze_pfnEventPoolCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolCreateCb_t, EventPool, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pdesc,
*tracerParams.pnumDevices,
*tracerParams.pphDevices,
*tracerParams.pphEventPool);
}
__zedllexport ze_result_t __zecall
zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnDestroy,
hEventPool);
ze_event_pool_destroy_params_t tracerParams;
tracerParams.phEventPool = &hEventPool;
L0::APITracerCallbackDataImp<ze_pfnEventPoolDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolDestroyCb_t, EventPool, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEventPool);
}
__zedllexport ze_result_t __zecall
zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
const ze_event_desc_t *desc,
ze_event_handle_t *phEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnCreate,
hEventPool,
desc,
phEvent);
ze_event_create_params_t tracerParams;
tracerParams.phEventPool = &hEventPool;
tracerParams.pdesc = &desc;
tracerParams.pphEvent = &phEvent;
L0::APITracerCallbackDataImp<ze_pfnEventCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventCreateCb_t, Event, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEventPool,
*tracerParams.pdesc,
*tracerParams.pphEvent);
}
__zedllexport ze_result_t __zecall
zeEventDestroy_Tracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnDestroy,
hEvent);
ze_event_destroy_params_t tracerParams;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnEventDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventDestroyCb_t, Event, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle,
hEventPool,
phIpc);
ze_event_pool_get_ipc_handle_params_t tracerParams;
tracerParams.phEventPool = &hEventPool;
tracerParams.pphIpc = &phIpc;
L0::APITracerCallbackDataImp<ze_pfnEventPoolGetIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolGetIpcHandleCb_t, EventPool, pfnGetIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEventPool,
*tracerParams.pphIpc);
}
__zedllexport ze_result_t __zecall
zeEventPoolOpenIpcHandle_Tracing(ze_driver_handle_t hDriver,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle,
hDriver,
hIpc,
phEventPool);
ze_event_pool_open_ipc_handle_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.phIpc = &hIpc;
tracerParams.pphEventPool = &phEventPool;
L0::APITracerCallbackDataImp<ze_pfnEventPoolOpenIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolOpenIpcHandleCb_t, EventPool, pfnOpenIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.phIpc,
*tracerParams.pphEventPool);
}
__zedllexport ze_result_t __zecall
zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle,
hEventPool);
ze_event_pool_close_ipc_handle_params_t tracerParams;
tracerParams.phEventPool = &hEventPool;
L0::APITracerCallbackDataImp<ze_pfnEventPoolCloseIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolCloseIpcHandleCb_t, EventPool, pfnCloseIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEventPool);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent,
hCommandList,
hEvent);
ze_command_list_append_signal_event_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendSignalEventCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendSignalEventCb_t, CommandList, pfnAppendSignalEventCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWaitOnEvents,
hCommandList,
numEvents,
phEvents);
ze_command_list_append_wait_on_events_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pnumEvents = &numEvents;
tracerParams.pphEvents = &phEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendWaitOnEventsCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendWaitOnEventsCb_t, CommandList, pfnAppendWaitOnEventsCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWaitOnEvents,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pnumEvents,
*tracerParams.pphEvents);
}
__zedllexport ze_result_t __zecall
zeEventHostSignal_Tracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostSignal,
hEvent);
ze_event_host_signal_params_t tracerParams;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnEventHostSignalCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostSignalCb_t, Event, pfnHostSignalCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSignal,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
uint32_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize,
hEvent,
timeout);
ze_event_host_synchronize_params_t tracerParams;
tracerParams.phEvent = &hEvent;
tracerParams.ptimeout = &timeout;
L0::APITracerCallbackDataImp<ze_pfnEventHostSynchronizeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostSynchronizeCb_t, Event, pfnHostSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent,
*tracerParams.ptimeout);
}
__zedllexport ze_result_t __zecall
zeEventQueryStatus_Tracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnQueryStatus,
hEvent);
ze_event_query_status_params_t tracerParams;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnEventQueryStatusCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventQueryStatusCb_t, Event, pfnQueryStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnQueryStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeEventHostReset_Tracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostReset,
hEvent);
ze_event_host_reset_params_t tracerParams;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnEventHostResetCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostResetCb_t, Event, pfnHostResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset,
hCommandList,
hEvent);
ze_command_list_append_event_reset_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phEvent = &hEvent;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendEventResetCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendEventResetCb_t,
CommandList, pfnAppendEventResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phEvent);
}
__zedllexport ze_result_t __zecall
zeEventGetTimestamp_Tracing(ze_event_handle_t hEvent,
ze_event_timestamp_type_t timestampType,
void *dstptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnGetTimestamp,
hEvent,
timestampType,
dstptr);
ze_event_get_timestamp_params_t tracerParams;
tracerParams.phEvent = &hEvent;
tracerParams.ptimestampType = &timestampType;
tracerParams.pdstptr = &dstptr;
L0::APITracerCallbackDataImp<ze_pfnEventGetTimestampCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventGetTimestampCb_t, Event, pfnGetTimestampCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnGetTimestamp,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phEvent,
*tracerParams.ptimestampType,
*tracerParams.pdstptr);
}

72
level_zero/tools/source/tracing/tracing_event_imp.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeEventPoolCreate_Tracing(ze_driver_handle_t hDriver,
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool);
__zedllexport ze_result_t __zecall
zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool);
__zedllexport ze_result_t __zecall
zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
const ze_event_desc_t *desc,
ze_event_handle_t *phEvent);
__zedllexport ze_result_t __zecall
zeEventDestroy_Tracing(ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc);
__zedllexport ze_result_t __zecall
zeEventPoolOpenIpcHandle_Tracing(ze_driver_handle_t hDriver,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool);
__zedllexport ze_result_t __zecall
zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool);
__zedllexport ze_result_t __zecall
zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents);
__zedllexport ze_result_t __zecall
zeEventHostSignal_Tracing(ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
uint32_t timeout);
__zedllexport ze_result_t __zecall
zeEventQueryStatus_Tracing(ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeEventHostReset_Tracing(ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent);
__zedllexport ze_result_t __zecall
zeEventGetTimestamp_Tracing(ze_event_handle_t hEvent,
ze_event_timestamp_type_t timestampType,
void *dstptr);
}

124
level_zero/tools/source/tracing/tracing_fence_imp.cpp Normal file
View File

@@ -0,0 +1,124 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
const ze_fence_desc_t *desc,
ze_fence_handle_t *phFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnCreate,
hCommandQueue,
desc,
phFence);
ze_fence_create_params_t tracerParams;
tracerParams.phCommandQueue = &hCommandQueue;
tracerParams.pdesc = &desc;
tracerParams.pphFence = &phFence;
L0::APITracerCallbackDataImp<ze_pfnFenceCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceCreateCb_t, Fence, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandQueue,
*tracerParams.pdesc,
*tracerParams.pphFence);
}
__zedllexport ze_result_t __zecall
zeFenceDestroy_Tracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnDestroy,
hFence);
ze_fence_destroy_params_t tracerParams;
tracerParams.phFence = &hFence;
L0::APITracerCallbackDataImp<ze_pfnFenceDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceDestroyCb_t, Fence, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phFence);
}
__zedllexport ze_result_t __zecall
zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
uint32_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize,
hFence,
timeout);
ze_fence_host_synchronize_params_t tracerParams;
tracerParams.phFence = &hFence;
tracerParams.ptimeout = &timeout;
L0::APITracerCallbackDataImp<ze_pfnFenceHostSynchronizeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceHostSynchronizeCb_t, Fence, pfnHostSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phFence,
*tracerParams.ptimeout);
}
__zedllexport ze_result_t __zecall
zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus,
hFence);
ze_fence_query_status_params_t tracerParams;
tracerParams.phFence = &hFence;
L0::APITracerCallbackDataImp<ze_pfnFenceQueryStatusCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceQueryStatusCb_t, Fence, pfnQueryStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phFence);
}
__zedllexport ze_result_t __zecall
zeFenceReset_Tracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnReset,
hFence);
ze_fence_reset_params_t tracerParams;
tracerParams.phFence = &hFence;
L0::APITracerCallbackDataImp<ze_pfnFenceResetCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceResetCb_t, Fence, pfnResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phFence);
}

29
level_zero/tools/source/tracing/tracing_fence_imp.h Normal file
View File

@@ -0,0 +1,29 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
const ze_fence_desc_t *desc,
ze_fence_handle_t *phFence);
__zedllexport ze_result_t __zecall
zeFenceDestroy_Tracing(ze_fence_handle_t hFence);
__zedllexport ze_result_t __zecall
zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
uint32_t timeout);
__zedllexport ze_result_t __zecall
zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence);
__zedllexport ze_result_t __zecall
zeFenceReset_Tracing(ze_fence_handle_t hFence);
}

28
level_zero/tools/source/tracing/tracing_global_imp.cpp Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeInit_Tracing(ze_init_flag_t flags) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Global.pfnInit,
flags);
ze_init_params_t tracerParams;
tracerParams.pflags = &flags;
L0::APITracerCallbackDataImp<ze_pfnInitCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnInitCb_t, Global, pfnInitCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Global.pfnInit,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.pflags);
}

14
level_zero/tools/source/tracing/tracing_global_imp.h Normal file
View File

@@ -0,0 +1,14 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeInit_Tracing(ze_init_flag_t flags);
}

87
level_zero/tools/source/tracing/tracing_image_imp.cpp Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_properties_t *pImageProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Image.pfnGetProperties,
hDevice,
desc,
pImageProperties);
ze_image_get_properties_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &desc;
tracerParams.ppImageProperties = &pImageProperties;
L0::APITracerCallbackDataImp<ze_pfnImageGetPropertiesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageGetPropertiesCb_t, Image, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.ppImageProperties);
}
__zedllexport ze_result_t __zecall
zeImageCreate_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Image.pfnCreate,
hDevice,
desc,
phImage);
ze_image_create_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &desc;
tracerParams.pphImage = &phImage;
L0::APITracerCallbackDataImp<ze_pfnImageCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageCreateCb_t, Image, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.pphImage);
}
__zedllexport ze_result_t __zecall
zeImageDestroy_Tracing(ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Image.pfnDestroy,
hImage);
ze_image_destroy_params_t tracerParams;
tracerParams.phImage = &hImage;
L0::APITracerCallbackDataImp<ze_pfnImageDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageDestroyCb_t, Image, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phImage);
}

24
level_zero/tools/source/tracing/tracing_image_imp.h Normal file
View File

@@ -0,0 +1,24 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_properties_t *pImageProperties);
__zedllexport ze_result_t __zecall
zeImageCreate_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage);
__zedllexport ze_result_t __zecall
zeImageDestroy_Tracing(ze_image_handle_t hImage);
}

345
level_zero/tools/source/tracing/tracing_imp.cpp Normal file
View File

@@ -0,0 +1,345 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
#include "shared/source/helpers/debug_helpers.h"
namespace L0 {
thread_local ze_bool_t tracingInProgress = 0;
bool tracingIsEnabled = false;
struct APITracerContextImp GLOBAL_APITracerContextImp;
struct APITracerContextImp *PGLOBAL_APITracerContextImp = &GLOBAL_APITracerContextImp;
APITracer *APITracer::create() {
APITracerImp *tracer = new APITracerImp;
tracer->tracingState = disabledState;
tracer->tracerFunctions = {};
UNRECOVERABLE_IF(tracer == nullptr);
return tracer;
}
ze_result_t createAPITracer(zet_driver_handle_t hDriver, const zet_tracer_desc_t *desc, zet_tracer_handle_t *phTracer) {
if (!PGLOBAL_APITracerContextImp->isTracingEnabled()) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
APITracerImp *tracer = static_cast<APITracerImp *>(APITracer::create());
tracer->tracerFunctions.pUserData = desc->pUserData;
*phTracer = tracer->toHandle();
return ZE_RESULT_SUCCESS;
}
ze_result_t APITracerImp::destroyTracer(zet_tracer_handle_t phTracer) {
APITracerImp *tracer = static_cast<APITracerImp *>(phTracer);
ze_result_t result = PGLOBAL_APITracerContextImp->finalizeDisableImpTracingWait(tracer);
if (result == ZE_RESULT_SUCCESS) {
delete L0::APITracer::fromHandle(phTracer);
}
return result;
}
ze_result_t APITracerImp::setPrologues(zet_core_callbacks_t *pCoreCbs) {
if (this->tracingState != disabledState) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
this->tracerFunctions.corePrologues = *pCoreCbs;
return ZE_RESULT_SUCCESS;
}
ze_result_t APITracerImp::setEpilogues(zet_core_callbacks_t *pCoreCbs) {
if (this->tracingState != disabledState) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
this->tracerFunctions.coreEpilogues = *pCoreCbs;
return ZE_RESULT_SUCCESS;
}
ze_result_t APITracerImp::enableTracer(ze_bool_t enable) {
return PGLOBAL_APITracerContextImp->enableTracingImp(this, enable);
}
static std::mutex perThreadTracerDataMutex;
static std::list<per_thread_tracer_data_t *> perThreadTracerDataList;
void ThreadPrivateTracerData::allocatePerThreadPublicTracerData() {
if (myThreadPublicTracerData == nullptr) {
myThreadPublicTracerData = new per_thread_tracer_data_t;
myThreadPublicTracerData->tracerArrayPointer.store(NULL, std::memory_order_relaxed);
myThreadPublicTracerData->thread_id = std::this_thread::get_id();
std::lock_guard<std::mutex> lock(perThreadTracerDataMutex);
perThreadTracerDataList.push_back(myThreadPublicTracerData);
}
}
void ThreadPrivateTracerData::freePerThreadPublicTracerData() {
//
// There is no need to hold a mutex when testing
// my_thread_tracer_data is a thread_local object.
// my_threadd_tracer_data for nullptr since it can only be done
// within the current thread's context.
// So there can be no other racing threads.
//
if (myThreadPublicTracerData != nullptr) {
std::lock_guard<std::mutex> lock(perThreadTracerDataMutex);
perThreadTracerDataList.remove(myThreadPublicTracerData);
delete myThreadPublicTracerData;
myThreadPublicTracerData = nullptr;
}
}
ThreadPrivateTracerData::ThreadPrivateTracerData() {
myThreadPublicTracerData = nullptr;
}
ThreadPrivateTracerData::~ThreadPrivateTracerData() {
freePerThreadPublicTracerData();
}
thread_local ThreadPrivateTracerData myThreadPrivateTracerData;
//
// This thread_local allows for an optimisation of the test_for_tracer_array_references()
// function. The optimization adds a test and branch, but it allows the common code path
// to avoid TWO out of line function calls.
//
// One function call is to call the constructor for the thread_private_tracer_data class.
// Note that this call is probably pretty heavy-weight, because it needs to be thread safe.
// It MUST include a mutex.
//
// The second function call we avoid is the call to the thread_private_tracer_data class's
// allocate memory member. It appears that at least with the Linux g++ compiler,
// the "inline" annotation on a member function is accepted at compile time, but does not
// change the code that is generated.
//
static thread_local bool myThreadPrivateTracerDataIsInitialized = false;
void APITracerContextImp::apiTracingEnable(ze_init_flag_t flag) {
if (driver_ddiTable.enableTracing) {
tracingIsEnabled = true;
}
}
void APITracerContextImp::enableTracing() { tracingIsEnabled = true; }
void APITracerContextImp::disableTracing() { tracingIsEnabled = false; }
bool APITracerContextImp::isTracingEnabled() { return tracingIsEnabled; }
//
// Walk the list of per-thread private data structures, testing
// whether any of them reference this array.
//
// Return 1 if a reference is found. Otherwise return 0.
//
ze_bool_t APITracerContextImp::testForTracerArrayReferences(tracer_array_t *tracerArray) {
std::list<per_thread_tracer_data_t *>::iterator itr;
for (itr = perThreadTracerDataList.begin();
itr != perThreadTracerDataList.end();
itr++) {
if ((*itr)->tracerArrayPointer.load(std::memory_order_relaxed) == tracerArray)
return 1;
}
return 0;
}
//
// Walk the retiring_tracer_array_list, checking each member of the list for
// references by per thread tracer array pointer. Delete and free
// each tracer array that has no per-thread references.
//
// Return the number of entries on the retiring tracer array list.
//
size_t APITracerContextImp::testAndFreeRetiredTracers() {
std::list<tracer_array_t *>::iterator itr = this->retiringTracerArrayList.begin();
while (itr != this->retiringTracerArrayList.end()) {
tracer_array_t *retiringTracerArray = *itr;
itr++;
if (testForTracerArrayReferences(retiringTracerArray))
continue;
this->retiringTracerArrayList.remove(retiringTracerArray);
delete[] retiringTracerArray->tracerArrayEntries;
delete retiringTracerArray;
}
return this->retiringTracerArrayList.size();
}
int APITracerContextImp::updateTracerArrays() {
tracer_array_t *newTracerArray;
size_t newTracerArrayCount = this->enabledTracerImpList.size();
if (newTracerArrayCount != 0) {
newTracerArray = new tracer_array_t;
newTracerArray->tracerArrayCount = newTracerArrayCount;
newTracerArray->tracerArrayEntries = new tracer_array_entry_t[newTracerArrayCount];
//
// iterate over the list of enabled tracers, copying their entries into the
// new tracer array
//
size_t i = 0;
std::list<struct APITracerImp *>::iterator itr;
for (itr = enabledTracerImpList.begin(); itr != enabledTracerImpList.end(); itr++) {
newTracerArray->tracerArrayEntries[i] = (*itr)->tracerFunctions;
i++;
}
} else {
newTracerArray = &emptyTracerArray;
}
//
// active_tracer_array.load can use memory_order_relaxed here because
// there is logically no transfer of other memory context between
// threads in this case.
//
tracer_array_t *active_tracer_array_shadow = activeTracerArray.load(std::memory_order_relaxed);
if (active_tracer_array_shadow != &emptyTracerArray) {
retiringTracerArrayList.push_back(active_tracer_array_shadow);
}
//
// This active_tracer_array.store must use memory_order_release.
// This store DOES signal a logical transfer of tracer state information
// from this thread to the tracing threads.
//
activeTracerArray.store(newTracerArray, std::memory_order_release);
testAndFreeRetiredTracers();
return 0;
}
ze_result_t APITracerContextImp::enableTracingImp(struct APITracerImp *tracerImp, ze_bool_t enable) {
std::lock_guard<std::mutex> lock(traceTableMutex);
ze_result_t result;
switch (tracerImp->tracingState) {
case disabledState:
if (enable) {
enabledTracerImpList.push_back(tracerImp);
tracerImp->tracingState = enabledState;
updateTracerArrays();
}
result = ZE_RESULT_SUCCESS;
break;
case enabledState:
if (!enable) {
enabledTracerImpList.remove(tracerImp);
tracerImp->tracingState = disabledWaitingState;
updateTracerArrays();
}
result = ZE_RESULT_SUCCESS;
break;
case disabledWaitingState:
result = ZE_RESULT_ERROR_UNINITIALIZED;
break;
default:
result = ZE_RESULT_ERROR_UNINITIALIZED;
UNRECOVERABLE_IF(true);
break;
}
return result;
}
// This is called by the destroy tracer method.
//
// This routine will return ZE_RESULT_SUCCESS
// state if either it has never been enabled,
// or if it has been enabled and then disabled.
//
// On ZE_RESULT_SUCESS, the destroy tracer method
// can free the tracer's memory.
//
// ZE_RESULT_ERROR_UNINITIALIZED is returned
// if the tracer has been enabled but not
// disabled. The destroy tracer method
// should NOT free this tracer's memory.
//
ze_result_t APITracerContextImp::finalizeDisableImpTracingWait(struct APITracerImp *tracerImp) {
std::lock_guard<std::mutex> lock(traceTableMutex);
ze_result_t result;
switch (tracerImp->tracingState) {
case disabledState:
result = ZE_RESULT_SUCCESS;
break;
case enabledState:
result = ZE_RESULT_ERROR_UNINITIALIZED;
break;
case disabledWaitingState:
while (testAndFreeRetiredTracers() != 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
tracerImp->tracingState = disabledState;
result = ZE_RESULT_SUCCESS;
break;
default:
result = ZE_RESULT_ERROR_UNINITIALIZED;
UNRECOVERABLE_IF(true);
break;
}
return result;
}
//
// For an explanation of this function and the reason for its while loop,
// see the comments at the top of this file.
//
void *APITracerContextImp::getActiveTracersList() {
tracer_array_t *stableTracerArray = NULL;
//
// This test and branch allows us to avoid TWO function calls. One call is for the
// constructor for my_thread_private_tracer_data. The other is to avoid the function
// call to allocate_per_thread_tracer_data().
//
// Since my_thread_private_tracer_data_is_initialized and my_thread_private_tracer_data are
// thread_local, there is no thread safety issue here. Each thread will find
// my_thread_private_tracer_data_is_initialized to be "false" at most once.
//
if (!myThreadPrivateTracerDataIsInitialized) {
myThreadPrivateTracerData.allocatePerThreadPublicTracerData();
myThreadPrivateTracerDataIsInitialized = true;
}
do {
//
// This read of active_tracer_array DOES logically signal a transfer
// of tracer structure information from the threader enable/disable/destroy
// thread to this tracing thread. So it must use memory_order_acquire
//
stableTracerArray = PGLOBAL_APITracerContextImp->activeTracerArray.load(std::memory_order_acquire);
myThreadPrivateTracerData.myThreadPublicTracerData->tracerArrayPointer.store(stableTracerArray, std::memory_order_relaxed);
//
// This read of active_tracer_array does NOT transfer any information
// that was not already transferred by the previous read within this loop.
// So it can use memory_order_relaxed.
//
} while (stableTracerArray !=
PGLOBAL_APITracerContextImp->activeTracerArray.load(std::memory_order_relaxed));
return (void *)stableTracerArray;
}
void APITracerContextImp::releaseActivetracersList() {
myThreadPrivateTracerData.myThreadPublicTracerData->tracerArrayPointer.store(NULL, std::memory_order_relaxed);
}
} // namespace L0

212
level_zero/tools/source/tracing/tracing_imp.h Normal file
View File

@@ -0,0 +1,212 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/tools/source/tracing/tracing.h"
#include "level_zero/tools/source/tracing/tracing_barrier_imp.h"
#include "level_zero/tools/source/tracing/tracing_cl_interop_imp.h"
#include "level_zero/tools/source/tracing/tracing_cmdlist_imp.h"
#include "level_zero/tools/source/tracing/tracing_cmdqueue_imp.h"
#include "level_zero/tools/source/tracing/tracing_copy_imp.h"
#include "level_zero/tools/source/tracing/tracing_device_imp.h"
#include "level_zero/tools/source/tracing/tracing_driver_imp.h"
#include "level_zero/tools/source/tracing/tracing_event_imp.h"
#include "level_zero/tools/source/tracing/tracing_fence_imp.h"
#include "level_zero/tools/source/tracing/tracing_global_imp.h"
#include "level_zero/tools/source/tracing/tracing_image_imp.h"
#include "level_zero/tools/source/tracing/tracing_memory_imp.h"
#include "level_zero/tools/source/tracing/tracing_module_imp.h"
#include "level_zero/tools/source/tracing/tracing_residency_imp.h"
#include "level_zero/tools/source/tracing/tracing_sampler_imp.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include "ze_ddi_tables.h"
#include <atomic>
#include <chrono>
#include <list>
#include <mutex>
#include <thread>
#include <vector>
extern ze_gpu_driver_dditable_t driver_ddiTable;
namespace L0 {
extern thread_local ze_bool_t tracingInProgress;
extern struct APITracerContextImp *PGLOBAL_APITracerContextImp;
typedef struct tracer_array_entry {
zet_core_callbacks_t corePrologues;
zet_core_callbacks_t coreEpilogues;
zet_device_handle_t hDevice;
void *pUserData;
} tracer_array_entry_t;
typedef struct tracerArray {
size_t tracerArrayCount;
tracer_array_entry_t *tracerArrayEntries;
} tracer_array_t;
typedef struct per_thread_public_tracer_data {
std::atomic<tracer_array_t *> tracerArrayPointer;
std::thread::id thread_id;
} per_thread_tracer_data_t;
class ThreadPrivateTracerData {
public:
per_thread_tracer_data_t *myThreadPublicTracerData;
void allocatePerThreadPublicTracerData();
void freePerThreadPublicTracerData();
ThreadPrivateTracerData();
~ThreadPrivateTracerData();
private:
ThreadPrivateTracerData(const ThreadPrivateTracerData &);
ThreadPrivateTracerData &operator=(const ThreadPrivateTracerData &);
};
extern thread_local ThreadPrivateTracerData myThreadPrivateTracerData;
typedef enum tracingState {
disabledState, // tracing has never been enabled
enabledState, // tracing is enabled.
disabledWaitingState, // tracing has been disabled, but not waited for
} tracingState_t;
struct APITracerImp : APITracer {
ze_result_t destroyTracer(zet_tracer_handle_t phTracer) override;
ze_result_t setPrologues(zet_core_callbacks_t *pCoreCbs) override;
ze_result_t setEpilogues(zet_core_callbacks_t *pCoreCbs) override;
ze_result_t enableTracer(ze_bool_t enable) override;
tracer_array_entry_t tracerFunctions;
tracingState_t tracingState;
private:
};
struct APITracerContextImp : APITracerContext {
public:
APITracerContextImp() {
activeTracerArray.store(&emptyTracerArray, std::memory_order_relaxed);
};
~APITracerContextImp() override {}
static void apiTracingEnable(ze_init_flag_t flag);
void *getActiveTracersList() override;
void releaseActivetracersList() override;
ze_result_t enableTracingImp(struct APITracerImp *newTracer, ze_bool_t enable);
ze_result_t finalizeDisableImpTracingWait(struct APITracerImp *oldTracer);
void enableTracing();
void disableTracing();
bool isTracingEnabled();
private:
std::mutex traceTableMutex;
tracer_array_t emptyTracerArray = {0, NULL};
std::atomic<tracer_array_t *> activeTracerArray;
//
// a list of tracer arrays that were once active, but
// have been replaced by a new active array. These
// once-active tracer arrays may continue for some time
// to have references to them among the per-thread
// tracer array pointers.
//
std::list<tracer_array_t *> retiringTracerArrayList;
std::list<struct APITracerImp *> enabledTracerImpList;
ze_bool_t testForTracerArrayReferences(tracer_array_t *tracerArray);
size_t testAndFreeRetiredTracers();
int updateTracerArrays();
};
template <class T>
class APITracerCallbackStateImp {
public:
T current_api_callback;
void *pUserData;
};
template <class T>
class APITracerCallbackDataImp {
public:
T apiOrdinal = {};
std::vector<L0::APITracerCallbackStateImp<T>> prologCallbacks;
std::vector<L0::APITracerCallbackStateImp<T>> epilogCallbacks;
};
#define ZE_HANDLE_TRACER_RECURSION(ze_api_ptr, ...) \
do { \
if (L0::tracingInProgress) { \
return ze_api_ptr(__VA_ARGS__); \
} \
L0::tracingInProgress = 1; \
} while (0)
#define ZE_GEN_TRACER_ARRAY_ENTRY(callbackPtr, tracerArray, tracerArrayIndex, callbackType, callbackCategory, callbackFunction) \
do { \
callbackPtr = tracerArray->tracerArrayEntries[tracerArrayIndex].callbackType.callbackCategory.callbackFunction; \
} while (0)
#define ZE_GEN_PER_API_CALLBACK_STATE(perApiCallbackData, tracerType, callbackCategory, callbackFunctionType) \
L0::tracer_array_t *currentTracerArray; \
currentTracerArray = (L0::tracer_array_t *)L0::PGLOBAL_APITracerContextImp->getActiveTracersList(); \
for (size_t i = 0; i < currentTracerArray->tracerArrayCount; i++) { \
tracerType prologueCallbackPtr; \
tracerType epilogue_callback_ptr; \
ZE_GEN_TRACER_ARRAY_ENTRY(prologueCallbackPtr, currentTracerArray, i, corePrologues, callbackCategory, callbackFunctionType); \
ZE_GEN_TRACER_ARRAY_ENTRY(epilogue_callback_ptr, currentTracerArray, i, coreEpilogues, callbackCategory, callbackFunctionType); \
\
L0::APITracerCallbackStateImp<tracerType> prologCallback; \
prologCallback.current_api_callback = prologueCallbackPtr; \
prologCallback.pUserData = currentTracerArray->tracerArrayEntries[i].pUserData; \
perApiCallbackData.prologCallbacks.push_back(prologCallback); \
\
L0::APITracerCallbackStateImp<tracerType> epilogCallback; \
epilogCallback.current_api_callback = epilogue_callback_ptr; \
epilogCallback.pUserData = currentTracerArray->tracerArrayEntries[i].pUserData; \
perApiCallbackData.epilogCallbacks.push_back(epilogCallback); \
}
template <typename TFunction_pointer, typename TParams, typename TTracer, typename TTracerPrologCallbacks, typename TTracerEpilogCallbacks, typename... Args>
ze_result_t APITracerWrapperImp(TFunction_pointer zeApiPtr,
TParams paramsStruct,
TTracer apiOrdinal,
TTracerPrologCallbacks prologCallbacks,
TTracerEpilogCallbacks epilogCallbacks,
Args &&... args) {
ze_result_t ret = ZE_RESULT_SUCCESS;
std::vector<APITracerCallbackStateImp<TTracer>> *callbacks_prologs = &prologCallbacks;
std::vector<void *> ppTracerInstanceUserData;
ppTracerInstanceUserData.resize(callbacks_prologs->size());
for (size_t i = 0; i < callbacks_prologs->size(); i++) {
if (callbacks_prologs->at(i).current_api_callback != nullptr)
callbacks_prologs->at(i).current_api_callback(paramsStruct, ret, callbacks_prologs->at(i).pUserData, &ppTracerInstanceUserData[i]);
}
ret = zeApiPtr(args...);
std::vector<APITracerCallbackStateImp<TTracer>> *callbacksEpilogs = &epilogCallbacks;
for (size_t i = 0; i < callbacksEpilogs->size(); i++) {
if (callbacksEpilogs->at(i).current_api_callback != nullptr)
callbacksEpilogs->at(i).current_api_callback(paramsStruct, ret, callbacksEpilogs->at(i).pUserData, &ppTracerInstanceUserData[i]);
}
L0::tracingInProgress = 0;
L0::PGLOBAL_APITracerContextImp->releaseActivetracersList();
return ret;
}
} // namespace L0

308
level_zero/tools/source/tracing/tracing_memory_imp.cpp Normal file
View File

@@ -0,0 +1,308 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeDriverAllocSharedMem_Tracing(ze_driver_handle_t hDriver,
const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnAllocSharedMem,
hDriver,
deviceDesc,
hostDesc,
size,
alignment,
hDevice,
pptr);
ze_driver_alloc_shared_mem_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pdevice_desc = &deviceDesc;
tracerParams.phost_desc = &hostDesc;
tracerParams.psize = &size;
tracerParams.palignment = &alignment;
tracerParams.phDevice = &hDevice;
tracerParams.ppptr = &pptr;
L0::APITracerCallbackDataImp<ze_pfnDriverAllocSharedMemCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverAllocSharedMemCb_t, Driver, pfnAllocSharedMemCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnAllocSharedMem,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pdevice_desc,
*tracerParams.phost_desc,
*tracerParams.psize,
*tracerParams.palignment,
*tracerParams.phDevice,
*tracerParams.ppptr);
}
__zedllexport ze_result_t __zecall
zeDriverAllocDeviceMem_Tracing(ze_driver_handle_t hDriver,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnAllocDeviceMem,
hDriver,
deviceDesc,
size,
alignment,
hDevice,
pptr);
ze_driver_alloc_device_mem_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pdevice_desc = &deviceDesc;
tracerParams.psize = &size;
tracerParams.palignment = &alignment;
tracerParams.phDevice = &hDevice;
tracerParams.ppptr = &pptr;
L0::APITracerCallbackDataImp<ze_pfnDriverAllocDeviceMemCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverAllocDeviceMemCb_t, Driver, pfnAllocDeviceMemCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnAllocDeviceMem,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pdevice_desc,
*tracerParams.psize,
*tracerParams.palignment,
*tracerParams.phDevice,
*tracerParams.ppptr);
}
__zedllexport ze_result_t __zecall
zeDriverAllocHostMem_Tracing(ze_driver_handle_t hDriver,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnAllocHostMem,
hDriver,
hostDesc,
size,
alignment,
pptr);
ze_driver_alloc_host_mem_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.phost_desc = &hostDesc;
tracerParams.psize = &size;
tracerParams.palignment = &alignment;
tracerParams.ppptr = &pptr;
L0::APITracerCallbackDataImp<ze_pfnDriverAllocHostMemCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverAllocHostMemCb_t, Driver, pfnAllocHostMemCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnAllocHostMem,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.phost_desc,
*tracerParams.psize,
*tracerParams.palignment,
*tracerParams.ppptr);
}
__zedllexport ze_result_t __zecall
zeDriverFreeMem_Tracing(ze_driver_handle_t hDriver,
void *ptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnFreeMem,
hDriver,
ptr);
ze_driver_free_mem_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pptr = &ptr;
L0::APITracerCallbackDataImp<ze_pfnDriverFreeMemCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverFreeMemCb_t, Driver, pfnFreeMemCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnFreeMem,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pptr);
}
__zedllexport ze_result_t __zecall
zeDriverGetMemAllocProperties_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetMemAllocProperties,
hDriver,
ptr,
pMemAllocProperties,
phDevice);
ze_driver_get_mem_alloc_properties_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pptr = &ptr;
tracerParams.ppMemAllocProperties = &pMemAllocProperties;
tracerParams.pphDevice = &phDevice;
L0::APITracerCallbackDataImp<ze_pfnDriverGetMemAllocPropertiesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetMemAllocPropertiesCb_t, Driver, pfnGetMemAllocPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetMemAllocProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pptr,
*tracerParams.ppMemAllocProperties,
*tracerParams.pphDevice);
}
__zedllexport ze_result_t __zecall
zeDriverGetMemAddressRange_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
void **pBase,
size_t *pSize) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetMemAddressRange,
hDriver,
ptr,
pBase,
pSize);
ze_driver_get_mem_address_range_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pptr = &ptr;
tracerParams.ppBase = &pBase;
tracerParams.ppSize = &pSize;
L0::APITracerCallbackDataImp<ze_pfnDriverGetMemAddressRangeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetMemAddressRangeCb_t, Driver, pfnGetMemAddressRangeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetMemAddressRange,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pptr,
*tracerParams.ppBase,
*tracerParams.ppSize);
}
__zedllexport ze_result_t __zecall
zeDriverGetMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetMemIpcHandle,
hDriver,
ptr,
pIpcHandle);
ze_driver_get_mem_ipc_handle_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pptr = &ptr;
tracerParams.ppIpcHandle = &pIpcHandle;
L0::APITracerCallbackDataImp<ze_pfnDriverGetMemIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetMemIpcHandleCb_t, Driver, pfnGetMemIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetMemIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pptr,
*tracerParams.ppIpcHandle);
}
__zedllexport ze_result_t __zecall
zeDriverOpenMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flag_t flags,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnOpenMemIpcHandle, hDriver, hDevice, handle, flags, pptr);
ze_driver_open_mem_ipc_handle_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.phDevice = &hDevice;
tracerParams.phandle = &handle;
tracerParams.pflags = &flags;
tracerParams.ppptr = &pptr;
L0::APITracerCallbackDataImp<ze_pfnDriverOpenMemIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverOpenMemIpcHandleCb_t, Driver, pfnOpenMemIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnOpenMemIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.phDevice,
*tracerParams.phandle,
*tracerParams.pflags,
*tracerParams.ppptr);
}
__zedllexport ze_result_t __zecall
zeDriverCloseMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
const void *ptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnCloseMemIpcHandle,
hDriver,
ptr);
ze_driver_close_mem_ipc_handle_params_t tracerParams;
tracerParams.phDriver = &hDriver;
tracerParams.pptr = &ptr;
L0::APITracerCallbackDataImp<ze_pfnDriverCloseMemIpcHandleCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverCloseMemIpcHandleCb_t, Driver, pfnCloseMemIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnCloseMemIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDriver,
*tracerParams.pptr);
}

67
level_zero/tools/source/tracing/tracing_memory_imp.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeDriverAllocSharedMem_Tracing(ze_driver_handle_t hDriver,
const ze_device_mem_alloc_desc_t *deviceDesc,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr);
__zedllexport ze_result_t __zecall
zeDriverAllocDeviceMem_Tracing(ze_driver_handle_t hDriver,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr);
__zedllexport ze_result_t __zecall
zeDriverAllocHostMem_Tracing(ze_driver_handle_t hDriver,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr);
__zedllexport ze_result_t __zecall
zeDriverFreeMem_Tracing(ze_driver_handle_t hDriver,
void *ptr);
__zedllexport ze_result_t __zecall
zeDriverGetMemAllocProperties_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice);
__zedllexport ze_result_t __zecall
zeDriverGetMemAddressRange_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
void **pBase,
size_t *pSize);
__zedllexport ze_result_t __zecall
zeDriverGetMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle);
__zedllexport ze_result_t __zecall
zeDriverOpenMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flag_t flags,
void **pptr);
__zedllexport ze_result_t __zecall
zeDriverCloseMemIpcHandle_Tracing(ze_driver_handle_t hDriver,
const void *ptr);
}

685
level_zero/tools/source/tracing/tracing_module_imp.cpp Normal file
View File

@@ -0,0 +1,685 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeModuleCreate_Tracing(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnCreate,
hDevice,
desc,
phModule,
phBuildLog);
ze_module_create_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &desc;
tracerParams.pphModule = &phModule;
tracerParams.pphBuildLog = &phBuildLog;
L0::APITracerCallbackDataImp<ze_pfnModuleCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleCreateCb_t, Module, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.pphModule,
*tracerParams.pphBuildLog);
}
__zedllexport ze_result_t __zecall
zeModuleDestroy_Tracing(ze_module_handle_t hModule) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnDestroy,
hModule);
ze_module_destroy_params_t tracerParams;
tracerParams.phModule = &hModule;
L0::APITracerCallbackDataImp<ze_pfnModuleDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleDestroyCb_t, Module, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule);
}
__zedllexport ze_result_t __zecall
zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy,
hModuleBuildLog);
ze_module_build_log_destroy_params_t tracerParams;
tracerParams.phModuleBuildLog = &hModuleBuildLog;
L0::APITracerCallbackDataImp<ze_pfnModuleBuildLogDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleBuildLogDestroyCb_t, ModuleBuildLog, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModuleBuildLog);
}
__zedllexport ze_result_t __zecall
zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
char *pBuildLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString,
hModuleBuildLog,
pSize,
pBuildLog);
ze_module_build_log_get_string_params_t tracerParams;
tracerParams.phModuleBuildLog = &hModuleBuildLog;
tracerParams.ppSize = &pSize;
tracerParams.ppBuildLog = &pBuildLog;
L0::APITracerCallbackDataImp<ze_pfnModuleBuildLogGetStringCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleBuildLogGetStringCb_t, ModuleBuildLog, pfnGetStringCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModuleBuildLog,
*tracerParams.ppSize,
*tracerParams.ppBuildLog);
}
__zedllexport ze_result_t __zecall
zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary,
hModule,
pSize,
pModuleNativeBinary);
ze_module_get_native_binary_params_t tracerParams;
tracerParams.phModule = &hModule;
tracerParams.ppSize = &pSize;
tracerParams.ppModuleNativeBinary = &pModuleNativeBinary;
L0::APITracerCallbackDataImp<ze_pfnModuleGetNativeBinaryCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetNativeBinaryCb_t, Module, pfnGetNativeBinaryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule,
*tracerParams.ppSize,
*tracerParams.ppModuleNativeBinary);
}
__zedllexport ze_result_t __zecall
zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
const char *pGlobalName,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer,
hModule,
pGlobalName,
pptr);
ze_module_get_global_pointer_params_t tracerParams;
tracerParams.phModule = &hModule;
tracerParams.ppGlobalName = &pGlobalName;
tracerParams.ppptr = &pptr;
L0::APITracerCallbackDataImp<ze_pfnModuleGetGlobalPointerCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetGlobalPointerCb_t, Module, pfnGetGlobalPointerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule,
*tracerParams.ppGlobalName,
*tracerParams.ppptr);
}
__zedllexport ze_result_t __zecall
zeKernelCreate_Tracing(ze_module_handle_t hModule,
const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phKernel) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnCreate,
hModule,
desc,
phKernel);
ze_kernel_create_params_t tracerParams;
tracerParams.phModule = &hModule;
tracerParams.pdesc = &desc;
tracerParams.pphKernel = &phKernel;
L0::APITracerCallbackDataImp<ze_pfnKernelCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelCreateCb_t, Kernel, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule,
*tracerParams.pdesc,
*tracerParams.pphKernel);
}
__zedllexport ze_result_t __zecall
zeKernelDestroy_Tracing(ze_kernel_handle_t hKernel) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnDestroy,
hKernel);
ze_kernel_destroy_params_t tracerParams;
tracerParams.phKernel = &hKernel;
L0::APITracerCallbackDataImp<ze_pfnKernelDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelDestroyCb_t, Kernel, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel);
}
__zedllexport ze_result_t __zecall
zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer,
hModule,
pKernelName,
pfnFunction);
ze_module_get_function_pointer_params_t tracerParams;
tracerParams.phModule = &hModule;
tracerParams.ppFunctionName = &pKernelName;
tracerParams.ppfnFunction = &pfnFunction;
L0::APITracerCallbackDataImp<ze_pfnModuleGetFunctionPointerCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetFunctionPointerCb_t, Module, pfnGetFunctionPointerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule,
*tracerParams.ppFunctionName,
*tracerParams.ppfnFunction);
}
__zedllexport ze_result_t __zecall
zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hKernel,
uint32_t groupSizeX,
uint32_t groupSizeY,
uint32_t groupSizeZ) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetGroupSize,
hKernel,
groupSizeX,
groupSizeY,
groupSizeZ);
ze_kernel_set_group_size_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pgroupSizeX = &groupSizeX;
tracerParams.pgroupSizeY = &groupSizeY;
tracerParams.pgroupSizeZ = &groupSizeZ;
L0::APITracerCallbackDataImp<ze_pfnKernelSetGroupSizeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetGroupSizeCb_t, Kernel, pfnSetGroupSizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetGroupSize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pgroupSizeX,
*tracerParams.pgroupSizeY,
*tracerParams.pgroupSizeZ);
}
__zedllexport ze_result_t __zecall
zeKernelSuggestGroupSize_Tracing(ze_kernel_handle_t hKernel,
uint32_t globalSizeX,
uint32_t globalSizeY,
uint32_t globalSizeZ,
uint32_t *groupSizeX,
uint32_t *groupSizeY,
uint32_t *groupSizeZ) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestGroupSize,
hKernel,
globalSizeX,
globalSizeY,
globalSizeZ,
groupSizeX,
groupSizeY,
groupSizeZ);
ze_kernel_suggest_group_size_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pglobalSizeX = &globalSizeX;
tracerParams.pglobalSizeY = &globalSizeY;
tracerParams.pglobalSizeZ = &globalSizeZ;
tracerParams.pgroupSizeX = &groupSizeX;
tracerParams.pgroupSizeY = &groupSizeY;
tracerParams.pgroupSizeZ = &groupSizeZ;
L0::APITracerCallbackDataImp<ze_pfnKernelSuggestGroupSizeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSuggestGroupSizeCb_t, Kernel, pfnSuggestGroupSizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestGroupSize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pglobalSizeX,
*tracerParams.pglobalSizeY,
*tracerParams.pglobalSizeZ,
*tracerParams.pgroupSizeX,
*tracerParams.pgroupSizeY,
*tracerParams.pgroupSizeZ);
}
__zedllexport ze_result_t __zecall
zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hKernel,
uint32_t argIndex,
size_t argSize,
const void *pArgValue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue,
hKernel,
argIndex,
argSize,
pArgValue);
ze_kernel_set_argument_value_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pargIndex = &argIndex;
tracerParams.pargSize = &argSize;
tracerParams.ppArgValue = &pArgValue;
L0::APITracerCallbackDataImp<ze_pfnKernelSetArgumentValueCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetArgumentValueCb_t, Kernel, pfnSetArgumentValueCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pargIndex,
*tracerParams.pargSize,
*tracerParams.ppArgValue);
}
__zedllexport ze_result_t __zecall
zeKernelSetAttribute_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t size,
const void *pValue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetAttribute,
hKernel,
attr,
size,
pValue);
ze_kernel_set_attribute_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pattr = &attr;
tracerParams.psize = &size;
tracerParams.ppValue = &pValue;
L0::APITracerCallbackDataImp<ze_pfnKernelSetAttributeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetAttributeCb_t, Kernel, pfnSetAttributeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetAttribute,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pattr,
*tracerParams.psize,
*tracerParams.ppValue);
}
__zedllexport ze_result_t __zecall
zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties,
hKernel,
pKernelProperties);
ze_kernel_get_properties_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.ppKernelProperties = &pKernelProperties;
L0::APITracerCallbackDataImp<ze_pfnKernelGetPropertiesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetPropertiesCb_t, Kernel, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.ppKernelProperties);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchKernel_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hKernel,
const ze_group_count_t *pLaunchFuncArgs,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernel,
hCommandList,
hKernel,
pLaunchFuncArgs,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_launch_kernel_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phKernel = &hKernel;
tracerParams.ppLaunchFuncArgs = &pLaunchFuncArgs;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendLaunchKernelCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendLaunchKernelCb_t,
CommandList,
pfnAppendLaunchKernelCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernel,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phKernel,
*tracerParams.ppLaunchFuncArgs,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchKernelIndirect_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hKernel,
const ze_group_count_t *pLaunchArgumentsBuffer,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernelIndirect,
hCommandList,
hKernel,
pLaunchArgumentsBuffer,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_launch_kernel_indirect_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phKernel = &hKernel;
tracerParams.ppLaunchArgumentsBuffer = &pLaunchArgumentsBuffer;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendLaunchKernelIndirectCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendLaunchKernelIndirectCb_t,
CommandList,
pfnAppendLaunchKernelIndirectCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernelIndirect,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phKernel,
*tracerParams.ppLaunchArgumentsBuffer,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numKernels,
ze_kernel_handle_t *phKernels,
const uint32_t *pCountBuffer,
const ze_group_count_t *pLaunchArgumentsBuffer,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect,
hCommandList,
numKernels,
phKernels,
pCountBuffer,
pLaunchArgumentsBuffer,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_launch_multiple_kernels_indirect_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.pnumKernels = &numKernels;
tracerParams.pphKernels = &phKernels;
tracerParams.ppCountBuffer = &pCountBuffer;
tracerParams.ppLaunchArgumentsBuffer = &pLaunchArgumentsBuffer;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendLaunchMultipleKernelsIndirectCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendLaunchMultipleKernelsIndirectCb_t,
CommandList,
pfnAppendLaunchMultipleKernelsIndirectCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.pnumKernels,
*tracerParams.pphKernels,
*tracerParams.ppCountBuffer,
*tracerParams.ppLaunchArgumentsBuffer,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchCooperativeKernel_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hKernel,
const ze_group_count_t *pLaunchFuncArgs,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchCooperativeKernel,
hCommandList,
hKernel,
pLaunchFuncArgs,
hSignalEvent,
numWaitEvents,
phWaitEvents);
ze_command_list_append_launch_cooperative_kernel_params_t tracerParams;
tracerParams.phCommandList = &hCommandList;
tracerParams.phKernel = &hKernel;
tracerParams.ppLaunchFuncArgs = &pLaunchFuncArgs;
tracerParams.phSignalEvent = &hSignalEvent;
tracerParams.pnumWaitEvents = &numWaitEvents;
tracerParams.pphWaitEvents = &phWaitEvents;
L0::APITracerCallbackDataImp<ze_pfnCommandListAppendLaunchCooperativeKernelCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendLaunchCooperativeKernelCb_t,
CommandList, pfnAppendLaunchCooperativeKernelCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchCooperativeKernel,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phCommandList,
*tracerParams.phKernel,
*tracerParams.ppLaunchFuncArgs,
*tracerParams.phSignalEvent,
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
__zedllexport ze_result_t __zecall
zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames,
hModule,
pCount,
pNames);
ze_module_get_kernel_names_params_t tracerParams;
tracerParams.phModule = &hModule;
tracerParams.ppCount = &pCount;
tracerParams.ppNames = &pNames;
L0::APITracerCallbackDataImp<ze_pfnModuleGetKernelNamesCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetKernelNamesCb_t, Module, pfnGetKernelNamesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phModule,
*tracerParams.ppCount,
*tracerParams.ppNames);
}
__zedllexport ze_result_t __zecall
zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount,
hKernel,
totalGroupCount);
ze_kernel_suggest_max_cooperative_group_count_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.ptotalGroupCount = &totalGroupCount;
L0::APITracerCallbackDataImp<ze_pfnKernelSuggestMaxCooperativeGroupCountCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSuggestMaxCooperativeGroupCountCb_t,
Kernel, pfnSuggestMaxCooperativeGroupCountCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.ptotalGroupCount);
}
__zedllexport ze_result_t __zecall
zeKernelGetAttribute_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t *pSize,
void *pValue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetAttribute,
hKernel,
attr,
pSize,
pValue);
ze_kernel_get_attribute_params_t tracerParams;
tracerParams.phKernel = &hKernel;
tracerParams.pattr = &attr;
tracerParams.ppSize = &pSize;
tracerParams.ppValue = &pValue;
L0::APITracerCallbackDataImp<ze_pfnKernelGetAttributeCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetAttributeCb_t, Kernel, pfnGetAttributeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetAttribute,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phKernel,
*tracerParams.pattr,
*tracerParams.ppSize,
*tracerParams.ppValue);
}

131
level_zero/tools/source/tracing/tracing_module_imp.h Normal file
View File

@@ -0,0 +1,131 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeModuleCreate_Tracing(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog);
__zedllexport ze_result_t __zecall
zeModuleDestroy_Tracing(ze_module_handle_t hModule);
__zedllexport ze_result_t __zecall
zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog);
__zedllexport ze_result_t __zecall
zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
char *pBuildLog);
__zedllexport ze_result_t __zecall
zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary);
__zedllexport ze_result_t __zecall
zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
const char *pGlobalName,
void **pptr);
__zedllexport ze_result_t __zecall
zeKernelCreate_Tracing(ze_module_handle_t hModule,
const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phFunction);
__zedllexport ze_result_t __zecall
zeKernelDestroy_Tracing(ze_kernel_handle_t hFunction);
__zedllexport ze_result_t __zecall
zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction);
__zedllexport ze_result_t __zecall
zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hFunction,
uint32_t groupSizeX,
uint32_t groupSizeY,
uint32_t groupSizeZ);
__zedllexport ze_result_t __zecall
zeKernelSuggestGroupSize_Tracing(ze_kernel_handle_t hFunction,
uint32_t globalSizeX,
uint32_t globalSizeY,
uint32_t globalSizeZ,
uint32_t *groupSizeX,
uint32_t *groupSizeY,
uint32_t *groupSizeZ);
__zedllexport ze_result_t __zecall
zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hFunction,
uint32_t argIndex,
size_t argSize,
const void *pArgValue);
__zedllexport ze_result_t __zecall
zeKernelSetAttribute_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t size,
const void *pValue);
__zedllexport ze_result_t __zecall
zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties);
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchKernel_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hFunction,
const ze_group_count_t *pLaunchFuncArgs,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchKernelIndirect_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hFunction,
const ze_group_count_t *pLaunchArgumentsBuffer,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numFunctions,
ze_kernel_handle_t *phFunctions,
const uint32_t *pCountBuffer,
const ze_group_count_t *pLaunchArgumentsBuffer,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeCommandListAppendLaunchCooperativeKernel_Tracing(ze_command_list_handle_t hCommandList,
ze_kernel_handle_t hKernel,
const ze_group_count_t *pLaunchFuncArgs,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
__zedllexport ze_result_t __zecall
zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames);
__zedllexport ze_result_t __zecall
zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount);
__zedllexport ze_result_t __zecall
zeKernelGetAttribute_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t *pSize,
void *pValue);
}

114
level_zero/tools/source/tracing/tracing_residency_imp.cpp Normal file
View File

@@ -0,0 +1,114 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeDeviceMakeMemoryResident_Tracing(ze_device_handle_t hDevice,
void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnMakeMemoryResident,
hDevice,
ptr,
size);
ze_device_make_memory_resident_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pptr = &ptr;
tracerParams.psize = &size;
L0::APITracerCallbackDataImp<ze_pfnDeviceMakeMemoryResidentCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceMakeMemoryResidentCb_t, Device, pfnMakeMemoryResidentCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnMakeMemoryResident,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pptr,
*tracerParams.psize);
}
__zedllexport ze_result_t __zecall
zeDeviceEvictMemory_Tracing(ze_device_handle_t hDevice,
void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnEvictMemory,
hDevice,
ptr,
size);
ze_device_evict_memory_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pptr = &ptr;
tracerParams.psize = &size;
L0::APITracerCallbackDataImp<ze_pfnDeviceEvictMemoryCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceEvictMemoryCb_t, Device, pfnEvictMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnEvictMemory,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pptr,
*tracerParams.psize);
}
__zedllexport ze_result_t __zecall
zeDeviceMakeImageResident_Tracing(ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnMakeImageResident, hDevice, hImage);
ze_device_make_image_resident_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.phImage = &hImage;
L0::APITracerCallbackDataImp<ze_pfnDeviceMakeImageResidentCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceMakeImageResidentCb_t, Device, pfnMakeImageResidentCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnMakeImageResident,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.phImage);
}
__zedllexport ze_result_t __zecall
zeDeviceEvictImage_Tracing(ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnEvictImage,
hDevice,
hImage);
ze_device_evict_image_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.phImage = &hImage;
L0::APITracerCallbackDataImp<ze_pfnDeviceEvictImageCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceEvictImageCb_t, Device, pfnEvictImageCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnEvictImage,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.phImage);
}

30
level_zero/tools/source/tracing/tracing_residency_imp.h Normal file
View File

@@ -0,0 +1,30 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeDeviceMakeMemoryResident_Tracing(ze_device_handle_t hDevice,
void *ptr,
size_t size);
__zedllexport ze_result_t __zecall
zeDeviceEvictMemory_Tracing(ze_device_handle_t hDevice,
void *ptr,
size_t size);
__zedllexport ze_result_t __zecall
zeDeviceMakeImageResident_Tracing(ze_device_handle_t hDevice,
ze_image_handle_t hImage);
__zedllexport ze_result_t __zecall
zeDeviceEvictImage_Tracing(ze_device_handle_t hDevice,
ze_image_handle_t hImage);
} // extern "C"

58
level_zero/tools/source/tracing/tracing_sampler_imp.cpp Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tracing/tracing_imp.h"
__zedllexport ze_result_t __zecall
zeSamplerCreate_Tracing(ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Sampler.pfnCreate,
hDevice,
pDesc,
phSampler);
ze_sampler_create_params_t tracerParams;
tracerParams.phDevice = &hDevice;
tracerParams.pdesc = &pDesc;
tracerParams.pphSampler = &phSampler;
L0::APITracerCallbackDataImp<ze_pfnSamplerCreateCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnSamplerCreateCb_t, Sampler, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice,
*tracerParams.pdesc,
*tracerParams.pphSampler);
}
__zedllexport ze_result_t __zecall
zeSamplerDestroy_Tracing(ze_sampler_handle_t hSampler) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Sampler.pfnDestroy,
hSampler);
ze_sampler_destroy_params_t tracerParams;
tracerParams.phSampler = &hSampler;
L0::APITracerCallbackDataImp<ze_pfnSamplerDestroyCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnSamplerDestroyCb_t, Sampler, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phSampler);
}

19
level_zero/tools/source/tracing/tracing_sampler_imp.h Normal file
View File

@@ -0,0 +1,19 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
extern "C" {
__zedllexport ze_result_t __zecall
zeSamplerCreate_Tracing(ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
ze_sampler_handle_t *phSampler);
__zedllexport ze_result_t __zecall
zeSamplerDestroy_Tracing(ze_sampler_handle_t hSampler);
}