intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 22:08:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: configure readability-identifier-naming.FunctionCase

Browse Source 
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Artur Harasimiuk
2022-05-16 14:06:56 +00:00
committed by Compute-Runtime-Automation
parent b3261a8e2b
commit 3f04769f07
178 changed files with 2560 additions and 2556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-tidy
View File

@@ -22,6 +22,8 @@ CheckOptions:
value: camelBack
- key: readability-identifier-naming.LocalVariableCase
value: camelBack
- key: readability-identifier-naming.FunctionCase
value: camelBack
- key: modernize-loop-convert.MaxCopySize
value: '16'
- key: modernize-loop-convert.MinConfidence

274
level_zero/api/core/ze_core_loader.cpp
View File

@@ -25,7 +25,7 @@ zeGetDriverProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGet = zeDriverGet;
pDdiTable->pfnGetApiVersion = zeDriverGetApiVersion;
@@ -35,11 +35,11 @@ zeGetDriverProcAddrTable(
pDdiTable->pfnGetExtensionFunctionAddress = zeDriverGetExtensionFunctionAddress;
driver_ddiTable.core_ddiTable.Driver = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnGet = zeDriverGet_Tracing;
pDdiTable->pfnGetApiVersion = zeDriverGetApiVersion_Tracing;
pDdiTable->pfnGetProperties = zeDriverGetProperties_Tracing;
pDdiTable->pfnGetIpcProperties = zeDriverGetIpcProperties_Tracing;
pDdiTable->pfnGetExtensionProperties = zeDriverGetExtensionProperties_Tracing;
pDdiTable->pfnGet = zeDriverGetTracing;
pDdiTable->pfnGetApiVersion = zeDriverGetApiVersionTracing;
pDdiTable->pfnGetProperties = zeDriverGetPropertiesTracing;
pDdiTable->pfnGetIpcProperties = zeDriverGetIpcPropertiesTracing;
pDdiTable->pfnGetExtensionProperties = zeDriverGetExtensionPropertiesTracing;
}
return result;
}
@@ -53,7 +53,7 @@ zeGetMemProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAllocShared = zeMemAllocShared;
@@ -68,15 +68,15 @@ zeGetMemProcAddrTable(
pDdiTable->pfnCloseIpcHandle = zeMemCloseIpcHandle;
driver_ddiTable.core_ddiTable.Mem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnAllocShared = zeMemAllocShared_Tracing;
pDdiTable->pfnAllocDevice = zeMemAllocDevice_Tracing;
pDdiTable->pfnAllocHost = zeMemAllocHost_Tracing;
pDdiTable->pfnFree = zeMemFree_Tracing;
pDdiTable->pfnGetAllocProperties = zeMemGetAllocProperties_Tracing;
pDdiTable->pfnGetAddressRange = zeMemGetAddressRange_Tracing;
pDdiTable->pfnGetIpcHandle = zeMemGetIpcHandle_Tracing;
pDdiTable->pfnOpenIpcHandle = zeMemOpenIpcHandle_Tracing;
pDdiTable->pfnCloseIpcHandle = zeMemCloseIpcHandle_Tracing;
pDdiTable->pfnAllocShared = zeMemAllocSharedTracing;
pDdiTable->pfnAllocDevice = zeMemAllocDeviceTracing;
pDdiTable->pfnAllocHost = zeMemAllocHostTracing;
pDdiTable->pfnFree = zeMemFreeTracing;
pDdiTable->pfnGetAllocProperties = zeMemGetAllocPropertiesTracing;
pDdiTable->pfnGetAddressRange = zeMemGetAddressRangeTracing;
pDdiTable->pfnGetIpcHandle = zeMemGetIpcHandleTracing;
pDdiTable->pfnOpenIpcHandle = zeMemOpenIpcHandleTracing;
pDdiTable->pfnCloseIpcHandle = zeMemCloseIpcHandleTracing;
}
return result;
}
@@ -91,7 +91,7 @@ zeGetContextProcAddrTable(
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeContextCreate;
@@ -106,14 +106,14 @@ zeGetContextProcAddrTable(
driver_ddiTable.core_ddiTable.Context = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeContextCreate_Tracing;
pDdiTable->pfnDestroy = zeContextDestroy_Tracing;
pDdiTable->pfnGetStatus = zeContextGetStatus_Tracing;
pDdiTable->pfnSystemBarrier = zeContextSystemBarrier_Tracing;
pDdiTable->pfnMakeMemoryResident = zeContextMakeMemoryResident_Tracing;
pDdiTable->pfnEvictMemory = zeContextEvictMemory_Tracing;
pDdiTable->pfnMakeImageResident = zeContextMakeImageResident_Tracing;
pDdiTable->pfnEvictImage = zeContextEvictImage_Tracing;
pDdiTable->pfnCreate = zeContextCreateTracing;
pDdiTable->pfnDestroy = zeContextDestroyTracing;
pDdiTable->pfnGetStatus = zeContextGetStatusTracing;
pDdiTable->pfnSystemBarrier = zeContextSystemBarrierTracing;
pDdiTable->pfnMakeMemoryResident = zeContextMakeMemoryResidentTracing;
pDdiTable->pfnEvictMemory = zeContextEvictMemoryTracing;
pDdiTable->pfnMakeImageResident = zeContextMakeImageResidentTracing;
pDdiTable->pfnEvictImage = zeContextEvictImageTracing;
}
return result;
}
@@ -128,7 +128,7 @@ zeGetPhysicalMemProcAddrTable(
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zePhysicalMemCreate;
@@ -136,8 +136,8 @@ zeGetPhysicalMemProcAddrTable(
driver_ddiTable.core_ddiTable.PhysicalMem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zePhysicalMemCreate_Tracing;
pDdiTable->pfnDestroy = zePhysicalMemDestroy_Tracing;
pDdiTable->pfnCreate = zePhysicalMemCreateTracing;
pDdiTable->pfnDestroy = zePhysicalMemDestroyTracing;
}
return result;
}
@@ -151,7 +151,7 @@ zeGetVirtualMemProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnReserve = zeVirtualMemReserve;
@@ -164,13 +164,13 @@ zeGetVirtualMemProcAddrTable(
driver_ddiTable.core_ddiTable.VirtualMem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnReserve = zeVirtualMemReserve_Tracing;
pDdiTable->pfnFree = zeVirtualMemFree_Tracing;
pDdiTable->pfnQueryPageSize = zeVirtualMemQueryPageSize_Tracing;
pDdiTable->pfnMap = zeVirtualMemMap_Tracing;
pDdiTable->pfnUnmap = zeVirtualMemUnmap_Tracing;
pDdiTable->pfnSetAccessAttribute = zeVirtualMemSetAccessAttribute_Tracing;
pDdiTable->pfnGetAccessAttribute = zeVirtualMemGetAccessAttribute_Tracing;
pDdiTable->pfnReserve = zeVirtualMemReserveTracing;
pDdiTable->pfnFree = zeVirtualMemFreeTracing;
pDdiTable->pfnQueryPageSize = zeVirtualMemQueryPageSizeTracing;
pDdiTable->pfnMap = zeVirtualMemMapTracing;
pDdiTable->pfnUnmap = zeVirtualMemUnmapTracing;
pDdiTable->pfnSetAccessAttribute = zeVirtualMemSetAccessAttributeTracing;
pDdiTable->pfnGetAccessAttribute = zeVirtualMemGetAccessAttributeTracing;
}
return result;
}
@@ -184,13 +184,13 @@ zeGetGlobalProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnInit = zeInit;
driver_ddiTable.core_ddiTable.Global = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnInit = zeInit_Tracing;
pDdiTable->pfnInit = zeInitTracing;
}
return result;
}
@@ -204,7 +204,7 @@ zeGetDeviceProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGet = zeDeviceGet;
@@ -227,20 +227,20 @@ zeGetDeviceProcAddrTable(
pDdiTable->pfnPciGetPropertiesExt = zeDevicePciGetPropertiesExt;
driver_ddiTable.core_ddiTable.Device = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnGet = zeDeviceGet_Tracing;
pDdiTable->pfnGetCommandQueueGroupProperties = zeDeviceGetCommandQueueGroupProperties_Tracing;
pDdiTable->pfnGetSubDevices = zeDeviceGetSubDevices_Tracing;
pDdiTable->pfnGetProperties = zeDeviceGetProperties_Tracing;
pDdiTable->pfnGetComputeProperties = zeDeviceGetComputeProperties_Tracing;
pDdiTable->pfnGetModuleProperties = zeDeviceGetModuleProperties_Tracing;
pDdiTable->pfnGetMemoryProperties = zeDeviceGetMemoryProperties_Tracing;
pDdiTable->pfnGetMemoryAccessProperties = zeDeviceGetMemoryAccessProperties_Tracing;
pDdiTable->pfnGetCacheProperties = zeDeviceGetCacheProperties_Tracing;
pDdiTable->pfnGetImageProperties = zeDeviceGetImageProperties_Tracing;
pDdiTable->pfnGetP2PProperties = zeDeviceGetP2PProperties_Tracing;
pDdiTable->pfnCanAccessPeer = zeDeviceCanAccessPeer_Tracing;
pDdiTable->pfnGetStatus = zeDeviceGetStatus_Tracing;
pDdiTable->pfnGetExternalMemoryProperties = zeDeviceGetExternalMemoryProperties_Tracing;
pDdiTable->pfnGet = zeDeviceGetTracing;
pDdiTable->pfnGetCommandQueueGroupProperties = zeDeviceGetCommandQueueGroupPropertiesTracing;
pDdiTable->pfnGetSubDevices = zeDeviceGetSubDevicesTracing;
pDdiTable->pfnGetProperties = zeDeviceGetPropertiesTracing;
pDdiTable->pfnGetComputeProperties = zeDeviceGetComputePropertiesTracing;
pDdiTable->pfnGetModuleProperties = zeDeviceGetModulePropertiesTracing;
pDdiTable->pfnGetMemoryProperties = zeDeviceGetMemoryPropertiesTracing;
pDdiTable->pfnGetMemoryAccessProperties = zeDeviceGetMemoryAccessPropertiesTracing;
pDdiTable->pfnGetCacheProperties = zeDeviceGetCachePropertiesTracing;
pDdiTable->pfnGetImageProperties = zeDeviceGetImagePropertiesTracing;
pDdiTable->pfnGetP2PProperties = zeDeviceGetP2PPropertiesTracing;
pDdiTable->pfnCanAccessPeer = zeDeviceCanAccessPeerTracing;
pDdiTable->pfnGetStatus = zeDeviceGetStatusTracing;
pDdiTable->pfnGetExternalMemoryProperties = zeDeviceGetExternalMemoryPropertiesTracing;
}
return result;
}
@@ -254,7 +254,7 @@ zeGetCommandQueueProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeCommandQueueCreate;
@@ -263,10 +263,10 @@ zeGetCommandQueueProcAddrTable(
pDdiTable->pfnSynchronize = zeCommandQueueSynchronize;
driver_ddiTable.core_ddiTable.CommandQueue = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeCommandQueueCreate_Tracing;
pDdiTable->pfnDestroy = zeCommandQueueDestroy_Tracing;
pDdiTable->pfnExecuteCommandLists = zeCommandQueueExecuteCommandLists_Tracing;
pDdiTable->pfnSynchronize = zeCommandQueueSynchronize_Tracing;
pDdiTable->pfnCreate = zeCommandQueueCreateTracing;
pDdiTable->pfnDestroy = zeCommandQueueDestroyTracing;
pDdiTable->pfnExecuteCommandLists = zeCommandQueueExecuteCommandListsTracing;
pDdiTable->pfnSynchronize = zeCommandQueueSynchronizeTracing;
}
return result;
}
@@ -280,7 +280,7 @@ zeGetCommandListProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAppendBarrier = zeCommandListAppendBarrier;
@@ -311,32 +311,32 @@ zeGetCommandListProcAddrTable(
pDdiTable->pfnAppendQueryKernelTimestamps = zeCommandListAppendQueryKernelTimestamps;
driver_ddiTable.core_ddiTable.CommandList = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnAppendBarrier = zeCommandListAppendBarrier_Tracing;
pDdiTable->pfnAppendMemoryRangesBarrier = zeCommandListAppendMemoryRangesBarrier_Tracing;
pDdiTable->pfnCreate = zeCommandListCreate_Tracing;
pDdiTable->pfnCreateImmediate = zeCommandListCreateImmediate_Tracing;
pDdiTable->pfnDestroy = zeCommandListDestroy_Tracing;
pDdiTable->pfnClose = zeCommandListClose_Tracing;
pDdiTable->pfnReset = zeCommandListReset_Tracing;
pDdiTable->pfnAppendMemoryCopy = zeCommandListAppendMemoryCopy_Tracing;
pDdiTable->pfnAppendMemoryCopyRegion = zeCommandListAppendMemoryCopyRegion_Tracing;
pDdiTable->pfnAppendMemoryFill = zeCommandListAppendMemoryFill_Tracing;
pDdiTable->pfnAppendImageCopy = zeCommandListAppendImageCopy_Tracing;
pDdiTable->pfnAppendImageCopyRegion = zeCommandListAppendImageCopyRegion_Tracing;
pDdiTable->pfnAppendImageCopyToMemory = zeCommandListAppendImageCopyToMemory_Tracing;
pDdiTable->pfnAppendImageCopyFromMemory = zeCommandListAppendImageCopyFromMemory_Tracing;
pDdiTable->pfnAppendMemoryPrefetch = zeCommandListAppendMemoryPrefetch_Tracing;
pDdiTable->pfnAppendMemAdvise = zeCommandListAppendMemAdvise_Tracing;
pDdiTable->pfnAppendSignalEvent = zeCommandListAppendSignalEvent_Tracing;
pDdiTable->pfnAppendWaitOnEvents = zeCommandListAppendWaitOnEvents_Tracing;
pDdiTable->pfnAppendEventReset = zeCommandListAppendEventReset_Tracing;
pDdiTable->pfnAppendLaunchKernel = zeCommandListAppendLaunchKernel_Tracing;
pDdiTable->pfnAppendLaunchCooperativeKernel = zeCommandListAppendLaunchCooperativeKernel_Tracing;
pDdiTable->pfnAppendLaunchKernelIndirect = zeCommandListAppendLaunchKernelIndirect_Tracing;
pDdiTable->pfnAppendLaunchMultipleKernelsIndirect = zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing;
pDdiTable->pfnAppendWriteGlobalTimestamp = zeCommandListAppendWriteGlobalTimestamp_Tracing;
pDdiTable->pfnAppendMemoryCopyFromContext = zeCommandListAppendMemoryCopyFromContext_Tracing;
pDdiTable->pfnAppendQueryKernelTimestamps = zeCommandListAppendQueryKernelTimestamps_Tracing;
pDdiTable->pfnAppendBarrier = zeCommandListAppendBarrierTracing;
pDdiTable->pfnAppendMemoryRangesBarrier = zeCommandListAppendMemoryRangesBarrierTracing;
pDdiTable->pfnCreate = zeCommandListCreateTracing;
pDdiTable->pfnCreateImmediate = zeCommandListCreateImmediateTracing;
pDdiTable->pfnDestroy = zeCommandListDestroyTracing;
pDdiTable->pfnClose = zeCommandListCloseTracing;
pDdiTable->pfnReset = zeCommandListResetTracing;
pDdiTable->pfnAppendMemoryCopy = zeCommandListAppendMemoryCopyTracing;
pDdiTable->pfnAppendMemoryCopyRegion = zeCommandListAppendMemoryCopyRegionTracing;
pDdiTable->pfnAppendMemoryFill = zeCommandListAppendMemoryFillTracing;
pDdiTable->pfnAppendImageCopy = zeCommandListAppendImageCopyTracing;
pDdiTable->pfnAppendImageCopyRegion = zeCommandListAppendImageCopyRegionTracing;
pDdiTable->pfnAppendImageCopyToMemory = zeCommandListAppendImageCopyToMemoryTracing;
pDdiTable->pfnAppendImageCopyFromMemory = zeCommandListAppendImageCopyFromMemoryTracing;
pDdiTable->pfnAppendMemoryPrefetch = zeCommandListAppendMemoryPrefetchTracing;
pDdiTable->pfnAppendMemAdvise = zeCommandListAppendMemAdviseTracing;
pDdiTable->pfnAppendSignalEvent = zeCommandListAppendSignalEventTracing;
pDdiTable->pfnAppendWaitOnEvents = zeCommandListAppendWaitOnEventsTracing;
pDdiTable->pfnAppendEventReset = zeCommandListAppendEventResetTracing;
pDdiTable->pfnAppendLaunchKernel = zeCommandListAppendLaunchKernelTracing;
pDdiTable->pfnAppendLaunchCooperativeKernel = zeCommandListAppendLaunchCooperativeKernelTracing;
pDdiTable->pfnAppendLaunchKernelIndirect = zeCommandListAppendLaunchKernelIndirectTracing;
pDdiTable->pfnAppendLaunchMultipleKernelsIndirect = zeCommandListAppendLaunchMultipleKernelsIndirectTracing;
pDdiTable->pfnAppendWriteGlobalTimestamp = zeCommandListAppendWriteGlobalTimestampTracing;
pDdiTable->pfnAppendMemoryCopyFromContext = zeCommandListAppendMemoryCopyFromContextTracing;
pDdiTable->pfnAppendQueryKernelTimestamps = zeCommandListAppendQueryKernelTimestampsTracing;
}
return result;
}
@@ -350,7 +350,7 @@ zeGetFenceProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeFenceCreate;
@@ -360,11 +360,11 @@ zeGetFenceProcAddrTable(
pDdiTable->pfnReset = zeFenceReset;
driver_ddiTable.core_ddiTable.Fence = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeFenceCreate_Tracing;
pDdiTable->pfnDestroy = zeFenceDestroy_Tracing;
pDdiTable->pfnHostSynchronize = zeFenceHostSynchronize_Tracing;
pDdiTable->pfnQueryStatus = zeFenceQueryStatus_Tracing;
pDdiTable->pfnReset = zeFenceReset_Tracing;
pDdiTable->pfnCreate = zeFenceCreateTracing;
pDdiTable->pfnDestroy = zeFenceDestroyTracing;
pDdiTable->pfnHostSynchronize = zeFenceHostSynchronizeTracing;
pDdiTable->pfnQueryStatus = zeFenceQueryStatusTracing;
pDdiTable->pfnReset = zeFenceResetTracing;
}
return result;
}
@@ -378,7 +378,7 @@ zeGetEventPoolProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeEventPoolCreate;
@@ -388,11 +388,11 @@ zeGetEventPoolProcAddrTable(
pDdiTable->pfnCloseIpcHandle = zeEventPoolCloseIpcHandle;
driver_ddiTable.core_ddiTable.EventPool = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeEventPoolCreate_Tracing;
pDdiTable->pfnDestroy = zeEventPoolDestroy_Tracing;
pDdiTable->pfnGetIpcHandle = zeEventPoolGetIpcHandle_Tracing;
pDdiTable->pfnOpenIpcHandle = zeEventPoolOpenIpcHandle_Tracing;
pDdiTable->pfnCloseIpcHandle = zeEventPoolCloseIpcHandle_Tracing;
pDdiTable->pfnCreate = zeEventPoolCreateTracing;
pDdiTable->pfnDestroy = zeEventPoolDestroyTracing;
pDdiTable->pfnGetIpcHandle = zeEventPoolGetIpcHandleTracing;
pDdiTable->pfnOpenIpcHandle = zeEventPoolOpenIpcHandleTracing;
pDdiTable->pfnCloseIpcHandle = zeEventPoolCloseIpcHandleTracing;
}
return result;
}
@@ -406,7 +406,7 @@ zeGetEventProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeEventCreate;
@@ -418,13 +418,13 @@ zeGetEventProcAddrTable(
pDdiTable->pfnQueryKernelTimestamp = zeEventQueryKernelTimestamp;
driver_ddiTable.core_ddiTable.Event = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeEventCreate_Tracing;
pDdiTable->pfnDestroy = zeEventDestroy_Tracing;
pDdiTable->pfnHostSignal = zeEventHostSignal_Tracing;
pDdiTable->pfnHostSynchronize = zeEventHostSynchronize_Tracing;
pDdiTable->pfnQueryStatus = zeEventQueryStatus_Tracing;
pDdiTable->pfnHostReset = zeEventHostReset_Tracing;
pDdiTable->pfnQueryKernelTimestamp = zeEventQueryKernelTimestamp_Tracing;
pDdiTable->pfnCreate = zeEventCreateTracing;
pDdiTable->pfnDestroy = zeEventDestroyTracing;
pDdiTable->pfnHostSignal = zeEventHostSignalTracing;
pDdiTable->pfnHostSynchronize = zeEventHostSynchronizeTracing;
pDdiTable->pfnQueryStatus = zeEventQueryStatusTracing;
pDdiTable->pfnHostReset = zeEventHostResetTracing;
pDdiTable->pfnQueryKernelTimestamp = zeEventQueryKernelTimestampTracing;
}
return result;
}
@@ -454,7 +454,7 @@ zeGetImageProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = zeImageGetProperties;
@@ -463,9 +463,9 @@ zeGetImageProcAddrTable(
pDdiTable->pfnGetAllocPropertiesExt = zeImageGetAllocPropertiesExt;
driver_ddiTable.core_ddiTable.Image = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnGetProperties = zeImageGetProperties_Tracing;
pDdiTable->pfnCreate = zeImageCreate_Tracing;
pDdiTable->pfnDestroy = zeImageDestroy_Tracing;
pDdiTable->pfnGetProperties = zeImageGetPropertiesTracing;
pDdiTable->pfnCreate = zeImageCreateTracing;
pDdiTable->pfnDestroy = zeImageDestroyTracing;
pDdiTable->pfnGetAllocPropertiesExt = zeImageGetAllocPropertiesExt;
}
return result;
@@ -480,7 +480,7 @@ zeGetModuleProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeModuleCreate;
@@ -493,14 +493,14 @@ zeGetModuleProcAddrTable(
pDdiTable->pfnGetProperties = zeModuleGetProperties;
driver_ddiTable.core_ddiTable.Module = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeModuleCreate_Tracing;
pDdiTable->pfnDestroy = zeModuleDestroy_Tracing;
pDdiTable->pfnGetNativeBinary = zeModuleGetNativeBinary_Tracing;
pDdiTable->pfnDynamicLink = zeModuleDynamicLink_Tracing;
pDdiTable->pfnGetGlobalPointer = zeModuleGetGlobalPointer_Tracing;
pDdiTable->pfnGetFunctionPointer = zeModuleGetFunctionPointer_Tracing;
pDdiTable->pfnGetKernelNames = zeModuleGetKernelNames_Tracing;
pDdiTable->pfnGetProperties = zeModuleGetProperties_Tracing;
pDdiTable->pfnCreate = zeModuleCreateTracing;
pDdiTable->pfnDestroy = zeModuleDestroyTracing;
pDdiTable->pfnGetNativeBinary = zeModuleGetNativeBinaryTracing;
pDdiTable->pfnDynamicLink = zeModuleDynamicLinkTracing;
pDdiTable->pfnGetGlobalPointer = zeModuleGetGlobalPointerTracing;
pDdiTable->pfnGetFunctionPointer = zeModuleGetFunctionPointerTracing;
pDdiTable->pfnGetKernelNames = zeModuleGetKernelNamesTracing;
pDdiTable->pfnGetProperties = zeModuleGetPropertiesTracing;
}
return result;
}
@@ -514,15 +514,15 @@ zeGetModuleBuildLogProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnDestroy = zeModuleBuildLogDestroy;
pDdiTable->pfnGetString = zeModuleBuildLogGetString;
driver_ddiTable.core_ddiTable.ModuleBuildLog = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnDestroy = zeModuleBuildLogDestroy_Tracing;
pDdiTable->pfnGetString = zeModuleBuildLogGetString_Tracing;
pDdiTable->pfnDestroy = zeModuleBuildLogDestroyTracing;
pDdiTable->pfnGetString = zeModuleBuildLogGetStringTracing;
}
return result;
}
@@ -536,7 +536,7 @@ zeGetKernelProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeKernelCreate;
@@ -553,18 +553,18 @@ zeGetKernelProcAddrTable(
pDdiTable->pfnGetName = zeKernelGetName;
driver_ddiTable.core_ddiTable.Kernel = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeKernelCreate_Tracing;
pDdiTable->pfnDestroy = zeKernelDestroy_Tracing;
pDdiTable->pfnSetGroupSize = zeKernelSetGroupSize_Tracing;
pDdiTable->pfnSuggestGroupSize = zeKernelSuggestGroupSize_Tracing;
pDdiTable->pfnSuggestMaxCooperativeGroupCount = zeKernelSuggestMaxCooperativeGroupCount_Tracing;
pDdiTable->pfnSetArgumentValue = zeKernelSetArgumentValue_Tracing;
pDdiTable->pfnSetIndirectAccess = zeKernelSetIndirectAccess_Tracing;
pDdiTable->pfnGetIndirectAccess = zeKernelGetIndirectAccess_Tracing;
pDdiTable->pfnGetSourceAttributes = zeKernelGetSourceAttributes_Tracing;
pDdiTable->pfnGetProperties = zeKernelGetProperties_Tracing;
pDdiTable->pfnSetCacheConfig = zeKernelSetCacheConfig_Tracing;
pDdiTable->pfnGetName = zeKernelGetName_Tracing;
pDdiTable->pfnCreate = zeKernelCreateTracing;
pDdiTable->pfnDestroy = zeKernelDestroyTracing;
pDdiTable->pfnSetGroupSize = zeKernelSetGroupSizeTracing;
pDdiTable->pfnSuggestGroupSize = zeKernelSuggestGroupSizeTracing;
pDdiTable->pfnSuggestMaxCooperativeGroupCount = zeKernelSuggestMaxCooperativeGroupCountTracing;
pDdiTable->pfnSetArgumentValue = zeKernelSetArgumentValueTracing;
pDdiTable->pfnSetIndirectAccess = zeKernelSetIndirectAccessTracing;
pDdiTable->pfnGetIndirectAccess = zeKernelGetIndirectAccessTracing;
pDdiTable->pfnGetSourceAttributes = zeKernelGetSourceAttributesTracing;
pDdiTable->pfnGetProperties = zeKernelGetPropertiesTracing;
pDdiTable->pfnSetCacheConfig = zeKernelSetCacheConfigTracing;
pDdiTable->pfnGetName = zeKernelGetNameTracing;
}
return result;
}
@@ -578,15 +578,15 @@ zeGetSamplerProcAddrTable(
if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
driver_ddiTable.enableTracing = getEnvToBool("ZET_ENABLE_API_TRACING_EXP");
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = zeSamplerCreate;
pDdiTable->pfnDestroy = zeSamplerDestroy;
driver_ddiTable.core_ddiTable.Sampler = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = zeSamplerCreate_Tracing;
pDdiTable->pfnDestroy = zeSamplerDestroy_Tracing;
pDdiTable->pfnCreate = zeSamplerCreateTracing;
pDdiTable->pfnDestroy = zeSamplerDestroyTracing;
}
return result;
}

2
level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl
View File

@@ -77,7 +77,7 @@ void CommandListCoreFamily<gfxCoreFamily>::applyMemoryRangesBarrier(uint32_t num
}
for (size_t subrangeNumber = 0; subrangeNumber < subranges.size(); subrangeNumber += NEO::maxFlushSubrangeCount) {
size_t rangeCount = subranges.size() <= subrangeNumber + NEO::maxFlushSubrangeCount ? subranges.size() - subrangeNumber : NEO::maxFlushSubrangeCount;
NEO::Range<NEO::L3Range> range = CreateRange(subranges.begin() + subrangeNumber, rangeCount);
NEO::Range<NEO::L3Range> range = createRange(subranges.begin() + subrangeNumber, rangeCount);
NEO::flushGpuCache<GfxFamily>(commandStream, range, postSyncAddressToFlush, device->getHwInfo());
}

2
level_zero/core/test/aub_tests/fixtures/aub_fixture.cpp
View File

@@ -82,7 +82,7 @@ void AUBFixtureL0::SetUp(const NEO::HardwareInfo *hardwareInfo, bool debuggingEn
context = static_cast<ContextImp *>(Context::fromHandle(hContext));
ze_result_t returnValue;
commandList.reset(ult::whitebox_cast(CommandList::create(hwInfo.platform.eProductFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList.reset(ult::whiteboxCast(CommandList::create(hwInfo.platform.eProductFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
returnValue = ZE_RESULT_ERROR_UNINITIALIZED;
ze_command_queue_desc_t queueDesc = {};

8
level_zero/core/test/black_box_tests/zello_ipc_copy_dma_buf.cpp
View File

@@ -133,7 +133,7 @@ inline void initializeProcess(ze_driver_handle_t &driverHandle,
typedef ze_result_t (*pFnzexMemGetIpcHandle)(ze_context_handle_t, const void *, uint32_t *, ze_ipc_mem_handle_t *);
typedef ze_result_t (*pFnzexMemOpenIpcHandle)(ze_context_handle_t, ze_device_handle_t, uint32_t, ze_ipc_mem_handle_t *, ze_ipc_memory_flags_t, void **);
void run_client(int commSocket, uint32_t clientId) {
void runClient(int commSocket, uint32_t clientId) {
std::cout << "Client " << clientId << ", process ID: " << std::dec << getpid() << "\n";
ze_driver_handle_t driverHandle;
@@ -202,7 +202,7 @@ void run_client(int commSocket, uint32_t clientId) {
delete[] heapBuffer;
}
void run_server(bool &validRet) {
void runServer(bool &validRet) {
std::cout << "Server process ID " << std::dec << getpid() << "\n";
ze_driver_handle_t driverHandle;
@@ -331,13 +331,13 @@ int main(int argc, char *argv[]) {
exit(1);
} else if (childPids[i] == 0) {
close(sv[i][0]);
run_client(sv[i][1], i);
runClient(sv[i][1], i);
close(sv[i][1]);
exit(0);
}
}
run_server(outputValidationSuccessful);
runServer(outputValidationSuccessful);
std::cout << "\nZello IPC Results validation "
<< (outputValidationSuccessful ? "PASSED" : "FAILED")

16
level_zero/core/test/black_box_tests/zello_ipc_copy_dma_buf_p2p.cpp
View File

@@ -20,7 +20,7 @@ uint8_t uinitializedPattern = 1;
uint8_t expectedPattern = 7;
size_t allocSize = 4096 + 7; // +7 to break alignment and make it harder
static int sendmsg_fd(int socket, int fd) {
static int sendmsgFd(int socket, int fd) {
char sendBuf[sizeof(ze_ipc_mem_handle_t)] = {};
char cmsgBuf[CMSG_SPACE(sizeof(ze_ipc_mem_handle_t))];
@@ -48,7 +48,7 @@ static int sendmsg_fd(int socket, int fd) {
return 0;
}
static int recvmsg_fd(int socket) {
static int recvmsgFd(int socket) {
int fd = -1;
char recvBuf[sizeof(ze_ipc_mem_handle_t)] = {};
char cmsgBuf[CMSG_SPACE(sizeof(ze_ipc_mem_handle_t))];
@@ -198,7 +198,7 @@ inline void initializeProcess(ze_context_handle_t &context,
SUCCESS_OR_TERMINATE(zeCommandListCreate(context, device, &cmdListDescCopy, &cmdListCopy));
}
void run_client(int commSocket) {
void runClient(int commSocket) {
std::cout << "Client process " << std::dec << getpid() << "\n";
ze_context_handle_t context;
@@ -220,7 +220,7 @@ void run_client(int commSocket) {
SUCCESS_OR_TERMINATE(zeCommandQueueSynchronize(cmdQueue, std::numeric_limits<uint64_t>::max()));
// get the dma_buf from the other process
int dmaBufFd = recvmsg_fd(commSocket);
int dmaBufFd = recvmsgFd(commSocket);
if (dmaBufFd < 0) {
std::cerr << "Failing to get dma_buf fd from server\n";
std::terminate();
@@ -249,7 +249,7 @@ void run_client(int commSocket) {
SUCCESS_OR_TERMINATE(zeContextDestroy(context));
}
void run_server(int commSocket, bool &validRet) {
void runServer(int commSocket, bool &validRet) {
std::cout << "Server process " << std::dec << getpid() << "\n";
ze_context_handle_t context;
@@ -280,7 +280,7 @@ void run_server(int commSocket, bool &validRet) {
// Pass the dma_buf to the other process
int dmaBufFd;
memcpy(static_cast<void *>(&dmaBufFd), &pIpcHandle, sizeof(dmaBufFd));
if (sendmsg_fd(commSocket, static_cast<int>(dmaBufFd)) < 0) {
if (sendmsgFd(commSocket, static_cast<int>(dmaBufFd)) < 0) {
std::cerr << "Failing to send dma_buf fd to client\n";
std::terminate();
}
@@ -346,12 +346,12 @@ int main(int argc, char *argv[]) {
exit(1);
} else if (0 == child) {
close(sv[0]);
run_client(sv[1]);
runClient(sv[1]);
close(sv[1]);
exit(0);
} else {
close(sv[1]);
run_server(sv[0], outputValidationSuccessful);
runServer(sv[0], outputValidationSuccessful);
close(sv[0]);
}

6
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h
View File

@@ -24,7 +24,7 @@ class CommandListFixture : public DeviceFixture {
void SetUp() {
DeviceFixture::SetUp();
ze_result_t returnValue;
commandList.reset(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList.reset(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
@@ -61,10 +61,10 @@ struct MultiTileCommandListFixture : public SingleRootMultiSubDeviceFixture {
NEO::EngineGroupType cmdListEngineType = createCopy ? NEO::EngineGroupType::Copy : NEO::EngineGroupType::RenderCompute;
if (!createImmediate) {
commandList.reset(whitebox_cast(CommandList::create(productFamily, device, cmdListEngineType, 0u, returnValue)));
commandList.reset(whiteboxCast(CommandList::create(productFamily, device, cmdListEngineType, 0u, returnValue)));
} else {
const ze_command_queue_desc_t desc = {};
commandList.reset(whitebox_cast(CommandList::createImmediate(productFamily, device, &desc, createInternal, cmdListEngineType, returnValue)));
commandList.reset(whiteboxCast(CommandList::createImmediate(productFamily, device, &desc, createInternal, cmdListEngineType, returnValue)));
}
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);

16
level_zero/core/test/unit_tests/gen11/test_cmdqueue_thread_arbitration_policy_gen11.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -34,7 +34,7 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
std::vector<std::unique_ptr<NEO::Device>> devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
auto driverHandleUlt = whitebox_cast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
auto driverHandleUlt = whiteboxCast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
driverHandle.reset(driverHandleUlt);
ASSERT_NE(nullptr, driverHandle);
@@ -47,12 +47,12 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
ASSERT_NE(nullptr, device);
ze_command_queue_desc_t queueDesc = {};
commandQueue = whitebox_cast(CommandQueue::create(productFamily, device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&queueDesc,
false,
false,
returnValue));
commandQueue = whiteboxCast(CommandQueue::create(productFamily, device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&queueDesc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
commandList = CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue);

14
level_zero/core/test/unit_tests/gen9/test_cmdqueue_enqueuecommandlist_gen9.cpp
View File

@@ -31,7 +31,7 @@ using CommandQueueExecuteCommandListsGen9 = Test<DeviceFixture>;
GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenPipelineSelectAndVfeStateAreAddedToCmdBuffer) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -72,7 +72,7 @@ GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenPipelin
GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenStateBaseAddressForGeneralStateBaseAddressIsAdded) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -120,13 +120,13 @@ GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenStateBa
GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenMidThreadPreemptionForFirstExecuteIsConfigured) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
auto commandList = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
auto commandList = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandList->commandListPreemptionMode = NEO::PreemptionMode::MidThread;
ze_command_list_handle_t commandLists[] = {commandList->toHandle()};
@@ -167,16 +167,16 @@ GEN9TEST_F(CommandQueueExecuteCommandListsGen9, WhenExecutingCmdListsThenMidThre
GEN9TEST_F(CommandQueueExecuteCommandListsGen9, GivenCmdListsWithDifferentPreemptionModesWhenExecutingThenQueuePreemptionIsSwitchedFromMidThreadToThreadGroupAndMidThread) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
auto commandListMidThread = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
auto commandListMidThread = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandListMidThread->commandListPreemptionMode = NEO::PreemptionMode::MidThread;
auto commandListThreadGroup = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
auto commandListThreadGroup = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandListThreadGroup->commandListPreemptionMode = NEO::PreemptionMode::ThreadGroup;
ze_command_list_handle_t commandLists[] = {commandListMidThread->toHandle(),

16
level_zero/core/test/unit_tests/gen9/test_cmdqueue_gen9.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -36,7 +36,7 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
std::vector<std::unique_ptr<NEO::Device>> devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
auto driverHandleUlt = whitebox_cast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
auto driverHandleUlt = whiteboxCast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
driverHandle.reset(driverHandleUlt);
ASSERT_NE(nullptr, driverHandle);
@@ -49,12 +49,12 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
ASSERT_NE(nullptr, device);
ze_command_queue_desc_t queueDesc = {};
commandQueue = whitebox_cast(CommandQueue::create(productFamily, device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&queueDesc,
false,
false,
returnValue));
commandQueue = whiteboxCast(CommandQueue::create(productFamily, device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&queueDesc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
commandList = CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue);

2
level_zero/core/test/unit_tests/main.cpp
View File

@@ -137,7 +137,7 @@ void applyWorkarounds() {
//Create FileLogger to prevent false memory leaks
{
NEO::FileLoggerInstance();
NEO::fileLoggerInstance();
}
}

2
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@@ -78,7 +78,7 @@ TEST_F(CommandListCreate, whenCommandListIsCreatedThenItIsInitialized) {
ASSERT_GT(commandList->commandContainer.getCmdBufferAllocations().size(), 0u);
auto numAllocations = 0u;
auto allocation = whitebox_cast(commandList->commandContainer.getCmdBufferAllocations()[0]);
auto allocation = whiteboxCast(commandList->commandContainer.getCmdBufferAllocations()[0]);
ASSERT_NE(allocation, nullptr);
++numAllocations;

2
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
View File

@@ -136,7 +136,7 @@ HWTEST_F(CommandListAppendEventReset, whenResetEventIsAppendedAndNoSpaceIsAvaila
HWTEST_F(CommandListAppendEventReset, givenCopyOnlyCmdlistWhenResetEventAppendedThenMiFlushWithPostSyncIsGenerated) {
using MI_FLUSH_DW = typename FamilyType::MI_FLUSH_DW;
ze_result_t returnValue;
commandList.reset(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::Copy, 0u, returnValue)));
commandList.reset(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::Copy, 0u, returnValue)));
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
View File

@@ -573,11 +573,11 @@ HWTEST_F(CommandListAppendLaunchKernel, givenCommandListWhenResetCalledThenState
createKernel();
ze_result_t returnValue;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
ASSERT_NE(nullptr, commandList->commandContainer.getCommandStream());
auto commandListControl = std::unique_ptr<CommandList>(whitebox_cast(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandListControl = std::unique_ptr<CommandList>(whiteboxCast(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandListControl);
ASSERT_NE(nullptr, commandListControl->commandContainer.getCommandStream());

32
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_2.cpp
View File

@@ -802,11 +802,11 @@ HWTEST_F(CommandListArbitrationPolicyTest, whenCreatingCommandListThenDefaultThr
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
ze_result_t returnValue;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
EXPECT_NE(nullptr, commandList);
EXPECT_NE(nullptr, commandList->commandContainer.getCommandStream());
@@ -834,11 +834,11 @@ HWTEST_F(CommandListArbitrationPolicyTest, whenCreatingCommandListThenChosenThre
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
ze_result_t returnValue;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
EXPECT_NE(nullptr, commandList);
EXPECT_NE(nullptr, commandList->commandContainer.getCommandStream());
@@ -864,11 +864,11 @@ HWTEST_F(CommandListArbitrationPolicyTest, whenCommandListIsResetThenOriginalThr
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
ze_result_t returnValue;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(L0::CommandList::create(productFamily,
device,
NEO::EngineGroupType::RenderCompute,
0u,
returnValue)));
EXPECT_NE(nullptr, commandList);
EXPECT_NE(nullptr, commandList->commandContainer.getCommandStream());
@@ -1284,7 +1284,7 @@ struct MultiTileCommandListAppendLaunchFunctionXeHpCoreFixture : public MultiDev
contextImp = static_cast<ContextImp *>(Context::fromHandle(hContext));
ze_result_t returnValue;
commandList = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandList = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
}

406
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp
View File

@@ -29,13 +29,13 @@ TEST_F(CommandQueueCreate, whenCreatingCommandQueueThenItIsInitialized) {
csr->setupContext(*neoDevice->getDefaultEngine().osContext);
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
@@ -64,13 +64,13 @@ TEST_F(CommandQueueCreate, whenCreatingCommandQueueThenItIsInitialized) {
TEST_F(CommandQueueCreate, whenSynchronizeByPollingTaskCountThenCallsPrintOutputOnPrintfFunctionsStoredAndClearsFunctionContainer) {
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
Mock<Kernel> kernel1, kernel2;
@@ -91,13 +91,13 @@ HWTEST_F(CommandQueueCreate, givenGpuHangOnSecondReserveWhenReservingLinearStrea
ze_result_t returnValue;
NEO::WaitStatus waitStatus{NEO::WaitStatus::NotReady};
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
size_t maxSize = commandQueue->commandStream->getMaxAvailableSpace();
@@ -132,13 +132,13 @@ HWTEST_F(CommandQueueCreate, whenReserveLinearStreamThenBufferAllocationSwitched
ze_result_t returnValue;
NEO::WaitStatus waitStatus{NEO::WaitStatus::NotReady};
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
size_t maxSize = commandQueue->commandStream->getMaxAvailableSpace();
@@ -206,13 +206,13 @@ TEST_F(CommandQueueCreate, whenCreatingCommandQueueWithInvalidProductFamilyThenF
TEST_F(CommandQueueCreate, whenCmdBuffersAllocationsAreCreatedThenSizeIsNotLessThanQueuesLinearStreamSize) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
size_t maxSize = commandQueue->commandStream->getMaxAvailableSpace();
@@ -238,19 +238,19 @@ HWTEST_F(CommandQueueCreate, given100CmdListsWhenExecutingThenCommandStreamIsNot
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue);
Mock<Kernel> kernel;
kernel.immutableData.device = device;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
ze_group_count_t dispatchFunctionArguments{1, 1, 1};
@@ -288,7 +288,7 @@ HWTEST2_F(CommandQueueCreate, givenGpuHangInReservingLinearStreamWhenExecutingCo
kernel.immutableData.device = device;
ze_result_t returnValue;
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
ze_group_count_t dispatchFunctionArguments{1, 1, 1};
@@ -309,15 +309,15 @@ HWTEST_F(CommandQueueCreate, givenUpdateTaskCountFromWaitWhenDispatchTaskCountWr
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
@@ -345,13 +345,13 @@ HWTEST_F(CommandQueueCreate, givenContainerWithAllocationsWhenResidencyContainer
csr->setupContext(*neoDevice->getDefaultEngine().osContext);
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
ResidencyContainer container;
commandQueue->submitBatchBuffer(0, container, nullptr, false);
EXPECT_EQ(csr->makeResidentCalledTimes, 0u);
@@ -366,13 +366,13 @@ HWTEST_F(CommandQueueCreate, givenCommandStreamReceiverFailsThenSubmitBatchBuffe
csr->setupContext(*neoDevice->getDefaultEngine().osContext);
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
ResidencyContainer container;
NEO::SubmissionStatus ret = commandQueue->submitBatchBuffer(0, container, nullptr, false);
EXPECT_EQ(ret, NEO::SubmissionStatus::FAILED);
@@ -385,13 +385,13 @@ HWTEST_F(CommandQueueCreate, givenOutOfMemoryThenSubmitBatchBufferReturnsOutOfMe
csr->setupContext(*neoDevice->getDefaultEngine().osContext);
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
ResidencyContainer container;
NEO::SubmissionStatus ret = commandQueue->submitBatchBuffer(0, container, nullptr, false);
EXPECT_EQ(ret, NEO::SubmissionStatus::OUT_OF_MEMORY);
@@ -403,13 +403,13 @@ TEST_F(CommandQueueCreate, whenCommandQueueCreatedThenExpectLinearStreamInitiali
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(commandQueue, nullptr);
size_t commandStreamSize = MemoryConstants::kiloByte * 128u;
@@ -427,16 +427,16 @@ HWTEST_F(CommandQueueCreate, givenQueueInAsyncModeAndRugularCmdListWithAppendBar
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
commandList->appendBarrier(nullptr, 0, nullptr);
@@ -448,16 +448,16 @@ HWTEST_F(CommandQueueCreate, givenQueueInSyncModeAndRugularCmdListWithAppendBarr
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
commandList->appendBarrier(nullptr, 0, nullptr);
@@ -1579,16 +1579,16 @@ HWTEST2_F(ExecuteCommandListTests, givenCommandQueueHavingTwoB2BCommandListsThen
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadScratchSize(0u);
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList1->setCommandListPerThreadScratchSize(0u);
auto commandListHandle0 = commandList0->toHandle();
auto commandListHandle1 = commandList1->toHandle();
@@ -1688,8 +1688,8 @@ HWTEST2_F(EngineInstancedDeviceExecuteTests, givenEngineInstancedDeviceWhenExecu
NEO::CommandStreamReceiver *csr;
l0Device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, l0Device, csr, &desc, false, false, returnValue));
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, l0Device, NEO::EngineGroupType::Compute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, l0Device, csr, &desc, false, false, returnValue));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, l0Device, NEO::EngineGroupType::Compute, 0u, returnValue)));
auto commandListHandle = commandList->toHandle();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false);
@@ -1716,15 +1716,15 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadScratchSize(512u);
commandList1->setCommandListPerThreadScratchSize(0u);
auto commandListHandle0 = commandList0->toHandle();
@@ -1752,13 +1752,13 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
commandList1->reset();
commandList1->setCommandListPerThreadScratchSize(0u);
auto commandQueue1 = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandQueue1 = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSize());
@@ -1788,15 +1788,15 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadScratchSize(0u);
commandList1->setCommandListPerThreadScratchSize(512u);
auto commandListHandle0 = commandList0->toHandle();
@@ -1824,13 +1824,13 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
commandList1->reset();
commandList1->setCommandListPerThreadScratchSize(0u);
auto commandQueue1 = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandQueue1 = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSize());
@@ -1860,15 +1860,15 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadScratchSize(512u);
commandList1->setCommandListPerThreadScratchSize(512u);
auto commandListHandle0 = commandList0->toHandle();
@@ -1896,13 +1896,13 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
commandList1->reset();
commandList1->setCommandListPerThreadScratchSize(1024u);
auto commandQueue1 = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandQueue1 = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSize());
@@ -1932,15 +1932,15 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadScratchSize(0u);
commandList1->setCommandListPerThreadScratchSize(512u);
auto commandListHandle0 = commandList0->toHandle();
@@ -1968,13 +1968,13 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
commandList1->reset();
commandList1->setCommandListPerThreadScratchSize(2048u);
auto commandQueue1 = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandQueue1 = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSize());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false);
@@ -2002,15 +2002,15 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
NEO::CommandStreamReceiver *csr;
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList0 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList1 = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList0->setCommandListPerThreadPrivateScratchSize(0u);
commandList1->setCommandListPerThreadPrivateScratchSize(512u);
auto commandListHandle0 = commandList0->toHandle();
@@ -2036,13 +2036,13 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
commandList1->reset();
commandList1->setCommandListPerThreadPrivateScratchSize(2048u);
auto commandQueue1 = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandQueue1 = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadPrivateScratchSize());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false);
@@ -2069,14 +2069,14 @@ HWTEST_F(ExecuteCommandListTests, givenDirectSubmissionEnabledWhenExecutingCmdLi
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
static_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList->setCommandListPerThreadPrivateScratchSize(0u);
auto commandListHandle = commandList->toHandle();
@@ -2111,14 +2111,14 @@ HWTEST_F(ExecuteCommandListTests, givenDirectSubmissionEnabledAndDebugFlagSetWhe
device->getCsrForOrdinalAndIndex(&csr, 0u, 0u);
static_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr,
&desc,
false,
false,
returnValue));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList->setCommandListPerThreadPrivateScratchSize(0u);
auto commandListHandle = commandList->toHandle();

128
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp
View File

@@ -214,7 +214,7 @@ HWTEST_F(CommandQueueSynchronizeTest, givenGpuHangWhenCallingSynchronizeThenErro
ASSERT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandQueue);
auto queue = whitebox_cast(L0::CommandQueue::fromHandle(commandQueue));
auto queue = whiteboxCast(L0::CommandQueue::fromHandle(commandQueue));
queue->csr = csr.get();
constexpr auto timeout{std::numeric_limits<uint64_t>::max()};
@@ -243,7 +243,7 @@ HWTEST_F(CommandQueueSynchronizeTest, givenDebugOverrideEnabledAndGpuHangWhenCal
ASSERT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandQueue);
auto queue = whitebox_cast(L0::CommandQueue::fromHandle(commandQueue));
auto queue = whiteboxCast(L0::CommandQueue::fromHandle(commandQueue));
queue->csr = csr.get();
constexpr auto timeout{std::numeric_limits<uint64_t>::max()};
@@ -307,18 +307,18 @@ HWTEST2_F(MultiTileCommandQueueSynchronizeTest, givenMultiplePartitionCountWhenC
tagAddress = ptrOffset(tagAddress, csr->getPostSyncWriteOffset());
}
csr->activePartitions = 2u;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
EXPECT_EQ(2u, commandQueue->activeSubDevices);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
commandList->partitionCount = 2;
@@ -347,18 +347,18 @@ HWTEST2_F(MultiTileCommandQueueSynchronizeTest, givenCsrHasMultipleActivePartiti
tagAddress = ptrOffset(tagAddress, csr->getPostSyncWriteOffset());
}
csr->activePartitions = 2u;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
EXPECT_EQ(2u, commandQueue->activeSubDevices);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
@@ -374,18 +374,18 @@ HWTEST_F(CommandQueueSynchronizeTest, givenSingleTileCsrWhenExecutingMultiTileCo
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
EXPECT_EQ(1u, commandQueue->activeSubDevices);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
commandList->partitionCount = 2;
@@ -412,13 +412,13 @@ HWTEST_F(CommandQueueSynchronizeTest, givenSinglePartitionCountWhenWaitFunctionF
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
@@ -452,18 +452,18 @@ HWTEST_F(CommandQueueSynchronizeTest, givenSynchronousCommandQueueWhenTagUpdateF
const ze_command_queue_desc_t desc{ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0, ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS, ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandQueue);
EXPECT_EQ(ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS, commandQueue->getSynchronousMode());
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList);
//1st execute provides all preamble commands
@@ -515,13 +515,13 @@ HWTEST_F(CommandQueuePowerHintTest, givenDriverHandleWithPowerHintAndOsContextPo
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
commandQueue->destroy();
@@ -538,13 +538,13 @@ HWTEST_F(CommandQueuePowerHintTest, givenDriverHandleWithPowerHintAndOsContextPo
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
csr.get(),
&desc,
false,
false,
returnValue));
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
commandQueue->destroy();
@@ -716,17 +716,17 @@ HWTEST2_F(DeviceWithDualStorage, givenCmdListWithAppendedKernelAndUsmTransferAnd
ze_result_t res = ZE_RESULT_SUCCESS;
const ze_command_queue_desc_t desc = {};
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getInternalEngine().commandStreamReceiver,
&desc,
false,
false,
res));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getInternalEngine().commandStreamReceiver,
&desc,
false,
false,
res));
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandQueue);
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, res)));
auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, res)));
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandList);
Mock<Kernel> kernel;
@@ -747,7 +747,7 @@ HWTEST2_F(DeviceWithDualStorage, givenCmdListWithAppendedKernelAndUsmTransferAnd
ze_group_count_t dispatchFunctionArguments{1, 1, 1};
commandList->appendLaunchKernel(kernel.toHandle(), &dispatchFunctionArguments, nullptr, 0, nullptr);
auto deviceImp = static_cast<DeviceImp *>(device);
auto pageFaultCmdQueue = whitebox_cast(deviceImp->pageFaultCommandList->cmdQImmediate);
auto pageFaultCmdQueue = whiteboxCast(deviceImp->pageFaultCommandList->cmdQImmediate);
auto sizeBefore = commandQueue->commandStream->getUsed();
auto pageFaultSizeBefore = pageFaultCmdQueue->commandStream->getUsed();

204
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist.cpp
View File

@@ -102,17 +102,17 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenACommandListExecutedRequiresUncach
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto commandList1 = whitebox_cast(CommandList::fromHandle(commandLists[0]));
auto commandList2 = whitebox_cast(CommandList::fromHandle(commandLists[1]));
auto commandList1 = whiteboxCast(CommandList::fromHandle(commandLists[0]));
auto commandList2 = whiteboxCast(CommandList::fromHandle(commandLists[1]));
commandList1->requiresQueueUncachedMocs = true;
commandList2->requiresQueueUncachedMocs = true;
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
@@ -128,13 +128,13 @@ HWTEST_F(CommandQueueExecuteCommandLists, givenCommandListThatRequiresDisabledEU
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto commandList1 = static_cast<WhiteBoxCommandList *>(CommandList::fromHandle(commandLists[0]));
@@ -154,13 +154,13 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenASecondLevelBatchBufferPerCommandL
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
@@ -202,20 +202,20 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenASecondLevelBatchBufferPerCommandL
HWTEST_F(CommandQueueExecuteCommandLists, givenFenceWhenExecutingCmdListThenFenceStatusIsCorrect) {
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
*csr.tagAddress = 10;
csr.taskCount = 10;
ze_fence_desc_t fenceDesc{};
auto fence = whitebox_cast(Fence::create(commandQueue, &fenceDesc));
auto fence = whiteboxCast(Fence::create(commandQueue, &fenceDesc));
ASSERT_NE(nullptr, fence);
EXPECT_EQ(ZE_RESULT_NOT_READY, fence->queryStatus());
@@ -241,17 +241,17 @@ HWTEST2_F(CommandQueueExecuteCommandLists, whenUsingFenceThenExpectEndingPipeCon
ze_command_queue_desc_t desc{};
ze_result_t returnValue;
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_fence_desc_t fenceDesc{};
auto fence = whitebox_cast(Fence::create(commandQueue, &fenceDesc));
auto fence = whiteboxCast(Fence::create(commandQueue, &fenceDesc));
ASSERT_NE(nullptr, fence);
ze_fence_handle_t fenceHandle = fence->toHandle();
@@ -293,13 +293,13 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenExecutingCommandListsThenEndingPip
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
@@ -336,13 +336,13 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenCommandQueueHaving2CommandListsT
using PARSE = typename FamilyType::PARSE;
ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
CommandList::fromHandle(commandLists[0])->setCommandListPerThreadScratchSize(512u);
CommandList::fromHandle(commandLists[1])->setCommandListPerThreadScratchSize(1024u);
@@ -410,13 +410,13 @@ HWTEST_F(CommandQueueExecuteCommandLists, givenMidThreadPreemptionWhenCommandsAr
for (auto flagInternal : testedInternalFlags) {
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
flagInternal,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
flagInternal,
returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -461,13 +461,13 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenMidThreadPreemptionWhenCommandsA
for (auto flagInternal : testedInternalFlags) {
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
flagInternal,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
flagInternal,
returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -637,7 +637,7 @@ void CommandQueueExecuteCommandLists::twoCommandListCommandPreemptionTest(bool p
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -645,10 +645,10 @@ void CommandQueueExecuteCommandLists::twoCommandListCommandPreemptionTest(bool p
preemptionCmdProgramming = NEO::PreemptionHelper::getRequiredCmdStreamSize<FamilyType>(NEO::PreemptionMode::ThreadGroup, NEO::PreemptionMode::Disabled) > 0u;
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
auto commandListDisabled = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
auto commandListDisabled = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandListDisabled->commandListPreemptionMode = NEO::PreemptionMode::Disabled;
auto commandListThreadGroup = whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
auto commandListThreadGroup = whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
commandListThreadGroup->commandListPreemptionMode = NEO::PreemptionMode::ThreadGroup;
ze_command_list_handle_t commandLists[] = {commandListDisabled->toHandle(),
@@ -806,13 +806,13 @@ struct CommandQueueExecuteCommandListSWTagsTests : public Test<DeviceFixture> {
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ze_command_queue_desc_t desc = {};
commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandQueue->commandStream);
}
@@ -863,7 +863,7 @@ HWTEST_F(CommandQueueExecuteCommandListSWTagsTests, givenEnableSWTagsAndCommandL
using MI_NOOP = typename FamilyType::MI_NOOP;
using PARSE = typename FamilyType::PARSE;
whitebox_cast(CommandList::fromHandle(commandLists[0]))->commandListPreemptionMode = PreemptionMode::Disabled;
whiteboxCast(CommandList::fromHandle(commandLists[0]))->commandListPreemptionMode = PreemptionMode::Disabled;
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
auto result = commandQueue->executeCommandLists(1, commandLists, nullptr, false);
@@ -945,13 +945,13 @@ HWTEST2_F(MultiDeviceCommandQueueExecuteCommandLists, givenMultiplePartitionCoun
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
false,
false,
returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
EXPECT_EQ(2u, commandQueue->partitionCount);
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -962,7 +962,7 @@ HWTEST2_F(MultiDeviceCommandQueueExecuteCommandLists, givenMultiplePartitionCoun
}
ze_fence_desc_t fenceDesc{};
auto fence = whitebox_cast(Fence::create(commandQueue, &fenceDesc));
auto fence = whiteboxCast(Fence::create(commandQueue, &fenceDesc));
ASSERT_NE(nullptr, fence);
ze_fence_handle_t fenceHandle = fence->toHandle();
@@ -1039,18 +1039,18 @@ HWTEST_F(CommandQueueExecuteCommandLists, GivenUpdateTaskCountFromWaitWhenExecut
csr->useNotifyEnableForPostSync = true;
const ze_command_queue_desc_t desc{};
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
true,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
true,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
ze_fence_desc_t fenceDesc{};
auto fence = whitebox_cast(Fence::create(commandQueue, &fenceDesc));
auto fence = whiteboxCast(Fence::create(commandQueue, &fenceDesc));
ASSERT_NE(nullptr, fence);
ze_fence_handle_t fenceHandle = fence->toHandle();
@@ -1091,18 +1091,18 @@ HWTEST_F(CommandQueueExecuteCommandLists, GivenCopyCommandQueueWhenExecutingCopy
csr->useNotifyEnableForPostSync = true;
const ze_command_queue_desc_t desc{};
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
true,
false,
returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
device,
neoDevice->getDefaultEngine().commandStreamReceiver,
&desc,
true,
false,
returnValue));
ASSERT_NE(nullptr, commandQueue);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
ze_fence_desc_t fenceDesc{};
auto fence = whitebox_cast(Fence::create(commandQueue, &fenceDesc));
auto fence = whiteboxCast(Fence::create(commandQueue, &fenceDesc));
ASSERT_NE(nullptr, fence);
ze_fence_handle_t fenceHandle = fence->toHandle();

4
level_zero/core/test/unit_tests/sources/debugger/active_debugger_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -54,7 +54,7 @@ struct ActiveDebuggerFixture {
std::vector<std::unique_ptr<NEO::Device>> devices;
devices.push_back(std::unique_ptr<NEO::Device>(device));
auto driverHandleUlt = whitebox_cast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
auto driverHandleUlt = whiteboxCast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
driverHandle.reset(driverHandleUlt);
ASSERT_NE(nullptr, driverHandle);

6
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@@ -135,7 +135,7 @@ HWTEST_F(L0DebuggerTest, givenDebuggingEnabledWhenCommandListIsExecutedThenValid
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
@@ -470,7 +470,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledForRegularCo
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {
@@ -504,7 +504,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledForRegularC
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {

2
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp
View File

@@ -306,7 +306,7 @@ HWTEST_F(L0DebuggerWithBlitterTest, givenUseCsrImmediateSubmissionEnabledForRegu
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {

8
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp
View File

@@ -169,7 +169,7 @@ HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledAndRequiredGsbaWhenCommandListIsE
auto cmdQ = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue);
ASSERT_NE(nullptr, cmdQ);
auto commandQueue = whitebox_cast(cmdQ);
auto commandQueue = whiteboxCast(cmdQ);
auto cmdQHw = static_cast<CommandQueueHw<gfxCoreFamily> *>(cmdQ);
if (cmdQHw->estimateStateBaseAddressCmdSize() == 0) {
@@ -226,7 +226,7 @@ HWTEST_F(L0DebuggerTest, givenDebuggingEnabledAndDebuggerLogsWhenCommandQueueIsS
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {
@@ -262,7 +262,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenNullL0DebuggerAndDebuggerLogsWhenCommandQueu
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {
@@ -293,7 +293,7 @@ HWTEST_F(L0DebuggerTest, givenL0DebuggerAndDebuggerLogsDisabledWhenCommandQueueI
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {

2
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_single_address_space.cpp
View File

@@ -341,7 +341,7 @@ HWTEST2_F(L0DebuggerSingleAddressSpace, givenDebuggingEnabledWhenCommandListIsEx
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();

4
level_zero/core/test/unit_tests/sources/debugger/test_source_level_debugger.cpp
View File

@@ -30,7 +30,7 @@ HWTEST2_F(CommandQueueDebugCommandsTest, givenDebuggingEnabledWhenCommandListIsE
NEO::MockCompilerEnableGuard mock(true);
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();
@@ -79,7 +79,7 @@ HWTEST2_F(CommandQueueDebugCommandsTest, givenDebuggingEnabledWhenCommandListIsE
ze_command_queue_desc_t queueDesc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
auto usedSpaceBefore = commandQueue->commandStream->getUsed();

6
level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
View File

@@ -307,7 +307,7 @@ TEST(DriverTest, givenNullEnvVariableWhenCreatingDriverThenEnableProgramDebuggin
L0EnvVariables envVariables = {};
envVariables.programDebugging = false;
auto driverHandle = whitebox_cast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
auto driverHandle = whiteboxCast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
EXPECT_NE(nullptr, driverHandle);
EXPECT_FALSE(driverHandle->enableProgramDebugging);
@@ -408,7 +408,7 @@ TEST(DriverTest, givenProgramDebuggingEnvVarNonZeroWhenCreatingDriverThenEnableP
L0EnvVariables envVariables = {};
envVariables.programDebugging = true;
auto driverHandle = whitebox_cast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
auto driverHandle = whiteboxCast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
EXPECT_NE(nullptr, driverHandle);
EXPECT_TRUE(driverHandle->enableProgramDebugging);
@@ -525,7 +525,7 @@ struct DriverHandleTest : public ::testing::Test {
L0EnvVariables envVariables = {};
envVariables.programDebugging = true;
driverHandle = whitebox_cast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
driverHandle = whiteboxCast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
L0::GlobalDriverHandle = driverHandle;
}
void TearDown() override {

12
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@@ -1613,7 +1613,7 @@ class EventFixture : public DeviceFixture {
auto hDevice = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
eventPool = whitebox_cast(EventPool::create(device->getDriverHandle(), context, 1, &hDevice, &eventPoolDesc, result));
eventPool = whiteboxCast(EventPool::create(device->getDriverHandle(), context, 1, &hDevice, &eventPoolDesc, result));
}
void TearDown() {
@@ -1635,7 +1635,7 @@ class EventFixture : public DeviceFixture {
using EventTests = Test<EventFixture>;
TEST_F(EventTests, WhenQueryingStatusThenSuccessIsReturned) {
auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
auto event = whiteboxCast(Event::create<uint32_t>(eventPool, &eventDesc, device));
ASSERT_NE(event, nullptr);
auto result = event->hostSignal();
@@ -1647,7 +1647,7 @@ TEST_F(EventTests, WhenQueryingStatusThenSuccessIsReturned) {
}
TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
auto event = whiteboxCast(Event::create<uint32_t>(eventPool, &eventDesc, device));
ASSERT_NE(event, nullptr);
auto result = event->hostSignal();
@@ -1664,7 +1664,7 @@ TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
}
TEST_F(EventTests, WhenDestroyingAnEventThenSuccessIsReturned) {
auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
auto event = whiteboxCast(Event::create<uint32_t>(eventPool, &eventDesc, device));
ASSERT_NE(event, nullptr);
auto result = event->destroy();
@@ -1680,10 +1680,10 @@ TEST_F(EventTests, givenTwoEventsCreatedThenTheyHaveDifferentAddresses) {
eventDesc1.index = 1;
eventDesc.index = 1;
auto event0 = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc0, device));
auto event0 = whiteboxCast(Event::create<uint32_t>(eventPool, &eventDesc0, device));
ASSERT_NE(event0, nullptr);
auto event1 = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc1, device));
auto event1 = whiteboxCast(Event::create<uint32_t>(eventPool, &eventDesc1, device));
ASSERT_NE(event1, nullptr);
EXPECT_NE(event0->hostAddress, event1->hostAddress);

18
level_zero/core/test/unit_tests/sources/fence/test_fence.cpp
View File

@@ -97,7 +97,7 @@ TEST_F(FenceTest, GivenGpuHangWhenHostSynchronizeIsCalledThenDeviceLostIsReturne
ze_fence_desc_t desc = {};
std::unique_ptr<WhiteBox<L0::Fence>> fence;
fence.reset(whitebox_cast(Fence::create(&cmdqueue, &desc)));
fence.reset(whiteboxCast(Fence::create(&cmdqueue, &desc)));
ASSERT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -118,7 +118,7 @@ TEST_F(FenceTest, GivenNoGpuHangAndOneNanosecondTimeoutWhenHostSynchronizeIsCall
ze_fence_desc_t desc = {};
std::unique_ptr<WhiteBox<L0::Fence>> fence;
fence.reset(whitebox_cast(Fence::create(&cmdqueue, &desc)));
fence.reset(whiteboxCast(Fence::create(&cmdqueue, &desc)));
ASSERT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -138,7 +138,7 @@ TEST_F(FenceTest, GivenLongPeriodOfGpuCheckAndOneNanosecondTimeoutWhenHostSynchr
ze_fence_desc_t desc = {};
std::unique_ptr<WhiteBox<L0::Fence>> fence;
fence.reset(whitebox_cast(Fence::create(&cmdqueue, &desc)));
fence.reset(whiteboxCast(Fence::create(&cmdqueue, &desc)));
ASSERT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -158,7 +158,7 @@ TEST_F(FenceTest, GivenSuccessfulQueryResultAndNoTimeoutWhenHostSynchronizeIsCal
ze_fence_desc_t desc = {};
std::unique_ptr<WhiteBox<L0::Fence>> fence;
fence.reset(whitebox_cast(Fence::create(&cmdqueue, &desc)));
fence.reset(whiteboxCast(Fence::create(&cmdqueue, &desc)));
ASSERT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -205,7 +205,7 @@ TEST_F(FenceSynchronizeTest, givenCallToFenceHostSynchronizeWithTimeoutZeroAndTa
Mock<CommandQueue> cmdQueue(device, csr.get());
ze_fence_desc_t fenceDesc = {};
auto fence = std::unique_ptr<Fence>(whitebox_cast(Fence::create(&cmdQueue, &fenceDesc)));
auto fence = std::unique_ptr<Fence>(whiteboxCast(Fence::create(&cmdQueue, &fenceDesc)));
EXPECT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -220,7 +220,7 @@ TEST_F(FenceSynchronizeTest, givenCallToFenceHostSynchronizeWithTimeoutNonZeroAn
Mock<CommandQueue> cmdQueue(device, csr.get());
ze_fence_desc_t fenceDesc = {};
auto fence = std::unique_ptr<Fence>(whitebox_cast(Fence::create(&cmdQueue, &fenceDesc)));
auto fence = std::unique_ptr<Fence>(whiteboxCast(Fence::create(&cmdQueue, &fenceDesc)));
EXPECT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -242,7 +242,7 @@ TEST_F(FenceSynchronizeTest, givenInfiniteTimeoutWhenWaitingForFenceCompletionTh
ze_fence_desc_t desc = {};
std::unique_ptr<WhiteBox<L0::Fence>> fence;
fence.reset(whitebox_cast(Fence::create(&cmdqueue, &desc)));
fence.reset(whiteboxCast(Fence::create(&cmdqueue, &desc)));
ASSERT_NE(nullptr, fence);
fence->taskCount = 1;
@@ -324,7 +324,7 @@ TEST_F(FenceTest, givenFenceNotEnqueuedThenStatusIsNotReady) {
Mock<CommandQueue> cmdqueue(device, csr.get());
ze_fence_desc_t desc = {};
auto fence = whitebox_cast(Fence::create(&cmdqueue, &desc));
auto fence = whiteboxCast(Fence::create(&cmdqueue, &desc));
ASSERT_NE(fence, nullptr);
EXPECT_EQ(fence->queryStatus(), ZE_RESULT_NOT_READY);
@@ -336,7 +336,7 @@ TEST_F(FenceTest, givenFenceWhenResettingThenTaskCountIsReset) {
Mock<CommandQueue> cmdqueue(device, csr.get());
ze_fence_desc_t desc = {};
auto fence = whitebox_cast(Fence::create(&cmdqueue, &desc));
auto fence = whiteboxCast(Fence::create(&cmdqueue, &desc));
ASSERT_NE(fence, nullptr);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), fence->taskCount);

10
level_zero/core/test/unit_tests/sources/image/test_image.cpp
View File

@@ -949,7 +949,7 @@ HWTEST2_F(ImageCreate, givenImageSizeZeroThenDummyImageIsCreated, IsAtMostXeHpgC
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
auto alloc = image->getAllocation();
@@ -999,7 +999,7 @@ HWTEST2_F(ImageCreate, WhenDestroyingImageThenSuccessIsReturned, IsAtMostProduct
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
result = zeImageDestroy(image->toHandle());
@@ -1014,7 +1014,7 @@ HWTEST2_F(ImageCreate, WhenCreatingImageThenNonNullPointerIsReturned, IsAtMostPr
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
image->destroy();
@@ -1028,7 +1028,7 @@ HWTEST2_F(ImageCreate, givenInvalidProductFamilyThenNullIsReturned, IsAtMostProd
auto result = Image::create(IGFX_UNKNOWN, device, &desc, &imagePtr);
ASSERT_NE(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_EQ(nullptr, image);
}
@@ -1048,7 +1048,7 @@ HWTEST2_F(ImageCreate, WhenImageIsCreatedThenDescMatchesAllocation, IsAtMostProd
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
auto alloc = image->getAllocation();

4
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@@ -63,7 +63,7 @@ HWTEST_F(ModuleTest, givenZeroCountWhenGettingKernelNamesThenCountIsFilled) {
uint32_t count = 0;
auto result = module->getKernelNames(&count, nullptr);
auto whiteboxModule = whitebox_cast(module.get());
auto whiteboxModule = whiteboxCast(module.get());
EXPECT_EQ(whiteboxModule->kernelImmDatas.size(), count);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -1125,7 +1125,7 @@ TEST_F(ModulePropertyTest, givenCallToGetPropertiesWithUnresolvedSymbolsThenFlag
NEO::Linker::RelocationInfo unresolvedRelocation;
unresolvedRelocation.symbolName = "unresolved";
whitebox_cast(module.get())->unresolvedExternalsInfo.push_back({unresolvedRelocation});
whiteboxCast(module.get())->unresolvedExternalsInfo.push_back({unresolvedRelocation});
ze_module_property_flags_t expectedFlags = 0;
expectedFlags |= ZE_MODULE_PROPERTY_FLAG_IMPORTS;

8
level_zero/core/test/unit_tests/white_box.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,17 +16,17 @@ struct WhiteBox : public Type {
};
template <typename Type>
WhiteBox<Type> *whitebox_cast(Type *obj) {
WhiteBox<Type> *whiteboxCast(Type *obj) {
return static_cast<WhiteBox<Type> *>(obj);
}
template <typename Type>
WhiteBox<Type> &whitebox_cast(Type &obj) {
WhiteBox<Type> &whiteboxCast(Type &obj) {
return static_cast<WhiteBox<Type> &>(obj);
}
template <typename Type>
Type *blackbox_cast(WhiteBox<Type> *obj) {
Type *blackboxCast(WhiteBox<Type> *obj) {
return static_cast<Type *>(obj);
}

6
level_zero/core/test/unit_tests/xe_hp_core/test_cmdqueue_debugger_xe_hp_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -36,7 +36,7 @@ XEHPTEST_F(CommandQueueDebugCommandsForSldXeHP, givenSteppingA0OrBWhenGlobalSipI
for (auto revision : revisions) {
hwInfo.platform.usRevId = revision;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, deviceL0, device->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {
@@ -115,7 +115,7 @@ XEHPTEST_F(CommandQueueDebugCommandsDebuggerL0XeHP, givenSteppingA0OrBWhenGlobal
for (auto revision : revisions) {
hwInfo.platform.usRevId = revision;
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
ze_command_list_handle_t commandLists[] = {

6
level_zero/core/test/unit_tests/xe_hp_core/test_cmdqueue_enqueuecommandlist_xe_hp_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -27,7 +27,7 @@ using CommandQueueExecuteCommandListsXE_HP_CORE = Test<DeviceFixture>;
XE_HP_CORE_TEST_F(CommandQueueExecuteCommandListsXE_HP_CORE, WhenExecutingCmdListsThenPipelineSelectAndCfeStateAreAddedToCmdBuffer) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -68,7 +68,7 @@ XE_HP_CORE_TEST_F(CommandQueueExecuteCommandListsXE_HP_CORE, WhenExecutingCmdLis
XE_HP_CORE_TEST_F(CommandQueueExecuteCommandListsXE_HP_CORE, WhenExecutingCmdListsThenStateBaseAddressForGeneralStateBaseAddressIsNotAdded) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);

6
level_zero/core/test/unit_tests/xe_hpg_core/test_cmdqueue_enqueuecommandlist_xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -27,7 +27,7 @@ using CommandQueueExecuteCommandListsXeHpgCore = Test<DeviceFixture>;
XE_HPG_CORETEST_F(CommandQueueExecuteCommandListsXeHpgCore, WhenExecutingCmdListsThenPipelineSelectAndCfeStateAreAddedToCmdBuffer) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);
@@ -68,7 +68,7 @@ XE_HPG_CORETEST_F(CommandQueueExecuteCommandListsXeHpgCore, WhenExecutingCmdList
XE_HPG_CORETEST_F(CommandQueueExecuteCommandListsXeHpgCore, WhenExecutingCmdListsThenStateBaseAddressForGeneralStateBaseAddressIsNotAdded) {
const ze_command_queue_desc_t desc = {};
ze_result_t returnValue;
auto commandQueue = whitebox_cast(CommandQueue::create(
auto commandQueue = whiteboxCast(CommandQueue::create(
productFamily,
device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc, false, false, returnValue));
ASSERT_NE(nullptr, commandQueue->commandStream);

8
level_zero/core/test/unit_tests/xe_hpg_core/test_image_xe_hpg_core.cpp
View File

@@ -53,7 +53,7 @@ HWTEST2_F(ImageCreate, WhenDestroyingImageThenSuccessIsReturned, IsXeHpgCore) {
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
result = zeImageDestroy(image->toHandle());
@@ -68,7 +68,7 @@ HWTEST2_F(ImageCreate, WhenCreatingImageThenSuccessIsReturned, IsXeHpgCore) {
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
image->destroy();
@@ -82,7 +82,7 @@ HWTEST2_F(ImageCreate, givenInvalidProductFamilyThenReturnNullPointer, IsXeHpgCo
auto result = Image::create(IGFX_UNKNOWN, device, &desc, &imagePtr);
ASSERT_NE(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_EQ(nullptr, image);
}
@@ -102,7 +102,7 @@ HWTEST2_F(ImageCreate, WhenImagesIsCreatedThenParamsSetCorrectly, IsXeHpgCore) {
auto result = Image::create(productFamily, device, &desc, &imagePtr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto image = whitebox_cast(imagePtr);
auto image = whiteboxCast(imagePtr);
ASSERT_NE(nullptr, image);
auto alloc = image->getAllocation();

28
level_zero/experimental/source/tracing/tracing_barrier_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,10 +8,10 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendBarrierTracing(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,
@@ -29,7 +29,7 @@ zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendBarrierCb_t, CommandList, pfnAppendBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendBarrier,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -41,13 +41,13 @@ zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeCommandListAppendMemoryRangesBarrierTracing(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,
@@ -71,7 +71,7 @@ zeCommandListAppendMemoryRangesBarrier_Tracing(ze_command_list_handle_t hCommand
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryRangesBarrierCb_t, CommandList, pfnAppendMemoryRangesBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

24
level_zero/experimental/source/tracing/tracing_barrier_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,17 +10,17 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendBarrier_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
zeCommandListAppendBarrierTracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
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);
zeCommandListAppendMemoryRangesBarrierTracing(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);
}

64
level_zero/experimental/source/tracing/tracing_cmdlist_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,10 +8,10 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList) {
zeCommandListCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -29,7 +29,7 @@ zeCommandListCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCreateCb_t, CommandList, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -41,10 +41,10 @@ zeCommandListCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList) {
zeCommandListCreateImmediateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -62,7 +62,7 @@ zeCommandListCreateImmediate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCreateImmediateCb_t, CommandList, pfnCreateImmediateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreateImmediate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnCreateImmediate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -74,7 +74,7 @@ zeCommandListCreateImmediate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList) {
zeCommandListDestroyTracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnDestroy, hCommandList);
@@ -85,7 +85,7 @@ zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListDestroyCb_t, CommandList, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -94,7 +94,7 @@ zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList) {
zeCommandListCloseTracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnClose, hCommandList);
@@ -105,7 +105,7 @@ zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListCloseCb_t, CommandList, pfnCloseCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnClose,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnClose,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -114,7 +114,7 @@ zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList) {
zeCommandListResetTracing(ze_command_list_handle_t hCommandList) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnReset,
hCommandList);
@@ -126,7 +126,7 @@ zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListResetCb_t, CommandList, pfnResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnReset,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -135,11 +135,11 @@ zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendWriteGlobalTimestamp_Tracing(ze_command_list_handle_t hCommandList,
uint64_t *dstptr,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendWriteGlobalTimestampTracing(ze_command_list_handle_t hCommandList,
uint64_t *dstptr,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWriteGlobalTimestamp,
hCommandList,
@@ -159,7 +159,7 @@ zeCommandListAppendWriteGlobalTimestamp_Tracing(ze_command_list_handle_t hComman
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendWriteGlobalTimestampCb_t, CommandList, pfnAppendWriteGlobalTimestampCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWriteGlobalTimestamp,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWriteGlobalTimestamp,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -172,14 +172,14 @@ zeCommandListAppendWriteGlobalTimestamp_Tracing(ze_command_list_handle_t hComman
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendQueryKernelTimestamps_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents,
void *dstptr,
const size_t *pOffsets,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendQueryKernelTimestampsTracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents,
void *dstptr,
const size_t *pOffsets,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendQueryKernelTimestamps,
hCommandList,
@@ -205,7 +205,7 @@ zeCommandListAppendQueryKernelTimestamps_Tracing(ze_command_list_handle_t hComma
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendQueryKernelTimestampsCb_t, CommandList, pfnAppendQueryKernelTimestampsCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendQueryKernelTimestamps,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendQueryKernelTimestamps,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

46
level_zero/experimental/source/tracing/tracing_cmdlist_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,39 +10,39 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList);
zeCommandListCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList);
zeCommandListCreateImmediateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListDestroy_Tracing(ze_command_list_handle_t hCommandList);
zeCommandListDestroyTracing(ze_command_list_handle_t hCommandList);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListClose_Tracing(ze_command_list_handle_t hCommandList);
zeCommandListCloseTracing(ze_command_list_handle_t hCommandList);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListReset_Tracing(ze_command_list_handle_t hCommandList);
zeCommandListResetTracing(ze_command_list_handle_t hCommandList);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendWriteGlobalTimestamp_Tracing(ze_command_list_handle_t hCommandList,
uint64_t *dstptr,
zeCommandListAppendWriteGlobalTimestampTracing(ze_command_list_handle_t hCommandList,
uint64_t *dstptr,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendQueryKernelTimestampsTracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents,
void *dstptr,
const size_t *pOffsets,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendQueryKernelTimestamps_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents,
void *dstptr,
const size_t *pOffsets,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
}

32
level_zero/experimental/source/tracing/tracing_cmdqueue_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,10 +8,10 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue) {
zeCommandQueueCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -28,7 +28,7 @@ zeCommandQueueCreate_Tracing(ze_context_handle_t hContext,
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,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -40,7 +40,7 @@ zeCommandQueueCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue) {
zeCommandQueueDestroyTracing(ze_command_queue_handle_t hCommandQueue) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy,
hCommandQueue);
@@ -52,7 +52,7 @@ zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueDestroyCb_t, CommandQueue, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -60,10 +60,10 @@ zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue) {
*tracerParams.phCommandQueue);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence) {
zeCommandQueueExecuteCommandListsTracing(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,
@@ -80,7 +80,7 @@ zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueu
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueExecuteCommandListsCb_t, CommandQueue, pfnExecuteCommandListsCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnExecuteCommandLists,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnExecuteCommandLists,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -92,8 +92,8 @@ zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueu
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueSynchronize_Tracing(ze_command_queue_handle_t hCommandQueue,
uint64_t timeout) {
zeCommandQueueSynchronizeTracing(ze_command_queue_handle_t hCommandQueue,
uint64_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize,
hCommandQueue,
@@ -107,7 +107,7 @@ zeCommandQueueSynchronize_Tracing(ze_command_queue_handle_t hCommandQueue,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandQueueSynchronizeCb_t, CommandQueue, pfnSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

24
level_zero/experimental/source/tracing/tracing_cmdqueue_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,21 +10,21 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue);
zeCommandQueueCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueDestroy_Tracing(ze_command_queue_handle_t hCommandQueue);
zeCommandQueueDestroyTracing(ze_command_queue_handle_t hCommandQueue);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueExecuteCommandLists_Tracing(ze_command_queue_handle_t hCommandQueue,
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence);
zeCommandQueueExecuteCommandListsTracing(ze_command_queue_handle_t hCommandQueue,
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueSynchronize_Tracing(ze_command_queue_handle_t hCommandQueue,
uint64_t timeout);
zeCommandQueueSynchronizeTracing(ze_command_queue_handle_t hCommandQueue,
uint64_t timeout);
}

162
level_zero/experimental/source/tracing/tracing_copy_imp.cpp
View File

@@ -8,13 +8,13 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendMemoryCopyTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy,
hCommandList,
@@ -38,7 +38,7 @@ zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryCopyCb_t, CommandList, pfnAppendMemoryCopyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -53,14 +53,14 @@ zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendMemoryFillTracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill,
hCommandList,
@@ -86,7 +86,7 @@ zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryFillCb_t, CommandList, pfnAppendMemoryFillCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -102,18 +102,18 @@ zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendMemoryCopyRegionTracing(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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion,
hCommandList,
@@ -147,7 +147,7 @@ zeCommandListAppendMemoryCopyRegion_Tracing(ze_command_list_handle_t hCommandLis
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryCopyRegionCb_t, CommandList, pfnAppendMemoryCopyRegionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -167,14 +167,14 @@ zeCommandListAppendMemoryCopyRegion_Tracing(ze_command_list_handle_t hCommandLis
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopyFromContext_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_context_handle_t hContextSrc,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendMemoryCopyFromContextTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_context_handle_t hContextSrc,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyFromContext,
hCommandList,
@@ -200,7 +200,7 @@ zeCommandListAppendMemoryCopyFromContext_Tracing(ze_command_list_handle_t hComma
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryCopyFromContextCb_t, CommandList, pfnAppendMemoryCopyFromContextCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyFromContext,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyFromContext,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -216,12 +216,12 @@ zeCommandListAppendMemoryCopyFromContext_Tracing(ze_command_list_handle_t hComma
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendImageCopyTracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy,
hCommandList,
@@ -243,7 +243,7 @@ zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendImageCopyCb_t, CommandList, pfnAppendImageCopyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -257,14 +257,14 @@ zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendImageCopyRegionTracing(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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion,
hCommandList,
@@ -290,7 +290,7 @@ zeCommandListAppendImageCopyRegion_Tracing(ze_command_list_handle_t hCommandList
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendImageCopyRegionCb_t, CommandList, pfnAppendImageCopyRegionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -306,13 +306,13 @@ zeCommandListAppendImageCopyRegion_Tracing(ze_command_list_handle_t hCommandList
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendImageCopyToMemoryTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory,
hCommandList,
@@ -336,7 +336,7 @@ zeCommandListAppendImageCopyToMemory_Tracing(ze_command_list_handle_t hCommandLi
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendImageCopyToMemoryCb_t, CommandList, pfnAppendImageCopyToMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -351,13 +351,13 @@ zeCommandListAppendImageCopyToMemory_Tracing(ze_command_list_handle_t hCommandLi
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
zeCommandListAppendImageCopyFromMemoryTracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
const void *srcptr,
const ze_image_region_t *pDstRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory,
hCommandList,
@@ -381,7 +381,7 @@ zeCommandListAppendImageCopyFromMemory_Tracing(ze_command_list_handle_t hCommand
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendImageCopyFromMemoryCb_t, CommandList, pfnAppendImageCopyFromMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -396,9 +396,9 @@ zeCommandListAppendImageCopyFromMemory_Tracing(ze_command_list_handle_t hCommand
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size) {
zeCommandListAppendMemoryPrefetchTracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch,
hCommandList,
@@ -414,7 +414,7 @@ zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemoryPrefetchCb_t, CommandList, pfnAppendMemoryPrefetchCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -425,11 +425,11 @@ zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemAdvise_Tracing(ze_command_list_handle_t hCommandList,
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice) {
zeCommandListAppendMemAdviseTracing(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,
@@ -449,7 +449,7 @@ zeCommandListAppendMemAdvise_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendMemAdviseCb_t, CommandList, pfnAppendMemAdviseCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemAdvise,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemAdvise,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

148
level_zero/experimental/source/tracing/tracing_copy_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,94 +10,94 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopy_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryFill_Tracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopyFromContext_Tracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_context_handle_t hContextSrc,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendImageCopy_Tracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
zeCommandListAppendMemoryCopyTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
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,
zeCommandListAppendMemoryFillTracing(ze_command_list_handle_t hCommandList,
void *ptr,
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopyRegionTracing(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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
zeCommandListAppendMemoryCopyFromContextTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_context_handle_t hContextSrc,
const void *srcptr,
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
zeCommandListAppendImageCopyTracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryPrefetch_Tracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size);
zeCommandListAppendImageCopyRegionTracing(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 hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemAdvise_Tracing(ze_command_list_handle_t hCommandList,
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice);
zeCommandListAppendImageCopyToMemoryTracing(ze_command_list_handle_t hCommandList,
void *dstptr,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendImageCopyFromMemoryTracing(ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
const void *srcptr,
const ze_image_region_t *pDstRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryPrefetchTracing(ze_command_list_handle_t hCommandList,
const void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemAdviseTracing(ze_command_list_handle_t hCommandList,
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice);
} // extern "C"

102
level_zero/experimental/source/tracing/tracing_device_imp.cpp
View File

@@ -8,9 +8,9 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices) {
zeDeviceGetTracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGet,
hDriver,
@@ -26,7 +26,7 @@ zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetCb_t, Device, pfnGetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGet,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGet,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -37,8 +37,8 @@ zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties) {
zeDeviceGetPropertiesTracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetProperties,
hDevice,
@@ -52,7 +52,7 @@ zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetPropertiesCb_t, Device, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -62,8 +62,8 @@ zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties) {
zeDeviceGetComputePropertiesTracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties,
hDevice,
@@ -77,7 +77,7 @@ zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetComputePropertiesCb_t, Device, pfnGetComputePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -87,9 +87,9 @@ zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_memory_properties_t *pMemProperties) {
zeDeviceGetMemoryPropertiesTracing(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,
@@ -105,7 +105,7 @@ zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetMemoryPropertiesCb_t, Device, pfnGetMemoryPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -116,9 +116,9 @@ zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties) {
zeDeviceGetCachePropertiesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties,
hDevice,
@@ -134,7 +134,7 @@ zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetCachePropertiesCb_t, Device, pfnGetCachePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -145,8 +145,8 @@ zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties) {
zeDeviceGetImagePropertiesTracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties,
hDevice,
@@ -160,7 +160,7 @@ zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetImagePropertiesCb_t, Device, pfnGetImagePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -170,9 +170,9 @@ zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices) {
zeDeviceGetSubDevicesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices,
hDevice,
@@ -188,7 +188,7 @@ zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetSubDevicesCb_t, Device, pfnGetSubDevicesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -199,9 +199,9 @@ zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) {
zeDeviceGetP2PPropertiesTracing(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,
@@ -217,7 +217,7 @@ zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetP2PPropertiesCb_t, Device, pfnGetP2PPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetP2PProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetP2PProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -228,9 +228,9 @@ zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value) {
zeDeviceCanAccessPeerTracing(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,
@@ -246,7 +246,7 @@ zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceCanAccessPeerCb_t, Device, pfnCanAccessPeerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -257,8 +257,8 @@ zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetCacheConfig_Tracing(ze_kernel_handle_t hKernel,
ze_cache_config_flags_t flags) {
zeKernelSetCacheConfigTracing(ze_kernel_handle_t hKernel,
ze_cache_config_flags_t flags) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetCacheConfig,
hKernel,
@@ -272,7 +272,7 @@ zeKernelSetCacheConfig_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetCacheConfigCb_t, Kernel, pfnSetCacheConfigCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetCacheConfig,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetCacheConfig,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -282,8 +282,8 @@ zeKernelSetCacheConfig_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties) {
zeDeviceGetMemoryAccessPropertiesTracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties,
hDevice,
@@ -298,7 +298,7 @@ zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetMemoryAccessPropertiesCb_t, Device,
pfnGetMemoryAccessPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -308,8 +308,8 @@ zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetModuleProperties_Tracing(ze_device_handle_t hDevice,
ze_device_module_properties_t *pModuleProperties) {
zeDeviceGetModulePropertiesTracing(ze_device_handle_t hDevice,
ze_device_module_properties_t *pModuleProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetModuleProperties,
hDevice,
@@ -323,7 +323,7 @@ zeDeviceGetModuleProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetModulePropertiesCb_t, Device, pfnGetModulePropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetModuleProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetModuleProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -333,9 +333,9 @@ zeDeviceGetModuleProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetCommandQueueGroupProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {
zeDeviceGetCommandQueueGroupPropertiesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetCommandQueueGroupProperties,
hDevice,
@@ -351,7 +351,7 @@ zeDeviceGetCommandQueueGroupProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetCommandQueueGroupPropertiesCb_t, Device, pfnGetCommandQueueGroupPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetCommandQueueGroupProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetCommandQueueGroupProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -362,8 +362,8 @@ zeDeviceGetCommandQueueGroupProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetExternalMemoryProperties_Tracing(ze_device_handle_t hDevice,
ze_device_external_memory_properties_t *pExternalMemoryProperties) {
zeDeviceGetExternalMemoryPropertiesTracing(ze_device_handle_t hDevice,
ze_device_external_memory_properties_t *pExternalMemoryProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetExternalMemoryProperties,
hDevice,
@@ -377,7 +377,7 @@ zeDeviceGetExternalMemoryProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetExternalMemoryPropertiesCb_t, Device, pfnGetExternalMemoryPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetExternalMemoryProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetExternalMemoryProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -387,7 +387,7 @@ zeDeviceGetExternalMemoryProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetStatus_Tracing(ze_device_handle_t hDevice) {
zeDeviceGetStatusTracing(ze_device_handle_t hDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnGetStatus,
hDevice);
@@ -399,7 +399,7 @@ zeDeviceGetStatus_Tracing(ze_device_handle_t hDevice) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceGetStatusCb_t, Device, pfnGetStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetStatus,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnGetStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

76
level_zero/experimental/source/tracing/tracing_device_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,68 +10,68 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGet_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices);
zeDeviceGetTracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_device_handle_t *phDevices);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetProperties_Tracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties);
zeDeviceGetPropertiesTracing(ze_device_handle_t hDevice,
ze_device_properties_t *pDeviceProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetComputeProperties_Tracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties);
zeDeviceGetComputePropertiesTracing(ze_device_handle_t hDevice,
ze_device_compute_properties_t *pComputeProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetMemoryProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_memory_properties_t *pMemProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetCacheProperties_Tracing(ze_device_handle_t hDevice,
zeDeviceGetMemoryPropertiesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties);
ze_device_memory_properties_t *pMemProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetImageProperties_Tracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties);
zeDeviceGetCachePropertiesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetSubDevices_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices);
zeDeviceGetImagePropertiesTracing(ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetP2PProperties_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties);
zeDeviceGetSubDevicesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceCanAccessPeer_Tracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value);
zeDeviceGetP2PPropertiesTracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetCacheConfig_Tracing(ze_kernel_handle_t hKernel,
ze_cache_config_flags_t flags);
zeDeviceCanAccessPeerTracing(ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetMemoryAccessProperties_Tracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties);
zeKernelSetCacheConfigTracing(ze_kernel_handle_t hKernel,
ze_cache_config_flags_t flags);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetModuleProperties_Tracing(ze_device_handle_t hDevice,
ze_device_module_properties_t *pModuleProperties);
zeDeviceGetMemoryAccessPropertiesTracing(ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetCommandQueueGroupProperties_Tracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_command_queue_group_properties_t *pCommandQueueGroupProperties);
zeDeviceGetModulePropertiesTracing(ze_device_handle_t hDevice,
ze_device_module_properties_t *pModuleProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetExternalMemoryProperties_Tracing(ze_device_handle_t hDevice,
ze_device_external_memory_properties_t *pExternalMemoryProperties);
zeDeviceGetCommandQueueGroupPropertiesTracing(ze_device_handle_t hDevice,
uint32_t *pCount,
ze_command_queue_group_properties_t *pCommandQueueGroupProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetStatus_Tracing(ze_device_handle_t hDevice);
zeDeviceGetExternalMemoryPropertiesTracing(ze_device_handle_t hDevice,
ze_device_external_memory_properties_t *pExternalMemoryProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetStatusTracing(ze_device_handle_t hDevice);
}

34
level_zero/experimental/source/tracing/tracing_driver_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,8 +8,8 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGet_Tracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers) {
zeDriverGetTracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGet,
pCount,
@@ -23,7 +23,7 @@ zeDriverGet_Tracing(uint32_t *pCount,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetCb_t, Driver, pfnGetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGet,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGet,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -33,8 +33,8 @@ zeDriverGet_Tracing(uint32_t *pCount,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties) {
zeDriverGetPropertiesTracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetProperties,
hDriver,
@@ -47,7 +47,7 @@ zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetPropertiesCb_t, Driver, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -57,8 +57,8 @@ zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version) {
zeDriverGetApiVersionTracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion, hDrivers, version);
@@ -70,7 +70,7 @@ zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetApiVersionCb_t, Driver, pfnGetApiVersionCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -80,8 +80,8 @@ zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetIpcProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIpcProperties) {
zeDriverGetIpcPropertiesTracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIpcProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetIpcProperties,
hDriver,
@@ -95,7 +95,7 @@ zeDriverGetIpcProperties_Tracing(ze_driver_handle_t hDriver,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetIpcPropertiesCb_t, Driver, pfnGetIpcPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetIpcProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetIpcProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -105,9 +105,9 @@ zeDriverGetIpcProperties_Tracing(ze_driver_handle_t hDriver,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetExtensionProperties_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_driver_extension_properties_t *pExtensionProperties) {
zeDriverGetExtensionPropertiesTracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_driver_extension_properties_t *pExtensionProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionProperties,
hDriver,
@@ -123,7 +123,7 @@ zeDriverGetExtensionProperties_Tracing(ze_driver_handle_t hDriver,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDriverGetExtensionPropertiesCb_t, Driver, pfnGetExtensionPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

24
level_zero/experimental/source/tracing/tracing_driver_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,23 +10,23 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGet_Tracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers);
zeDriverGetTracing(uint32_t *pCount,
ze_driver_handle_t *phDrivers);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties);
zeDriverGetPropertiesTracing(ze_driver_handle_t hDriver,
ze_driver_properties_t *properties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetApiVersion_Tracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version);
zeDriverGetApiVersionTracing(ze_driver_handle_t hDrivers,
ze_api_version_t *version);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetIpcProperties_Tracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIpcProperties);
zeDriverGetIpcPropertiesTracing(ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIpcProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetExtensionProperties_Tracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_driver_extension_properties_t *pExtensionProperties);
zeDriverGetExtensionPropertiesTracing(ze_driver_handle_t hDriver,
uint32_t *pCount,
ze_driver_extension_properties_t *pExtensionProperties);
}

92
level_zero/experimental/source/tracing/tracing_event_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,11 +8,11 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolCreate_Tracing(ze_context_handle_t hContext,
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) {
zeEventPoolCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -32,7 +32,7 @@ zeEventPoolCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolCreateCb_t, EventPool, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -45,7 +45,7 @@ zeEventPoolCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool) {
zeEventPoolDestroyTracing(ze_event_pool_handle_t hEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnDestroy,
hEventPool);
@@ -57,7 +57,7 @@ zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolDestroyCb_t, EventPool, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -66,9 +66,9 @@ zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
const ze_event_desc_t *desc,
ze_event_handle_t *phEvent) {
zeEventCreateTracing(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,
@@ -84,7 +84,7 @@ zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventCreateCb_t, Event, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -95,7 +95,7 @@ zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventDestroy_Tracing(ze_event_handle_t hEvent) {
zeEventDestroyTracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnDestroy,
hEvent);
@@ -107,7 +107,7 @@ zeEventDestroy_Tracing(ze_event_handle_t hEvent) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventDestroyCb_t, Event, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -116,8 +116,8 @@ zeEventDestroy_Tracing(ze_event_handle_t hEvent) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc) {
zeEventPoolGetIpcHandleTracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle,
hEventPool,
@@ -131,7 +131,7 @@ zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolGetIpcHandleCb_t, EventPool, pfnGetIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -141,9 +141,9 @@ zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) {
zeEventPoolOpenIpcHandleTracing(ze_context_handle_t hContext,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle,
hContext,
@@ -159,7 +159,7 @@ zeEventPoolOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolOpenIpcHandleCb_t, EventPool, pfnOpenIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -170,7 +170,7 @@ zeEventPoolOpenIpcHandle_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool) {
zeEventPoolCloseIpcHandleTracing(ze_event_pool_handle_t hEventPool) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle,
hEventPool);
@@ -182,7 +182,7 @@ zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventPoolCloseIpcHandleCb_t, EventPool, pfnCloseIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -191,8 +191,8 @@ zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
zeCommandListAppendSignalEventTracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent,
hCommandList,
@@ -206,7 +206,7 @@ zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendSignalEventCb_t, CommandList, pfnAppendSignalEventCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -216,9 +216,9 @@ zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents) {
zeCommandListAppendWaitOnEventsTracing(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,
@@ -234,7 +234,7 @@ zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendWaitOnEventsCb_t, CommandList, pfnAppendWaitOnEventsCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWaitOnEvents,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendWaitOnEvents,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -245,7 +245,7 @@ zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSignal_Tracing(ze_event_handle_t hEvent) {
zeEventHostSignalTracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostSignal,
hEvent);
@@ -257,7 +257,7 @@ zeEventHostSignal_Tracing(ze_event_handle_t hEvent) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostSignalCb_t, Event, pfnHostSignalCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSignal,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSignal,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -266,8 +266,8 @@ zeEventHostSignal_Tracing(ze_event_handle_t hEvent) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
uint64_t timeout) {
zeEventHostSynchronizeTracing(ze_event_handle_t hEvent,
uint64_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize,
hEvent,
@@ -281,7 +281,7 @@ zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostSynchronizeCb_t, Event, pfnHostSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -291,7 +291,7 @@ zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryStatus_Tracing(ze_event_handle_t hEvent) {
zeEventQueryStatusTracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnQueryStatus,
hEvent);
@@ -303,7 +303,7 @@ zeEventQueryStatus_Tracing(ze_event_handle_t hEvent) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventQueryStatusCb_t, Event, pfnQueryStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnQueryStatus,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnQueryStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -312,7 +312,7 @@ zeEventQueryStatus_Tracing(ze_event_handle_t hEvent) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostReset_Tracing(ze_event_handle_t hEvent) {
zeEventHostResetTracing(ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnHostReset,
hEvent);
@@ -324,7 +324,7 @@ zeEventHostReset_Tracing(ze_event_handle_t hEvent) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventHostResetCb_t, Event, pfnHostResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostReset,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnHostReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -333,8 +333,8 @@ zeEventHostReset_Tracing(ze_event_handle_t hEvent) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
zeCommandListAppendEventResetTracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset,
hCommandList,
@@ -349,7 +349,7 @@ zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendEventResetCb_t,
CommandList, pfnAppendEventResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -359,8 +359,8 @@ zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryKernelTimestamp_Tracing(ze_event_handle_t hEvent,
ze_kernel_timestamp_result_t *dstptr) {
zeEventQueryKernelTimestampTracing(ze_event_handle_t hEvent,
ze_kernel_timestamp_result_t *dstptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Event.pfnQueryKernelTimestamp,
hEvent,
@@ -374,7 +374,7 @@ zeEventQueryKernelTimestamp_Tracing(ze_event_handle_t hEvent,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnEventQueryKernelTimestampCb_t, Event, pfnQueryKernelTimestampCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnQueryKernelTimestamp,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Event.pfnQueryKernelTimestamp,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

84
level_zero/experimental/source/tracing/tracing_event_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,62 +10,62 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolCreate_Tracing(ze_context_handle_t hContext,
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool);
zeEventPoolCreateTracing(ze_context_handle_t hContext,
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolDestroy_Tracing(ze_event_pool_handle_t hEventPool);
zeEventPoolDestroyTracing(ze_event_pool_handle_t hEventPool);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventCreate_Tracing(ze_event_pool_handle_t hEventPool,
const ze_event_desc_t *desc,
ze_event_handle_t *phEvent);
zeEventCreateTracing(ze_event_pool_handle_t hEventPool,
const ze_event_desc_t *desc,
ze_event_handle_t *phEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventDestroy_Tracing(ze_event_handle_t hEvent);
zeEventDestroyTracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolGetIpcHandle_Tracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc);
zeEventPoolGetIpcHandleTracing(ze_event_pool_handle_t hEventPool,
ze_ipc_event_pool_handle_t *phIpc);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool);
zeEventPoolOpenIpcHandleTracing(ze_context_handle_t hContext,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolCloseIpcHandle_Tracing(ze_event_pool_handle_t hEventPool);
zeEventPoolCloseIpcHandleTracing(ze_event_pool_handle_t hEventPool);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendSignalEvent_Tracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendWaitOnEvents_Tracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSignal_Tracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSynchronize_Tracing(ze_event_handle_t hEvent,
uint64_t timeout);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryStatus_Tracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostReset_Tracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendEventReset_Tracing(ze_command_list_handle_t hCommandList,
zeCommandListAppendSignalEventTracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryKernelTimestamp_Tracing(ze_event_handle_t hEvent,
ze_kernel_timestamp_result_t *dstptr);
zeCommandListAppendWaitOnEventsTracing(ze_command_list_handle_t hCommandList,
uint32_t numEvents,
ze_event_handle_t *phEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSignalTracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSynchronizeTracing(ze_event_handle_t hEvent,
uint64_t timeout);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryStatusTracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostResetTracing(ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendEventResetTracing(ze_command_list_handle_t hCommandList,
ze_event_handle_t hEvent);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryKernelTimestampTracing(ze_event_handle_t hEvent,
ze_kernel_timestamp_result_t *dstptr);
}

28
level_zero/experimental/source/tracing/tracing_fence_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,9 +8,9 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
const ze_fence_desc_t *desc,
ze_fence_handle_t *phFence) {
zeFenceCreateTracing(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,
@@ -26,7 +26,7 @@ zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceCreateCb_t, Fence, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -37,7 +37,7 @@ zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceDestroy_Tracing(ze_fence_handle_t hFence) {
zeFenceDestroyTracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnDestroy,
hFence);
@@ -49,7 +49,7 @@ zeFenceDestroy_Tracing(ze_fence_handle_t hFence) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceDestroyCb_t, Fence, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -58,8 +58,8 @@ zeFenceDestroy_Tracing(ze_fence_handle_t hFence) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
uint64_t timeout) {
zeFenceHostSynchronizeTracing(ze_fence_handle_t hFence,
uint64_t timeout) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize,
hFence,
@@ -73,7 +73,7 @@ zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceHostSynchronizeCb_t, Fence, pfnHostSynchronizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -83,7 +83,7 @@ zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence) {
zeFenceQueryStatusTracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus,
hFence);
@@ -95,7 +95,7 @@ zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceQueryStatusCb_t, Fence, pfnQueryStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -104,7 +104,7 @@ zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceReset_Tracing(ze_fence_handle_t hFence) {
zeFenceResetTracing(ze_fence_handle_t hFence) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Fence.pfnReset,
hFence);
@@ -116,7 +116,7 @@ zeFenceReset_Tracing(ze_fence_handle_t hFence) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnFenceResetCb_t, Fence, pfnResetCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnReset,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Fence.pfnReset,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

18
level_zero/experimental/source/tracing/tracing_fence_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,20 +10,20 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceCreate_Tracing(ze_command_queue_handle_t hCommandQueue,
const ze_fence_desc_t *desc,
ze_fence_handle_t *phFence);
zeFenceCreateTracing(ze_command_queue_handle_t hCommandQueue,
const ze_fence_desc_t *desc,
ze_fence_handle_t *phFence);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceDestroy_Tracing(ze_fence_handle_t hFence);
zeFenceDestroyTracing(ze_fence_handle_t hFence);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceHostSynchronize_Tracing(ze_fence_handle_t hFence,
uint64_t timeout);
zeFenceHostSynchronizeTracing(ze_fence_handle_t hFence,
uint64_t timeout);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceQueryStatus_Tracing(ze_fence_handle_t hFence);
zeFenceQueryStatusTracing(ze_fence_handle_t hFence);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceReset_Tracing(ze_fence_handle_t hFence);
zeFenceResetTracing(ze_fence_handle_t hFence);
}

6
level_zero/experimental/source/tracing/tracing_global_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,7 +8,7 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeInit_Tracing(ze_init_flags_t flags) {
zeInitTracing(ze_init_flags_t flags) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Global.pfnInit,
flags);
@@ -19,7 +19,7 @@ zeInit_Tracing(ze_init_flags_t flags) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnInitCb_t, Global, pfnInitCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Global.pfnInit,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Global.pfnInit,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

4
level_zero/experimental/source/tracing/tracing_global_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,5 +10,5 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeInit_Tracing(ze_init_flags_t flags);
zeInitTracing(ze_init_flags_t flags);
}

24
level_zero/experimental/source/tracing/tracing_image_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,9 +8,9 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_properties_t *pImageProperties) {
zeImageGetPropertiesTracing(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,
@@ -26,7 +26,7 @@ zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageGetPropertiesCb_t, Image, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnGetProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -37,10 +37,10 @@ zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) {
zeImageCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -58,7 +58,7 @@ zeImageCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageCreateCb_t, Image, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -70,7 +70,7 @@ zeImageCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageDestroy_Tracing(ze_image_handle_t hImage) {
zeImageDestroyTracing(ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Image.pfnDestroy,
hImage);
@@ -82,7 +82,7 @@ zeImageDestroy_Tracing(ze_image_handle_t hImage) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnImageDestroyCb_t, Image, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Image.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

18
level_zero/experimental/source/tracing/tracing_image_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,16 +10,16 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageGetProperties_Tracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_properties_t *pImageProperties);
zeImageGetPropertiesTracing(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_properties_t *pImageProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage);
zeImageCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageDestroy_Tracing(ze_image_handle_t hImage);
zeImageDestroyTracing(ze_image_handle_t hImage);
}

2
level_zero/experimental/source/tracing/tracing_imp.h
View File

@@ -186,7 +186,7 @@ class APITracerCallbackDataImp {
}
template <typename TFunction_pointer, typename TParams, typename TTracer, typename TTracerPrologCallbacks, typename TTracerEpilogCallbacks, typename... Args>
ze_result_t APITracerWrapperImp(TFunction_pointer zeApiPtr,
ze_result_t apiTracerWrapperImp(TFunction_pointer zeApiPtr,
TParams paramsStruct,
TTracer apiOrdinal,
TTracerPrologCallbacks prologCallbacks,

184
level_zero/experimental/source/tracing/tracing_memory_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,13 +8,13 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocShared_Tracing(ze_context_handle_t hContext,
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) {
zeMemAllocSharedTracing(ze_context_handle_t hContext,
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.Mem.pfnAllocShared,
hContext,
@@ -38,7 +38,7 @@ zeMemAllocShared_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocSharedCb_t, Mem, pfnAllocSharedCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocShared,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocShared,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -53,12 +53,12 @@ zeMemAllocShared_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocDevice_Tracing(ze_context_handle_t hContext,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr) {
zeMemAllocDeviceTracing(ze_context_handle_t hContext,
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.Mem.pfnAllocDevice,
hContext,
@@ -80,7 +80,7 @@ zeMemAllocDevice_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocDeviceCb_t, Mem, pfnAllocDeviceCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocDevice,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocDevice,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -94,11 +94,11 @@ zeMemAllocDevice_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocHost_Tracing(ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr) {
zeMemAllocHostTracing(ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnAllocHost,
hContext,
@@ -118,7 +118,7 @@ zeMemAllocHost_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocHostCb_t, Mem, pfnAllocHostCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocHost,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnAllocHost,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -131,8 +131,8 @@ zeMemAllocHost_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemFree_Tracing(ze_context_handle_t hContext,
void *ptr) {
zeMemFreeTracing(ze_context_handle_t hContext,
void *ptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnFree,
hContext,
@@ -146,7 +146,7 @@ zeMemFree_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemFreeCb_t, Mem, pfnFreeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnFree,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnFree,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -156,10 +156,10 @@ zeMemFree_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAllocProperties_Tracing(ze_context_handle_t hContext,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {
zeMemGetAllocPropertiesTracing(ze_context_handle_t hContext,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnGetAllocProperties,
hContext,
@@ -177,7 +177,7 @@ zeMemGetAllocProperties_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetAllocPropertiesCb_t, Mem, pfnGetAllocPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetAllocProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetAllocProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -189,10 +189,10 @@ zeMemGetAllocProperties_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAddressRange_Tracing(ze_context_handle_t hContext,
const void *ptr,
void **pBase,
size_t *pSize) {
zeMemGetAddressRangeTracing(ze_context_handle_t hContext,
const void *ptr,
void **pBase,
size_t *pSize) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnGetAddressRange,
hContext,
@@ -210,7 +210,7 @@ zeMemGetAddressRange_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetAddressRangeCb_t, Mem, pfnGetAddressRangeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetAddressRange,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetAddressRange,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -222,9 +222,9 @@ zeMemGetAddressRange_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetIpcHandle_Tracing(ze_context_handle_t hContext,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
zeMemGetIpcHandleTracing(ze_context_handle_t hContext,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnGetIpcHandle,
hContext,
@@ -240,7 +240,7 @@ zeMemGetIpcHandle_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetIpcHandleCb_t, Mem, pfnGetIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnGetIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -251,11 +251,11 @@ zeMemGetIpcHandle_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **pptr) {
zeMemOpenIpcHandleTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnOpenIpcHandle,
hContext,
@@ -275,7 +275,7 @@ zeMemOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemOpenIpcHandleCb_t, Mem, pfnOpenIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnOpenIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnOpenIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -288,8 +288,8 @@ zeMemOpenIpcHandle_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemCloseIpcHandle_Tracing(ze_context_handle_t hContext,
const void *ptr) {
zeMemCloseIpcHandleTracing(ze_context_handle_t hContext,
const void *ptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Mem.pfnCloseIpcHandle,
hContext,
@@ -303,7 +303,7 @@ zeMemCloseIpcHandle_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemCloseIpcHandleCb_t, Mem, pfnCloseIpcHandleCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnCloseIpcHandle,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Mem.pfnCloseIpcHandle,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -313,10 +313,10 @@ zeMemCloseIpcHandle_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemReserve_Tracing(ze_context_handle_t hContext,
const void *pStart,
size_t size,
void **pptr) {
zeVirtualMemReserveTracing(ze_context_handle_t hContext,
const void *pStart,
size_t size,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnReserve,
hContext,
@@ -334,7 +334,7 @@ zeVirtualMemReserve_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemReserveCb_t, VirtualMem, pfnReserveCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnReserve,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnReserve,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -346,9 +346,9 @@ zeVirtualMemReserve_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemFree_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size) {
zeVirtualMemFreeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnFree,
hContext,
@@ -364,7 +364,7 @@ zeVirtualMemFree_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemFreeCb_t, VirtualMem, pfnFreeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnFree,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnFree,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -375,10 +375,10 @@ zeVirtualMemFree_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemQueryPageSize_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
size_t size,
size_t *pagesize) {
zeVirtualMemQueryPageSizeTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
size_t size,
size_t *pagesize) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnQueryPageSize,
hContext,
@@ -396,7 +396,7 @@ zeVirtualMemQueryPageSize_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemQueryPageSizeCb_t, VirtualMem, pfnQueryPageSizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnQueryPageSize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnQueryPageSize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -408,12 +408,12 @@ zeVirtualMemQueryPageSize_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemMap_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_physical_mem_handle_t hPhysicalMemory,
size_t offset,
ze_memory_access_attribute_t access) {
zeVirtualMemMapTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_physical_mem_handle_t hPhysicalMemory,
size_t offset,
ze_memory_access_attribute_t access) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnMap,
hContext,
@@ -435,7 +435,7 @@ zeVirtualMemMap_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemMapCb_t, VirtualMem, pfnMapCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnMap,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnMap,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -449,9 +449,9 @@ zeVirtualMemMap_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemUnmap_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size) {
zeVirtualMemUnmapTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnUnmap,
hContext,
@@ -467,7 +467,7 @@ zeVirtualMemUnmap_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemUnmapCb_t, VirtualMem, pfnUnmapCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnUnmap,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnUnmap,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -478,10 +478,10 @@ zeVirtualMemUnmap_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemSetAccessAttribute_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t access) {
zeVirtualMemSetAccessAttributeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t access) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnSetAccessAttribute,
hContext,
@@ -499,7 +499,7 @@ zeVirtualMemSetAccessAttribute_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemSetAccessAttributeCb_t, VirtualMem, pfnSetAccessAttributeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnSetAccessAttribute,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnSetAccessAttribute,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -511,11 +511,11 @@ zeVirtualMemSetAccessAttribute_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemGetAccessAttribute_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize) {
zeVirtualMemGetAccessAttributeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.VirtualMem.pfnGetAccessAttribute,
hContext,
@@ -535,7 +535,7 @@ zeVirtualMemGetAccessAttribute_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemGetAccessAttributeCb_t, VirtualMem, pfnGetAccessAttributeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnGetAccessAttribute,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.VirtualMem.pfnGetAccessAttribute,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -548,10 +548,10 @@ zeVirtualMemGetAccessAttribute_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zePhysicalMemCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_physical_mem_desc_t *desc,
ze_physical_mem_handle_t *phPhysicalMemory) {
zePhysicalMemCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_physical_mem_desc_t *desc,
ze_physical_mem_handle_t *phPhysicalMemory) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.PhysicalMem.pfnCreate,
hContext,
@@ -569,7 +569,7 @@ zePhysicalMemCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnPhysicalMemCreateCb_t, PhysicalMem, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.PhysicalMem.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.PhysicalMem.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -581,8 +581,8 @@ zePhysicalMemCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zePhysicalMemDestroy_Tracing(ze_context_handle_t hContext,
ze_physical_mem_handle_t hPhysicalMemory) {
zePhysicalMemDestroyTracing(ze_context_handle_t hContext,
ze_physical_mem_handle_t hPhysicalMemory) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.PhysicalMem.pfnDestroy,
hContext,
@@ -596,7 +596,7 @@ zePhysicalMemDestroy_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnPhysicalMemDestroyCb_t, PhysicalMem, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.PhysicalMem.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.PhysicalMem.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

154
level_zero/experimental/source/tracing/tracing_memory_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,111 +10,111 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocShared_Tracing(ze_context_handle_t hContext,
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);
zeMemAllocSharedTracing(ze_context_handle_t hContext,
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_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocDevice_Tracing(ze_context_handle_t hContext,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr);
zeMemAllocDeviceTracing(ze_context_handle_t hContext,
const ze_device_mem_alloc_desc_t *deviceDesc,
size_t size,
size_t alignment,
ze_device_handle_t hDevice,
void **pptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocHost_Tracing(ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr);
zeMemAllocHostTracing(ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemFree_Tracing(ze_context_handle_t hContext,
void *ptr);
zeMemFreeTracing(ze_context_handle_t hContext,
void *ptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAllocProperties_Tracing(ze_context_handle_t hContext,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice);
zeMemGetAllocPropertiesTracing(ze_context_handle_t hContext,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAddressRange_Tracing(ze_context_handle_t hContext,
const void *ptr,
void **pBase,
size_t *pSize);
zeMemGetAddressRangeTracing(ze_context_handle_t hContext,
const void *ptr,
void **pBase,
size_t *pSize);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetIpcHandle_Tracing(ze_context_handle_t hContext,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle);
zeMemGetIpcHandleTracing(ze_context_handle_t hContext,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemOpenIpcHandle_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
zeMemOpenIpcHandleTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flags_t flags,
void **pptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemCloseIpcHandleTracing(ze_context_handle_t hContext,
const void *ptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemReserveTracing(ze_context_handle_t hContext,
const void *pStart,
size_t size,
void **pptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemCloseIpcHandle_Tracing(ze_context_handle_t hContext,
const void *ptr);
zeVirtualMemFreeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemReserve_Tracing(ze_context_handle_t hContext,
const void *pStart,
size_t size,
void **pptr);
zeVirtualMemQueryPageSizeTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
size_t size,
size_t *pagesize);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemFree_Tracing(ze_context_handle_t hContext,
zeVirtualMemMapTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_physical_mem_handle_t hPhysicalMemory,
size_t offset,
ze_memory_access_attribute_t access);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemUnmapTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemQueryPageSize_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
size_t size,
size_t *pagesize);
zeVirtualMemSetAccessAttributeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t access);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemMap_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_physical_mem_handle_t hPhysicalMemory,
size_t offset,
ze_memory_access_attribute_t access);
zeVirtualMemGetAccessAttributeTracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemUnmap_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size);
zePhysicalMemCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_physical_mem_desc_t *desc,
ze_physical_mem_handle_t *phPhysicalMemory);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemSetAccessAttribute_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t access);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeVirtualMemGetAccessAttribute_Tracing(ze_context_handle_t hContext,
const void *ptr,
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize);
ZE_APIEXPORT ze_result_t ZE_APICALL
zePhysicalMemCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_physical_mem_desc_t *desc,
ze_physical_mem_handle_t *phPhysicalMemory);
ZE_APIEXPORT ze_result_t ZE_APICALL
zePhysicalMemDestroy_Tracing(ze_context_handle_t hContext,
ze_physical_mem_handle_t hPhysicalMemory);
zePhysicalMemDestroyTracing(ze_context_handle_t hContext,
ze_physical_mem_handle_t hPhysicalMemory);
}

226
level_zero/experimental/source/tracing/tracing_module_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,11 +8,11 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
zeModuleCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -32,7 +32,7 @@ zeModuleCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleCreateCb_t, Module, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -45,7 +45,7 @@ zeModuleCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleDestroy_Tracing(ze_module_handle_t hModule) {
zeModuleDestroyTracing(ze_module_handle_t hModule) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnDestroy,
hModule);
@@ -57,7 +57,7 @@ zeModuleDestroy_Tracing(ze_module_handle_t hModule) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleDestroyCb_t, Module, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -66,7 +66,7 @@ zeModuleDestroy_Tracing(ze_module_handle_t hModule) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog) {
zeModuleBuildLogDestroyTracing(ze_module_build_log_handle_t hModuleBuildLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy,
hModuleBuildLog);
@@ -78,7 +78,7 @@ zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleBuildLogDestroyCb_t, ModuleBuildLog, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -87,9 +87,9 @@ zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
char *pBuildLog) {
zeModuleBuildLogGetStringTracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
char *pBuildLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString,
hModuleBuildLog,
@@ -105,7 +105,7 @@ zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleBuildLogGetStringCb_t, ModuleBuildLog, pfnGetStringCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -116,9 +116,9 @@ zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary) {
zeModuleGetNativeBinaryTracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary,
hModule,
@@ -134,7 +134,7 @@ zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetNativeBinaryCb_t, Module, pfnGetNativeBinaryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -145,10 +145,10 @@ zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
const char *pGlobalName,
size_t *pSize,
void **pptr) {
zeModuleGetGlobalPointerTracing(ze_module_handle_t hModule,
const char *pGlobalName,
size_t *pSize,
void **pptr) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer,
hModule,
@@ -166,7 +166,7 @@ zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetGlobalPointerCb_t, Module, pfnGetGlobalPointerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -178,9 +178,9 @@ zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleDynamicLink_Tracing(uint32_t numModules,
ze_module_handle_t *phModules,
ze_module_build_log_handle_t *phLinkLog) {
zeModuleDynamicLinkTracing(uint32_t numModules,
ze_module_handle_t *phModules,
ze_module_build_log_handle_t *phLinkLog) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnDynamicLink,
numModules,
@@ -196,7 +196,7 @@ zeModuleDynamicLink_Tracing(uint32_t numModules,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleDynamicLinkCb_t, Module, pfnDynamicLinkCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnDynamicLink,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnDynamicLink,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -207,8 +207,8 @@ zeModuleDynamicLink_Tracing(uint32_t numModules,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetProperties_Tracing(ze_module_handle_t hModule,
ze_module_properties_t *pModuleProperties) {
zeModuleGetPropertiesTracing(ze_module_handle_t hModule,
ze_module_properties_t *pModuleProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetProperties,
hModule,
@@ -222,7 +222,7 @@ zeModuleGetProperties_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetPropertiesCb_t, Module, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -232,9 +232,9 @@ zeModuleGetProperties_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelCreate_Tracing(ze_module_handle_t hModule,
const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phKernel) {
zeKernelCreateTracing(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,
@@ -250,7 +250,7 @@ zeKernelCreate_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelCreateCb_t, Kernel, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -261,7 +261,7 @@ zeKernelCreate_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelDestroy_Tracing(ze_kernel_handle_t hKernel) {
zeKernelDestroyTracing(ze_kernel_handle_t hKernel) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnDestroy,
hKernel);
@@ -273,7 +273,7 @@ zeKernelDestroy_Tracing(ze_kernel_handle_t hKernel) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelDestroyCb_t, Kernel, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -282,9 +282,9 @@ zeKernelDestroy_Tracing(ze_kernel_handle_t hKernel) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction) {
zeModuleGetFunctionPointerTracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer,
hModule,
@@ -300,7 +300,7 @@ zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetFunctionPointerCb_t, Module, pfnGetFunctionPointerCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -311,10 +311,10 @@ zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hKernel,
uint32_t groupSizeX,
uint32_t groupSizeY,
uint32_t groupSizeZ) {
zeKernelSetGroupSizeTracing(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,
@@ -332,7 +332,7 @@ zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetGroupSizeCb_t, Kernel, pfnSetGroupSizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetGroupSize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetGroupSize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -344,13 +344,13 @@ zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeKernelSuggestGroupSizeTracing(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,
@@ -374,7 +374,7 @@ zeKernelSuggestGroupSize_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSuggestGroupSizeCb_t, Kernel, pfnSuggestGroupSizeCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestGroupSize,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestGroupSize,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -389,10 +389,10 @@ zeKernelSuggestGroupSize_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hKernel,
uint32_t argIndex,
size_t argSize,
const void *pArgValue) {
zeKernelSetArgumentValueTracing(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,
@@ -410,7 +410,7 @@ zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetArgumentValueCb_t, Kernel, pfnSetArgumentValueCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -422,8 +422,8 @@ zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties) {
zeKernelGetPropertiesTracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties,
hKernel,
@@ -437,7 +437,7 @@ zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetPropertiesCb_t, Kernel, pfnGetPropertiesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -447,12 +447,12 @@ zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeCommandListAppendLaunchKernelTracing(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,
@@ -476,7 +476,7 @@ zeCommandListAppendLaunchKernel_Tracing(ze_command_list_handle_t hCommandList,
CommandList,
pfnAppendLaunchKernelCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernel,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernel,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -490,12 +490,12 @@ zeCommandListAppendLaunchKernel_Tracing(ze_command_list_handle_t hCommandList,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeCommandListAppendLaunchKernelIndirectTracing(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,
@@ -519,7 +519,7 @@ zeCommandListAppendLaunchKernelIndirect_Tracing(ze_command_list_handle_t hComman
CommandList,
pfnAppendLaunchKernelIndirectCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernelIndirect,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernelIndirect,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -533,14 +533,14 @@ zeCommandListAppendLaunchKernelIndirect_Tracing(ze_command_list_handle_t hComman
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeCommandListAppendLaunchMultipleKernelsIndirectTracing(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,
@@ -568,7 +568,7 @@ zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(ze_command_list_handle_
CommandList,
pfnAppendLaunchMultipleKernelsIndirectCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -584,12 +584,12 @@ zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(ze_command_list_handle_
}
ZE_APIEXPORT ze_result_t ZE_APICALL
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) {
zeCommandListAppendLaunchCooperativeKernelTracing(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,
@@ -612,7 +612,7 @@ zeCommandListAppendLaunchCooperativeKernel_Tracing(ze_command_list_handle_t hCom
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListAppendLaunchCooperativeKernelCb_t,
CommandList, pfnAppendLaunchCooperativeKernelCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchCooperativeKernel,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchCooperativeKernel,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -626,9 +626,9 @@ zeCommandListAppendLaunchCooperativeKernel_Tracing(ze_command_list_handle_t hCom
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames) {
zeModuleGetKernelNamesTracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames,
hModule,
@@ -644,7 +644,7 @@ zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnModuleGetKernelNamesCb_t, Module, pfnGetKernelNamesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -655,8 +655,8 @@ zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount) {
zeKernelSuggestMaxCooperativeGroupCountTracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount,
hKernel,
@@ -671,7 +671,7 @@ zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSuggestMaxCooperativeGroupCountCb_t,
Kernel, pfnSuggestMaxCooperativeGroupCountCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -681,8 +681,8 @@ zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t *pFlags) {
zeKernelGetIndirectAccessTracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t *pFlags) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetIndirectAccess,
hKernel,
@@ -697,7 +697,7 @@ zeKernelGetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetIndirectAccessCb_t,
Kernel, pfnGetIndirectAccessCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetIndirectAccess,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetIndirectAccess,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -707,9 +707,9 @@ zeKernelGetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetName_Tracing(ze_kernel_handle_t hKernel,
size_t *pSize,
char *pName) {
zeKernelGetNameTracing(ze_kernel_handle_t hKernel,
size_t *pSize,
char *pName) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetName,
hKernel,
@@ -726,7 +726,7 @@ zeKernelGetName_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetNameCb_t,
Kernel, pfnGetNameCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetName,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetName,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -737,9 +737,9 @@ zeKernelGetName_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetSourceAttributes_Tracing(ze_kernel_handle_t hKernel,
uint32_t *pSize,
char **pString) {
zeKernelGetSourceAttributesTracing(ze_kernel_handle_t hKernel,
uint32_t *pSize,
char **pString) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnGetSourceAttributes,
hKernel,
@@ -756,7 +756,7 @@ zeKernelGetSourceAttributes_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelGetSourceAttributesCb_t,
Kernel, pfnGetSourceAttributesCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetSourceAttributes,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnGetSourceAttributes,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -767,8 +767,8 @@ zeKernelGetSourceAttributes_Tracing(ze_kernel_handle_t hKernel,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t flags) {
zeKernelSetIndirectAccessTracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t flags) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Kernel.pfnSetIndirectAccess,
hKernel,
@@ -783,7 +783,7 @@ zeKernelSetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnKernelSetIndirectAccessCb_t,
Kernel, pfnSetIndirectAccessCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetIndirectAccess,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Kernel.pfnSetIndirectAccess,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

182
level_zero/experimental/source/tracing/tracing_module_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,139 +10,139 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog);
zeModuleCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleDestroy_Tracing(ze_module_handle_t hModule);
zeModuleDestroyTracing(ze_module_handle_t hModule);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleBuildLogDestroy_Tracing(ze_module_build_log_handle_t hModuleBuildLog);
zeModuleBuildLogDestroyTracing(ze_module_build_log_handle_t hModuleBuildLog);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleBuildLogGetString_Tracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
char *pBuildLog);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetNativeBinary_Tracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetGlobalPointer_Tracing(ze_module_handle_t hModule,
const char *pGlobalName,
zeModuleBuildLogGetStringTracing(ze_module_build_log_handle_t hModuleBuildLog,
size_t *pSize,
void **pptr);
char *pBuildLog);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleDynamicLink_Tracing(uint32_t numModules,
ze_module_handle_t *phModules,
ze_module_build_log_handle_t *phLinkLog);
zeModuleGetNativeBinaryTracing(ze_module_handle_t hModule,
size_t *pSize,
uint8_t *pModuleNativeBinary);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetProperties_Tracing(ze_module_handle_t hModule,
ze_module_properties_t *pModuleProperties);
zeModuleGetGlobalPointerTracing(ze_module_handle_t hModule,
const char *pGlobalName,
size_t *pSize,
void **pptr);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelCreate_Tracing(ze_module_handle_t hModule,
const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phFunction);
zeModuleDynamicLinkTracing(uint32_t numModules,
ze_module_handle_t *phModules,
ze_module_build_log_handle_t *phLinkLog);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelDestroy_Tracing(ze_kernel_handle_t hKernel);
zeModuleGetPropertiesTracing(ze_module_handle_t hModule,
ze_module_properties_t *pModuleProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetFunctionPointer_Tracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction);
zeKernelCreateTracing(ze_module_handle_t hModule,
const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phFunction);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetGroupSize_Tracing(ze_kernel_handle_t hKernel,
uint32_t groupSizeX,
uint32_t groupSizeY,
uint32_t groupSizeZ);
zeKernelDestroyTracing(ze_kernel_handle_t hKernel);
ZE_APIEXPORT ze_result_t ZE_APICALL
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);
zeModuleGetFunctionPointerTracing(ze_module_handle_t hModule,
const char *pKernelName,
void **pfnFunction);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetArgumentValue_Tracing(ze_kernel_handle_t hKernel,
uint32_t argIndex,
size_t argSize,
const void *pArgValue);
zeKernelSetGroupSizeTracing(ze_kernel_handle_t hKernel,
uint32_t groupSizeX,
uint32_t groupSizeY,
uint32_t groupSizeZ);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetProperties_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties);
zeKernelSuggestGroupSizeTracing(ze_kernel_handle_t hKernel,
uint32_t globalSizeX,
uint32_t globalSizeY,
uint32_t globalSizeZ,
uint32_t *groupSizeX,
uint32_t *groupSizeY,
uint32_t *groupSizeZ);
ZE_APIEXPORT ze_result_t ZE_APICALL
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);
zeKernelSetArgumentValueTracing(ze_kernel_handle_t hKernel,
uint32_t argIndex,
size_t argSize,
const void *pArgValue);
ZE_APIEXPORT ze_result_t ZE_APICALL
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);
zeKernelGetPropertiesTracing(ze_kernel_handle_t hKernel,
ze_kernel_properties_t *pKernelProperties);
ZE_APIEXPORT ze_result_t ZE_APICALL
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);
zeCommandListAppendLaunchKernelTracing(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_APIEXPORT ze_result_t ZE_APICALL
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);
zeCommandListAppendLaunchKernelIndirectTracing(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_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetKernelNames_Tracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames);
zeCommandListAppendLaunchMultipleKernelsIndirectTracing(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_APIEXPORT ze_result_t ZE_APICALL
zeKernelSuggestMaxCooperativeGroupCount_Tracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount);
zeCommandListAppendLaunchCooperativeKernelTracing(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_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t *pFlags);
zeModuleGetKernelNamesTracing(ze_module_handle_t hModule,
uint32_t *pCount,
const char **pNames);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetName_Tracing(ze_kernel_handle_t hKernel,
size_t *pSize,
char *pName);
zeKernelSuggestMaxCooperativeGroupCountTracing(ze_kernel_handle_t hKernel,
uint32_t *totalGroupCount);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetSourceAttributes_Tracing(ze_kernel_handle_t hKernel,
uint32_t *pSize,
char **pString);
zeKernelGetIndirectAccessTracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t *pFlags);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetIndirectAccess_Tracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t flags);
zeKernelGetNameTracing(ze_kernel_handle_t hKernel,
size_t *pSize,
char *pName);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetSourceAttributesTracing(ze_kernel_handle_t hKernel,
uint32_t *pSize,
char **pString);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetIndirectAccessTracing(ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t flags);
}

58
level_zero/experimental/source/tracing/tracing_residency_imp.cpp
View File

@@ -8,9 +8,9 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextCreate_Tracing(ze_driver_handle_t hDriver,
const ze_context_desc_t *desc,
ze_context_handle_t *phContext) {
zeContextCreateTracing(ze_driver_handle_t hDriver,
const ze_context_desc_t *desc,
ze_context_handle_t *phContext) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnCreate,
hDriver,
@@ -26,7 +26,7 @@ zeContextCreate_Tracing(ze_driver_handle_t hDriver,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextCreateCb_t, Context, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -37,7 +37,7 @@ zeContextCreate_Tracing(ze_driver_handle_t hDriver,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextDestroy_Tracing(ze_context_handle_t hContext) {
zeContextDestroyTracing(ze_context_handle_t hContext) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnDestroy,
hContext);
@@ -49,7 +49,7 @@ zeContextDestroy_Tracing(ze_context_handle_t hContext) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextDestroyCb_t, Context, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -58,7 +58,7 @@ zeContextDestroy_Tracing(ze_context_handle_t hContext) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextGetStatus_Tracing(ze_context_handle_t hContext) {
zeContextGetStatusTracing(ze_context_handle_t hContext) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnGetStatus,
hContext);
@@ -70,7 +70,7 @@ zeContextGetStatus_Tracing(ze_context_handle_t hContext) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextGetStatusCb_t, Context, pfnGetStatusCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnGetStatus,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnGetStatus,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -79,8 +79,8 @@ zeContextGetStatus_Tracing(ze_context_handle_t hContext) {
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextSystemBarrier_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice) {
zeContextSystemBarrierTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnSystemBarrier,
hContext,
@@ -94,7 +94,7 @@ zeContextSystemBarrier_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextSystemBarrierCb_t, Context, pfnSystemBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnSystemBarrier,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnSystemBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -104,10 +104,10 @@ zeContextSystemBarrier_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextMakeMemoryResident_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size) {
zeContextMakeMemoryResidentTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident,
hContext,
@@ -125,7 +125,7 @@ zeContextMakeMemoryResident_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextMakeMemoryResidentCb_t, Context, pfnMakeMemoryResidentCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -137,10 +137,10 @@ zeContextMakeMemoryResident_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextEvictMemory_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size) {
zeContextEvictMemoryTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnEvictMemory,
hContext,
@@ -158,7 +158,7 @@ zeContextEvictMemory_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextEvictMemoryCb_t, Context, pfnEvictMemoryCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnEvictMemory,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnEvictMemory,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -170,9 +170,9 @@ zeContextEvictMemory_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextMakeImageResident_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
zeContextMakeImageResidentTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident,
hContext,
@@ -188,7 +188,7 @@ zeContextMakeImageResident_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextMakeImageResidentCb_t, Context, pfnMakeImageResidentCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -199,9 +199,9 @@ zeContextMakeImageResident_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextEvictImage_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
zeContextEvictImageTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Context.pfnEvictImage,
hContext,
@@ -217,7 +217,7 @@ zeContextEvictImage_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnContextEvictImageCb_t, Context, pfnEvictImageCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnEvictImage,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Context.pfnEvictImage,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

48
level_zero/experimental/source/tracing/tracing_residency_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,40 +10,40 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextCreate_Tracing(ze_driver_handle_t hDriver,
const ze_context_desc_t *desc,
ze_context_handle_t *phContext);
zeContextCreateTracing(ze_driver_handle_t hDriver,
const ze_context_desc_t *desc,
ze_context_handle_t *phContext);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextDestroy_Tracing(ze_context_handle_t hContext);
zeContextDestroyTracing(ze_context_handle_t hContext);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextGetStatus_Tracing(ze_context_handle_t hContext);
zeContextGetStatusTracing(ze_context_handle_t hContext);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextSystemBarrier_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice);
zeContextSystemBarrierTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextMakeMemoryResident_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextEvictMemory_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextMakeImageResident_Tracing(ze_context_handle_t hContext,
zeContextMakeMemoryResidentTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage);
void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextEvictImage_Tracing(ze_context_handle_t hContext,
zeContextEvictMemoryTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage);
void *ptr,
size_t size);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextMakeImageResidentTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextEvictImageTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
ze_image_handle_t hImage);
} // extern "C"

16
level_zero/experimental/source/tracing/tracing_sampler_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,10 +8,10 @@
#include "level_zero/experimental/source/tracing/tracing_imp.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) {
zeSamplerCreateTracing(ze_context_handle_t hContext,
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,
hContext,
@@ -29,7 +29,7 @@ zeSamplerCreate_Tracing(ze_context_handle_t hContext,
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnSamplerCreateCb_t, Sampler, pfnCreateCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnCreate,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnCreate,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
@@ -41,7 +41,7 @@ zeSamplerCreate_Tracing(ze_context_handle_t hContext,
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerDestroy_Tracing(ze_sampler_handle_t hSampler) {
zeSamplerDestroyTracing(ze_sampler_handle_t hSampler) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Sampler.pfnDestroy,
hSampler);
@@ -53,7 +53,7 @@ zeSamplerDestroy_Tracing(ze_sampler_handle_t hSampler) {
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnSamplerDestroyCb_t, Sampler, pfnDestroyCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnDestroy,
return L0::apiTracerWrapperImp(driver_ddiTable.core_ddiTable.Sampler.pfnDestroy,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,

12
level_zero/experimental/source/tracing/tracing_sampler_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,11 +10,11 @@
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreate_Tracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
ze_sampler_handle_t *phSampler);
zeSamplerCreateTracing(ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
ze_sampler_handle_t *phSampler);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerDestroy_Tracing(ze_sampler_handle_t hSampler);
zeSamplerDestroyTracing(ze_sampler_handle_t hSampler);
}

2
level_zero/experimental/test/unit_tests/sources/test_cmdlist.cpp
View File

@@ -27,7 +27,7 @@ class CommandListMemoryExtensionFixture : public DeviceFixture {
void SetUp() {
DeviceFixture::SetUp();
ze_result_t returnValue;
commandList.reset(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
commandList.reset(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;

4
level_zero/experimental/test/unit_tests/sources/tracing/test_barrier_api_tracing.cpp
View File

@@ -23,7 +23,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendBarrierTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendBarrier_Tracing(nullptr, hSignalEvent, numWaitEvents, nullptr);
result = zeCommandListAppendBarrierTracing(nullptr, hSignalEvent, numWaitEvents, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -44,7 +44,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryRangesBarrier
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryRangesBarrier_Tracing(nullptr, numRanges, pRangeSizes, pRanges, nullptr, 0, nullptr);
result = zeCommandListAppendMemoryRangesBarrierTracing(nullptr, numRanges, pRangeSizes, pRanges, nullptr, 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);

16
level_zero/experimental/test/unit_tests/sources/tracing/test_cmdlist_api_tracing.cpp
View File

@@ -25,7 +25,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCreateTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zeCommandListCreate_Tracing(nullptr, nullptr, &desc, &commandList);
result = zeCommandListCreateTracing(nullptr, nullptr, &desc, &commandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -45,7 +45,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCreateImmediateTracingWra
setTracerCallbacksAndEnableTracer();
result = zeCommandListCreateImmediate_Tracing(nullptr, nullptr, &desc, &commandList);
result = zeCommandListCreateImmediateTracing(nullptr, nullptr, &desc, &commandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -59,7 +59,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListDestroyTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeCommandListDestroy_Tracing(nullptr);
result = zeCommandListDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -73,7 +73,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListResetTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeCommandListReset_Tracing(nullptr);
result = zeCommandListResetTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -87,7 +87,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryPrefetchTraci
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryPrefetch_Tracing(nullptr, nullptr, 0);
result = zeCommandListAppendMemoryPrefetchTracing(nullptr, nullptr, 0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -101,7 +101,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCloseTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeCommandListClose_Tracing(nullptr);
result = zeCommandListCloseTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -124,7 +124,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendQueryKernelTimestam
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendQueryKernelTimestamps_Tracing(nullptr, 1U, nullptr, nullptr, nullptr, nullptr, 1U, nullptr);
result = zeCommandListAppendQueryKernelTimestampsTracing(nullptr, 1U, nullptr, nullptr, nullptr, nullptr, 1U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -143,7 +143,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendWriteGlobalTimestam
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendWriteGlobalTimestamp_Tracing(nullptr, nullptr, nullptr, 1U, nullptr);
result = zeCommandListAppendWriteGlobalTimestampTracing(nullptr, nullptr, nullptr, 1U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

8
level_zero/experimental/test/unit_tests/sources/tracing/test_cmdqueue_api_tracing.cpp
View File

@@ -25,7 +25,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueCreateTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeCommandQueueCreate_Tracing(nullptr, nullptr, &desc, &commandQueue);
result = zeCommandQueueCreateTracing(nullptr, nullptr, &desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -39,7 +39,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueDestroyTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeCommandQueueDestroy_Tracing(nullptr);
result = zeCommandQueueDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -60,7 +60,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueExecuteCommandListsTraci
setTracerCallbacksAndEnableTracer();
result = zeCommandQueueExecuteCommandLists_Tracing(nullptr, numCommandList, &phCommandLists, hFence);
result = zeCommandQueueExecuteCommandListsTracing(nullptr, numCommandList, &phCommandLists, hFence);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -76,7 +76,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueSynchronizeTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeCommandQueueSynchronize_Tracing(nullptr, timeout);
result = zeCommandQueueSynchronizeTracing(nullptr, timeout);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

36
level_zero/experimental/test/unit_tests/sources/tracing/test_copy_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -31,7 +31,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyTracingWr
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryCopy_Tracing(nullptr, dst, static_cast<const void *>(src), bufferSize, nullptr, 0U, nullptr);
result = zeCommandListAppendMemoryCopyTracing(nullptr, dst, static_cast<const void *>(src), bufferSize, nullptr, 0U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -60,7 +60,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryFillTracingWr
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryFill_Tracing(nullptr, dst, &pattern, sizeof(pattern), bufferSize, nullptr, 0, nullptr);
result = zeCommandListAppendMemoryFillTracing(nullptr, dst, &pattern, sizeof(pattern), bufferSize, nullptr, 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -98,15 +98,15 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyRegionTra
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryCopyRegion_Tracing(nullptr, dst,
&dstRegion, dstPitch,
dstSlicePitch,
static_cast<const void *>(src),
&srcRegion, srcPitch,
srcSlicePitch,
nullptr,
0,
nullptr);
result = zeCommandListAppendMemoryCopyRegionTracing(nullptr, dst,
&dstRegion, dstPitch,
dstSlicePitch,
static_cast<const void *>(src),
&srcRegion, srcPitch,
srcSlicePitch,
nullptr,
0,
nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -132,7 +132,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyTracingWra
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendImageCopy_Tracing(nullptr, hDstImage, hSrcImage, nullptr, 0U, nullptr);
result = zeCommandListAppendImageCopyTracing(nullptr, hDstImage, hSrcImage, nullptr, 0U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -160,7 +160,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyRegionTrac
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendImageCopyRegion_Tracing(nullptr, hDstImage, hSrcImage, nullptr, nullptr, nullptr, 0U, nullptr);
result = zeCommandListAppendImageCopyRegionTracing(nullptr, hDstImage, hSrcImage, nullptr, nullptr, nullptr, 0U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -187,7 +187,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyToMemoryTr
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendImageCopyToMemory_Tracing(nullptr, dstptr, hSrcImage, nullptr, nullptr, 0U, nullptr);
result = zeCommandListAppendImageCopyToMemoryTracing(nullptr, dstptr, hSrcImage, nullptr, nullptr, 0U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -214,7 +214,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyFromMemory
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendImageCopyFromMemory_Tracing(nullptr, hDstImage, srcptr, nullptr, nullptr, 0U, nullptr);
result = zeCommandListAppendImageCopyFromMemoryTracing(nullptr, hDstImage, srcptr, nullptr, nullptr, 0U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -240,7 +240,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemAdviseTracingWra
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemAdvise_Tracing(nullptr, nullptr, ptr, bufferSize, advice);
result = zeCommandListAppendMemAdviseTracing(nullptr, nullptr, ptr, bufferSize, advice);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -264,7 +264,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyFromConte
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendMemoryCopyFromContext_Tracing(nullptr, nullptr, nullptr, nullptr, 0U, nullptr, 1u, nullptr);
result = zeCommandListAppendMemoryCopyFromContextTracing(nullptr, nullptr, nullptr, nullptr, 0U, nullptr, 1u, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

56
level_zero/experimental/test/unit_tests/sources/tracing/test_core_api_tracing.cpp
View File

@@ -10,7 +10,7 @@
namespace L0 {
namespace ult {
void OnEnterCommandListAppendLaunchFunction(
void onEnterCommandListAppendLaunchFunction(
ze_command_list_append_launch_kernel_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -18,7 +18,7 @@ void OnEnterCommandListAppendLaunchFunction(
int a = 0;
a++;
}
void OnExitCommandListAppendLaunchFunction(
void onExitCommandListAppendLaunchFunction(
ze_command_list_append_launch_kernel_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -27,7 +27,7 @@ void OnExitCommandListAppendLaunchFunction(
a++;
}
void OnEnterCommandListCreateWithUserData(
void onEnterCommandListCreateWithUserData(
ze_command_list_create_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -36,7 +36,7 @@ void OnEnterCommandListCreateWithUserData(
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(5, *val);
}
void OnExitCommandListCreateWithUserData(
void onExitCommandListCreateWithUserData(
ze_command_list_create_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -46,7 +46,7 @@ void OnExitCommandListCreateWithUserData(
EXPECT_EQ(5, *val);
}
void OnEnterCommandListCloseWithUserData(
void onEnterCommandListCloseWithUserData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -55,7 +55,7 @@ void OnEnterCommandListCloseWithUserData(
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(5, *val);
}
void OnExitCommandListCloseWithUserData(
void onExitCommandListCloseWithUserData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -65,7 +65,7 @@ void OnExitCommandListCloseWithUserData(
EXPECT_EQ(5, *val);
}
void OnEnterCommandListCloseWithUserDataRecursion(
void onEnterCommandListCloseWithUserDataRecursion(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -75,7 +75,7 @@ void OnEnterCommandListCloseWithUserDataRecursion(
EXPECT_EQ(5, *val);
*val += 5;
}
void OnExitCommandListCloseWithUserDataRecursion(
void onExitCommandListCloseWithUserDataRecursion(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -86,7 +86,7 @@ void OnExitCommandListCloseWithUserDataRecursion(
*val += 5;
}
void OnEnterCommandListCloseWithUserDataAndAllocateInstanceData(
void onEnterCommandListCloseWithUserDataAndAllocateInstanceData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -98,7 +98,7 @@ void OnEnterCommandListCloseWithUserDataAndAllocateInstanceData(
ppTracerInstanceUserData[0] = instanceData;
*instanceData = 0x1234;
}
void OnExitCommandListCloseWithUserDataAndReadInstanceData(
void onExitCommandListCloseWithUserDataAndReadInstanceData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -117,7 +117,7 @@ void OnExitCommandListCloseWithUserDataAndReadInstanceData(
delete instanceData;
}
void OnEnterCommandListCloseWithoutUserDataAndAllocateInstanceData(
void onEnterCommandListCloseWithoutUserDataAndAllocateInstanceData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -127,7 +127,7 @@ void OnEnterCommandListCloseWithoutUserDataAndAllocateInstanceData(
ppTracerInstanceUserData[0] = instanceData;
*instanceData = 0x1234;
}
void OnExitCommandListCloseWithoutUserDataAndReadInstanceData(
void onExitCommandListCloseWithoutUserDataAndReadInstanceData(
ze_command_list_close_params_t *params,
ze_result_t result,
void *pTracerUserData,
@@ -168,8 +168,8 @@ TEST_F(zeAPITracingCoreTests, WhenCreateTracerAndsetCallbacksAndEnableTracingAnd
zet_core_callbacks_t prologCbs = {};
zet_core_callbacks_t epilogCbs = {};
prologCbs.CommandList.pfnAppendLaunchKernelCb = OnEnterCommandListAppendLaunchFunction;
epilogCbs.CommandList.pfnAppendLaunchKernelCb = OnExitCommandListAppendLaunchFunction;
prologCbs.CommandList.pfnAppendLaunchKernelCb = onEnterCommandListAppendLaunchFunction;
epilogCbs.CommandList.pfnAppendLaunchKernelCb = onExitCommandListAppendLaunchFunction;
result = zetTracerExpSetPrologues(apiTracerHandle, &prologCbs);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -194,7 +194,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOnePrologAndNoEpilogWi
ze_command_list_close_params_t tracerParams;
zet_core_callbacks_t prologCbs = {};
prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserData;
prologCbs.CommandList.pfnCloseCb = onEnterCommandListCloseWithUserData;
ze_command_list_handle_t commandListHandle = commandList.toHandle();
tracerParams.phCommandList = &commandListHandle;
@@ -207,7 +207,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOnePrologAndNoEpilogWi
prologCallbacks.push_back(prologCallback);
ze_pfnCommandListCloseCb_t apiOrdinal = {};
result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
result = apiTracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -219,8 +219,8 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
zet_core_callbacks_t prologCbs = {};
zet_core_callbacks_t epilogCbs = {};
prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserData;
epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserData;
prologCbs.CommandList.pfnCloseCb = onEnterCommandListCloseWithUserData;
epilogCbs.CommandList.pfnCloseCb = onExitCommandListCloseWithUserData;
ze_command_list_handle_t commandListHandle = commandList.toHandle();
tracerParams.phCommandList = &commandListHandle;
@@ -237,7 +237,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
epilogCallbacks.push_back(epilogCallback);
ze_pfnCommandListCloseCb_t apiOrdinal = {};
result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
result = apiTracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -249,8 +249,8 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
zet_core_callbacks_t prologCbs = {};
zet_core_callbacks_t epilogCbs = {};
prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserDataAndAllocateInstanceData;
epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserDataAndReadInstanceData;
prologCbs.CommandList.pfnCloseCb = onEnterCommandListCloseWithUserDataAndAllocateInstanceData;
epilogCbs.CommandList.pfnCloseCb = onExitCommandListCloseWithUserDataAndReadInstanceData;
ze_command_list_handle_t commandListHandle = commandList.toHandle();
tracerParams.phCommandList = &commandListHandle;
@@ -267,7 +267,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
epilogCallbacks.push_back(epilogCallback);
ze_pfnCommandListCloseCb_t apiOrdinal = {};
result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
result = apiTracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -278,8 +278,8 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
zet_core_callbacks_t prologCbs = {};
zet_core_callbacks_t epilogCbs = {};
prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithoutUserDataAndAllocateInstanceData;
epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithoutUserDataAndReadInstanceData;
prologCbs.CommandList.pfnCloseCb = onEnterCommandListCloseWithoutUserDataAndAllocateInstanceData;
epilogCbs.CommandList.pfnCloseCb = onExitCommandListCloseWithoutUserDataAndReadInstanceData;
ze_command_list_handle_t commandListHandle = commandList.toHandle();
tracerParams.phCommandList = &commandListHandle;
@@ -296,7 +296,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
epilogCallbacks.push_back(epilogCallback);
ze_pfnCommandListCloseCb_t apiOrdinal = {};
result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
result = apiTracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -308,8 +308,8 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
zet_core_callbacks_t prologCbs = {};
zet_core_callbacks_t epilogCbs = {};
prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserDataRecursion;
epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserDataRecursion;
prologCbs.CommandList.pfnCloseCb = onEnterCommandListCloseWithUserDataRecursion;
epilogCbs.CommandList.pfnCloseCb = onExitCommandListCloseWithUserDataRecursion;
ze_command_list_handle_t commandListHandle = commandList.toHandle();
tracerParams.phCommandList = &commandListHandle;
@@ -329,7 +329,7 @@ TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsW
result = callHandleTracerRecursion(zeCommandListClose, commandListHandle);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
result = apiTracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = callHandleTracerRecursion(zeCommandListClose, commandListHandle);

32
level_zero/experimental/test/unit_tests/sources/tracing/test_device_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -20,7 +20,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetTracingWrapperWithOneSetOfP
setTracerCallbacksAndEnableTracer();
result = zeDeviceGet_Tracing(nullptr, nullptr, nullptr);
result = zeDeviceGetTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -35,7 +35,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetPropertiesTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -50,7 +50,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetComputePropertiesTracingWra
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetComputeProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetComputePropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -65,7 +65,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetMemoryPropertiesTracingWrap
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetMemoryProperties_Tracing(nullptr, nullptr, nullptr);
result = zeDeviceGetMemoryPropertiesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -82,7 +82,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetCachePropertiesTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetCacheProperties_Tracing(nullptr, nullptr, nullptr);
result = zeDeviceGetCachePropertiesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -98,7 +98,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetImagePropertiesTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetImageProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetImagePropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -117,7 +117,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetSubDevicesTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetSubDevices_Tracing(nullptr, &pcount, nullptr);
result = zeDeviceGetSubDevicesTracing(nullptr, &pcount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -136,7 +136,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetP2PPropertiesTracingWrapper
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetP2PProperties_Tracing(nullptr, nullptr, &pP2PProperties);
result = zeDeviceGetP2PPropertiesTracing(nullptr, nullptr, &pP2PProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -155,7 +155,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceCanAccessPeerTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeDeviceCanAccessPeer_Tracing(nullptr, nullptr, &value);
result = zeDeviceCanAccessPeerTracing(nullptr, nullptr, &value);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -173,7 +173,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetCacheConfigTracingWrapperWi
setTracerCallbacksAndEnableTracer();
result = zeKernelSetCacheConfig_Tracing(nullptr, flags);
result = zeKernelSetCacheConfigTracing(nullptr, flags);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -189,7 +189,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetModulePropertiesTracingWrap
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetModuleProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetModulePropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -205,7 +205,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetMemoryAccessPropertiesTraci
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetMemoryAccessProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetMemoryAccessPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -220,7 +220,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetCommandQueueGroupProperties
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetCommandQueueGroupProperties_Tracing(nullptr, nullptr, nullptr);
result = zeDeviceGetCommandQueueGroupPropertiesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -235,7 +235,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetExternalMemoryPropertiesTra
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetExternalMemoryProperties_Tracing(nullptr, nullptr);
result = zeDeviceGetExternalMemoryPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -250,7 +250,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetStatusTracingWrapperWithOne
setTracerCallbacksAndEnableTracer();
result = zeDeviceGetStatus_Tracing(nullptr);
result = zeDeviceGetStatusTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

12
level_zero/experimental/test/unit_tests/sources/tracing/test_driver_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -20,7 +20,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetTracingWrapperWithOneSetO
setTracerCallbacksAndEnableTracer();
result = zeDriverGet_Tracing(nullptr, nullptr);
result = zeDriverGetTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -35,7 +35,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetPropertiesTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeDriverGetProperties_Tracing(nullptr, nullptr);
result = zeDriverGetPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -49,7 +49,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetApiVersionTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeDriverGetApiVersion_Tracing(nullptr, nullptr);
result = zeDriverGetApiVersionTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -65,7 +65,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetIpcPropertiesTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeDriverGetIpcProperties_Tracing(nullptr, nullptr);
result = zeDriverGetIpcPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -82,7 +82,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetExtensionPropertiesTracin
setTracerCallbacksAndEnableTracer();
result = zeDriverGetExtensionProperties_Tracing(nullptr, nullptr, nullptr);
result = zeDriverGetExtensionPropertiesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

90
level_zero/experimental/test/unit_tests/sources/tracing/test_event_api_multi_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -246,7 +246,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
setTracerCallbacksAndEnableTracer();
result = zeEventCreate_Tracing(event_create_args.hEventPool0, &event_create_args.desc0, &event_create_args.hEvent0);
result = zeEventCreateTracing(event_create_args.hEventPool0, &event_create_args.desc0, &event_create_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -375,7 +375,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventDestroyTracing
setTracerCallbacksAndEnableTracer();
result = zeEventDestroy_Tracing(event_destroy_args.hEvent0);
result = zeEventDestroyTracing(event_destroy_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -504,7 +504,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSignalTrac
setTracerCallbacksAndEnableTracer();
result = zeEventHostSignal_Tracing(event_host_signal_args.hEvent0);
result = zeEventHostSignalTracing(event_host_signal_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -645,7 +645,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
setTracerCallbacksAndEnableTracer();
result = zeEventHostSynchronize_Tracing(event_host_synchronize_args.hEvent0, event_host_synchronize_args.timeout0);
result = zeEventHostSynchronizeTracing(event_host_synchronize_args.hEvent0, event_host_synchronize_args.timeout0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -774,7 +774,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventQueryStatusTra
setTracerCallbacksAndEnableTracer();
result = zeEventQueryStatus_Tracing(event_query_status_args.hEvent0);
result = zeEventQueryStatusTracing(event_query_status_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -903,7 +903,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventHostResetTraci
setTracerCallbacksAndEnableTracer();
result = zeEventHostReset_Tracing(event_reset_args.hEvent0);
result = zeEventHostResetTracing(event_reset_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -1200,11 +1200,11 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
setTracerCallbacksAndEnableTracer();
result = zeEventPoolCreate_Tracing(event_pool_create_args.hContext0,
&event_pool_create_args.desc0,
event_pool_create_args.numDevices0,
event_pool_create_args.hDevices0,
&event_pool_create_args.hEventPool0);
result = zeEventPoolCreateTracing(event_pool_create_args.hContext0,
&event_pool_create_args.desc0,
event_pool_create_args.numDevices0,
event_pool_create_args.hDevices0,
&event_pool_create_args.hEventPool0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -1333,7 +1333,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolDestroyTra
setTracerCallbacksAndEnableTracer();
result = zeEventPoolDestroy_Tracing(event_pool_destroy_args.hEventPool0);
result = zeEventPoolDestroyTracing(event_pool_destroy_args.hEventPool0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -1348,14 +1348,14 @@ struct {
void *instanceData3;
} event_pool_get_ipc_handle_args;
static void event_pool_get_ipc_handle_init_random(ze_ipc_event_pool_handle_t *phIpc) {
static void eventPoolGetIpcHandleInitRandom(ze_ipc_event_pool_handle_t *phIpc) {
uint8_t *ptr = (uint8_t *)phIpc;
for (size_t i = 0; i < sizeof(*phIpc); i++, ptr++) {
*ptr = generateRandomSize<uint8_t>();
}
}
static bool event_pool_get_ipc_handles_compare(ze_ipc_event_pool_handle_t *phIpc0, ze_ipc_event_pool_handle_t *phIpc1) {
static bool eventPoolGetIpcHandlesCompare(ze_ipc_event_pool_handle_t *phIpc0, ze_ipc_event_pool_handle_t *phIpc1) {
if (nullptr == phIpc0) {
return false;
}
@@ -1370,11 +1370,11 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
// initialize initial argument set
event_pool_get_ipc_handle_args.hEventPool0 = generateRandomHandle<ze_event_pool_handle_t>();
event_pool_get_ipc_handle_init_random(&event_pool_get_ipc_handle_args.hIpc0);
eventPoolGetIpcHandleInitRandom(&event_pool_get_ipc_handle_args.hIpc0);
// initialize replacement argument set
event_pool_get_ipc_handle_args.hEventPool1 = generateRandomHandle<ze_event_pool_handle_t>();
event_pool_get_ipc_handle_init_random(&event_pool_get_ipc_handle_args.hIpc1);
eventPoolGetIpcHandleInitRandom(&event_pool_get_ipc_handle_args.hIpc1);
// initialize user instance data
event_pool_get_ipc_handle_args.instanceData0 = generateRandomHandle<void *>();
@@ -1384,8 +1384,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
[](ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t *phIpc) {
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, hEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, phIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, phIpc));
event_pool_get_ipc_handle_init_random(&event_pool_get_ipc_handle_args.hIpcAPI);
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, phIpc));
eventPoolGetIpcHandleInitRandom(&event_pool_get_ipc_handle_args.hIpcAPI);
*phIpc = event_pool_get_ipc_handle_args.hIpcAPI;
return ZE_RESULT_SUCCESS;
};
@@ -1398,7 +1398,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
[](ze_event_pool_get_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool0, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc0, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc0, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc0, *params->pphIpc));
*params->phEventPool = event_pool_get_ipc_handle_args.hEventPool1;
*params->pphIpc = &event_pool_get_ipc_handle_args.hIpc1;
ASSERT_NE(nullptr, pTracerUserData);
@@ -1420,7 +1420,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
@@ -1438,7 +1438,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
[](ze_event_pool_get_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -1454,7 +1454,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -1469,7 +1469,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
[](ze_event_pool_get_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
@@ -1489,7 +1489,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
EXPECT_TRUE(event_pool_get_ipc_handles_compare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
EXPECT_TRUE(eventPoolGetIpcHandlesCompare(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
@@ -1501,7 +1501,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
setTracerCallbacksAndEnableTracer();
result = zeEventPoolGetIpcHandle_Tracing(event_pool_get_ipc_handle_args.hEventPool0, &event_pool_get_ipc_handle_args.hIpc0);
result = zeEventPoolGetIpcHandleTracing(event_pool_get_ipc_handle_args.hEventPool0, &event_pool_get_ipc_handle_args.hIpc0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -1518,14 +1518,14 @@ struct {
void *instanceData3;
} event_pool_open_ipc_handle_args;
static void event_pool_open_ipc_handle_init_random(ze_ipc_event_pool_handle_t *phIpc) {
static void eventPoolOpenIpcHandleInitRandom(ze_ipc_event_pool_handle_t *phIpc) {
uint8_t *ptr = (uint8_t *)phIpc;
for (size_t i = 0; i < sizeof(*phIpc); i++, ptr++) {
*ptr = generateRandomSize<uint8_t>();
}
}
static bool event_pool_open_ipc_handles_compare(ze_ipc_event_pool_handle_t *phIpc0, ze_ipc_event_pool_handle_t *phIpc1) {
static bool eventPoolOpenIpcHandlesCompare(ze_ipc_event_pool_handle_t *phIpc0, ze_ipc_event_pool_handle_t *phIpc1) {
return (memcmp((void *)phIpc0, (void *)phIpc1, sizeof(ze_ipc_event_pool_handle_t)) == 0);
}
@@ -1534,12 +1534,12 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
// initialize initial argument set
event_pool_open_ipc_handle_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
event_pool_open_ipc_handle_init_random(&event_pool_open_ipc_handle_args.hIpc0);
eventPoolOpenIpcHandleInitRandom(&event_pool_open_ipc_handle_args.hIpc0);
event_pool_open_ipc_handle_args.hEventPool0 = generateRandomHandle<ze_event_pool_handle_t>();
// initialize replacement argument set
event_pool_open_ipc_handle_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
event_pool_open_ipc_handle_init_random(&event_pool_open_ipc_handle_args.hIpc1);
eventPoolOpenIpcHandleInitRandom(&event_pool_open_ipc_handle_args.hIpc1);
event_pool_open_ipc_handle_args.hEventPool1 = generateRandomHandle<ze_event_pool_handle_t>();
// initialize user instance data
@@ -1549,7 +1549,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle =
[](ze_context_handle_t hContext, ze_ipc_event_pool_handle_t hIpc, ze_event_pool_handle_t *phEventPool) {
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, hContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, &hIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, &hIpc));
EXPECT_EQ(event_pool_open_ipc_handle_args.hEventPool1, *phEventPool);
EXPECT_EQ(&event_pool_open_ipc_handle_args.hEventPool1, phEventPool);
event_pool_open_ipc_handle_args.hEventPoolAPI = generateRandomHandle<ze_event_pool_handle_t>();
@@ -1564,7 +1564,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
prologCbs0.EventPool.pfnOpenIpcHandleCb =
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext0, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc0, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc0, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1602,7 +1602,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
struct instanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1634,7 +1634,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
prologCbs1.EventPool.pfnOpenIpcHandleCb =
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1664,7 +1664,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1693,7 +1693,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
prologCbs3.EventPool.pfnOpenIpcHandleCb =
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1727,7 +1727,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
struct instanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(event_pool_open_ipc_handles_compare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
ze_event_pool_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -1754,9 +1754,9 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
setTracerCallbacksAndEnableTracer();
result = zeEventPoolOpenIpcHandle_Tracing(event_pool_open_ipc_handle_args.hContext0,
event_pool_open_ipc_handle_args.hIpc0,
&event_pool_open_ipc_handle_args.hEventPool0);
result = zeEventPoolOpenIpcHandleTracing(event_pool_open_ipc_handle_args.hContext0,
event_pool_open_ipc_handle_args.hIpc0,
&event_pool_open_ipc_handle_args.hEventPool0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -1885,7 +1885,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCloseIpcHa
setTracerCallbacksAndEnableTracer();
result = zeEventPoolCloseIpcHandle_Tracing(event_pool_close_ipc_handle_args.hEventPool0);
result = zeEventPoolCloseIpcHandleTracing(event_pool_close_ipc_handle_args.hEventPool0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -2022,7 +2022,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendSi
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendSignalEvent_Tracing(command_list_append_signal_event_args.hCommandList0, command_list_append_signal_event_args.hEvent0);
result = zeCommandListAppendSignalEventTracing(command_list_append_signal_event_args.hCommandList0, command_list_append_signal_event_args.hEvent0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
@@ -2191,9 +2191,9 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendWaitOnEvents_Tracing(command_list_append_wait_on_events_args.hCommandList0,
NUM_COMMAND_LIST_APPEND_WAIT_ON_EVENTS_0,
command_list_append_wait_on_events_args.hEvents0);
result = zeCommandListAppendWaitOnEventsTracing(command_list_append_wait_on_events_args.hCommandList0,
NUM_COMMAND_LIST_APPEND_WAIT_ON_EVENTS_0,
command_list_append_wait_on_events_args.hEvents0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

32
level_zero/experimental/test/unit_tests/sources/tracing/test_event_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -22,7 +22,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventCreateTracingWrapperWithOneSetO
setTracerCallbacksAndEnableTracer();
result = zeEventCreate_Tracing(nullptr, &desc, &event);
result = zeEventCreateTracing(nullptr, &desc, &event);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -37,7 +37,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventDestroyTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeEventDestroy_Tracing(nullptr);
result = zeEventDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -51,7 +51,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostSignalTracingWrapperWithOne
setTracerCallbacksAndEnableTracer();
result = zeEventHostSignal_Tracing(nullptr);
result = zeEventHostSignalTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -65,7 +65,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostSynchronizeTracingWrapperWi
setTracerCallbacksAndEnableTracer();
result = zeEventHostSynchronize_Tracing(nullptr, 1U);
result = zeEventHostSynchronizeTracing(nullptr, 1U);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -79,7 +79,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventQueryStatusTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeEventQueryStatus_Tracing(nullptr);
result = zeEventQueryStatusTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -93,7 +93,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostResetTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeEventHostReset_Tracing(nullptr);
result = zeEventHostResetTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -111,7 +111,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolCreateTracingWrapperWithOne
setTracerCallbacksAndEnableTracer();
result = zeEventPoolCreate_Tracing(nullptr, nullptr, 1U, nullptr, nullptr);
result = zeEventPoolCreateTracing(nullptr, nullptr, 1U, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -125,7 +125,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolDestroyTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeEventPoolDestroy_Tracing(nullptr);
result = zeEventPoolDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -141,7 +141,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolGetIpcHandleTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeEventPoolGetIpcHandle_Tracing(nullptr, &phIpc);
result = zeEventPoolGetIpcHandleTracing(nullptr, &phIpc);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -160,7 +160,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolOpenIpcHandleTracingWrapper
setTracerCallbacksAndEnableTracer();
result = zeEventPoolOpenIpcHandle_Tracing(nullptr, hIpc, &phEventPool);
result = zeEventPoolOpenIpcHandleTracing(nullptr, hIpc, &phEventPool);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -174,7 +174,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolCloseIpcHandleTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeEventPoolCloseIpcHandle_Tracing(nullptr);
result = zeEventPoolCloseIpcHandleTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -190,7 +190,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendSignalEventTracingW
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendSignalEvent_Tracing(nullptr, nullptr);
result = zeCommandListAppendSignalEventTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -207,7 +207,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendWaitOnEventsTracing
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendWaitOnEvents_Tracing(nullptr, 1, &phEvents);
result = zeCommandListAppendWaitOnEventsTracing(nullptr, 1, &phEvents);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -222,7 +222,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendEventResetTracingWr
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendEventReset_Tracing(nullptr, nullptr);
result = zeCommandListAppendEventResetTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -237,7 +237,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingEventQueryKernelTimestampTracingWrap
setTracerCallbacksAndEnableTracer();
result = zeEventQueryKernelTimestamp_Tracing(nullptr, nullptr);
result = zeEventQueryKernelTimestampTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

20
level_zero/experimental/test/unit_tests/sources/tracing/test_fence_api_tracing.cpp
View File

@@ -22,7 +22,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceCreateTracingWrapperWithOneSetO
setTracerCallbacksAndEnableTracer();
result = zeFenceCreate_Tracing(nullptr, &desc, &fence);
result = zeFenceCreateTracing(nullptr, &desc, &fence);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -37,7 +37,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceDestroyTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeFenceDestroy_Tracing(nullptr);
result = zeFenceDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -51,7 +51,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceHostSynchronizeTracingWrapperWi
setTracerCallbacksAndEnableTracer();
result = zeFenceHostSynchronize_Tracing(nullptr, 1U);
result = zeFenceHostSynchronizeTracing(nullptr, 1U);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -65,7 +65,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceQueryStatusTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeFenceQueryStatus_Tracing(nullptr);
result = zeFenceQueryStatusTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -79,7 +79,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceResetTracingWrapperWithOneSetOf
setTracerCallbacksAndEnableTracer();
result = zeFenceReset_Tracing(nullptr);
result = zeFenceResetTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -319,7 +319,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
setTracerCallbacksAndEnableTracer();
result = zeFenceCreate_Tracing(fence_create_args.hCommandQueue0, &fence_create_args.desc0, &fence_create_args.hFence0);
result = zeFenceCreateTracing(fence_create_args.hCommandQueue0, &fence_create_args.desc0, &fence_create_args.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(fence_create_args.hFence1, fence_create_args.hFenceAPI);
validateDefaultUserDataFinal();
@@ -449,7 +449,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
setTracerCallbacksAndEnableTracer();
result = zeFenceDestroy_Tracing(fence_destroy_args.hFence0);
result = zeFenceDestroyTracing(fence_destroy_args.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -590,7 +590,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
setTracerCallbacksAndEnableTracer();
result = zeFenceHostSynchronize_Tracing(fence_host_synchronize_args.hFence0, fence_host_synchronize_args.timeout0);
result = zeFenceHostSynchronizeTracing(fence_host_synchronize_args.hFence0, fence_host_synchronize_args.timeout0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -719,7 +719,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
setTracerCallbacksAndEnableTracer();
result = zeFenceQueryStatus_Tracing(fence_query_status_args.hFence0);
result = zeFenceQueryStatusTracing(fence_query_status_args.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -848,7 +848,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
setTracerCallbacksAndEnableTracer();
result = zeFenceReset_Tracing(fence_reset_args.hFence0);
result = zeFenceResetTracing(fence_reset_args.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

2
level_zero/experimental/test/unit_tests/sources/tracing/test_global_api_tracing.cpp
View File

@@ -19,7 +19,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingInitTracingWrapperWithOneSetOfProlog
setTracerCallbacksAndEnableTracer();
result = zeInit_Tracing(ZE_INIT_FLAG_GPU_ONLY);
result = zeInitTracing(ZE_INIT_FLAG_GPU_ONLY);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

12
level_zero/experimental/test/unit_tests/sources/tracing/test_image_api_tracing.cpp
View File

@@ -22,7 +22,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingImageGetPropertiesTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeImageGetProperties_Tracing(nullptr, &desc, &pImageProperties);
result = zeImageGetPropertiesTracing(nullptr, &desc, &pImageProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -39,7 +39,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingImageCreateTracingWrapperWithOneSetO
setTracerCallbacksAndEnableTracer();
result = zeImageCreate_Tracing(nullptr, nullptr, &desc, &phImage);
result = zeImageCreateTracing(nullptr, nullptr, &desc, &phImage);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -53,7 +53,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingImageDestroyTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeImageDestroy_Tracing(nullptr);
result = zeImageDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -204,7 +204,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
setTracerCallbacksAndEnableTracer();
result = zeImageGetProperties_Tracing(ImageGetProperties_args.hDevice0, &ImageGetProperties_args.desc0, &ImageGetProperties_args.ImageProperties0);
result = zeImageGetPropertiesTracing(ImageGetProperties_args.hDevice0, &ImageGetProperties_args.desc0, &ImageGetProperties_args.ImageProperties0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -465,7 +465,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
setTracerCallbacksAndEnableTracer();
result = zeImageCreate_Tracing(ImageCreate_args.hContext0, ImageCreate_args.hDevice0, &ImageCreate_args.desc0, &ImageCreate_args.hImage0);
result = zeImageCreateTracing(ImageCreate_args.hContext0, ImageCreate_args.hDevice0, &ImageCreate_args.desc0, &ImageCreate_args.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -594,7 +594,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
setTracerCallbacksAndEnableTracer();
result = zeImageDestroy_Tracing(ImageDestroy_args.hImage0);
result = zeImageDestroyTracing(ImageDestroy_args.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

36
level_zero/experimental/test/unit_tests/sources/tracing/test_memory_api_tracing.cpp
View File

@@ -26,7 +26,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocSharedTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeMemAllocShared_Tracing(nullptr, &deviceDesc, &hostDesc, size, alignment, nullptr, &pptr);
result = zeMemAllocSharedTracing(nullptr, &deviceDesc, &hostDesc, size, alignment, nullptr, &pptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -46,7 +46,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocDeviceTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeMemAllocDevice_Tracing(nullptr, &deviceDesc, size, alignment, nullptr, &pptr);
result = zeMemAllocDeviceTracing(nullptr, &deviceDesc, size, alignment, nullptr, &pptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -65,7 +65,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocHostTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeMemAllocHost_Tracing(nullptr, &hostDesc, size, alignment, &pptr);
result = zeMemAllocHostTracing(nullptr, &hostDesc, size, alignment, &pptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -80,7 +80,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemFreeTracingWrapperWithOneSetOfPro
setTracerCallbacksAndEnableTracer();
result = zeMemFree_Tracing(nullptr, nullptr);
result = zeMemFreeTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -95,7 +95,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetAllocPropertiesTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeMemGetAllocProperties_Tracing(nullptr, nullptr, nullptr, nullptr);
result = zeMemGetAllocPropertiesTracing(nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -110,7 +110,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetAddressRangeTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeMemGetAddressRange_Tracing(nullptr, nullptr, nullptr, nullptr);
result = zeMemGetAddressRangeTracing(nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -125,7 +125,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetIpcHandleTracingWrapperWithOne
setTracerCallbacksAndEnableTracer();
result = zeMemGetIpcHandle_Tracing(nullptr, nullptr, nullptr);
result = zeMemGetIpcHandleTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -142,7 +142,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemOpenIpcHandleTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeMemOpenIpcHandle_Tracing(nullptr, nullptr, ipchandle, 0, nullptr);
result = zeMemOpenIpcHandleTracing(nullptr, nullptr, ipchandle, 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -157,7 +157,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingMemCloseIpcHandleTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zeMemCloseIpcHandle_Tracing(nullptr, nullptr);
result = zeMemCloseIpcHandleTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -172,7 +172,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingPhysicalMemCreateTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zePhysicalMemCreate_Tracing(nullptr, nullptr, nullptr, nullptr);
result = zePhysicalMemCreateTracing(nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -188,7 +188,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingPhysicalMemDestroyTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zePhysicalMemDestroy_Tracing(nullptr, nullptr);
result = zePhysicalMemDestroyTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -204,7 +204,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemFreeTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemFree_Tracing(nullptr, nullptr, 1U);
result = zeVirtualMemFreeTracing(nullptr, nullptr, 1U);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -220,7 +220,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemGetAccessAttributeTracingW
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemGetAccessAttribute_Tracing(nullptr, nullptr, 1U, nullptr, nullptr);
result = zeVirtualMemGetAccessAttributeTracing(nullptr, nullptr, 1U, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -236,7 +236,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemMapTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemMap_Tracing(nullptr, nullptr, 1U, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
result = zeVirtualMemMapTracing(nullptr, nullptr, 1U, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -252,7 +252,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemQueryPageSizeTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemQueryPageSize_Tracing(nullptr, nullptr, 1U, nullptr);
result = zeVirtualMemQueryPageSizeTracing(nullptr, nullptr, 1U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -268,7 +268,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemReserveTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemReserve_Tracing(nullptr, nullptr, 1U, nullptr);
result = zeVirtualMemReserveTracing(nullptr, nullptr, 1U, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -284,7 +284,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemSetAccessAttributeTracingW
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemSetAccessAttribute_Tracing(nullptr, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
result = zeVirtualMemSetAccessAttributeTracing(nullptr, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
@@ -300,7 +300,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemUnmapTracingWrapperWithOne
setTracerCallbacksAndEnableTracer();
result = zeVirtualMemUnmap_Tracing(nullptr, nullptr, 1U);
result = zeVirtualMemUnmapTracing(nullptr, nullptr, 1U);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);

42
level_zero/experimental/test/unit_tests/sources/tracing/test_module_api_multi_tracing.cpp
View File

@@ -373,7 +373,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
setTracerCallbacksAndEnableTracer();
result = zeModuleCreate_Tracing(module_create_args.hContext0, module_create_args.hDevice0, &module_create_args.desc0, &module_create_args.hModule0, &module_create_args.hBuildLog0);
result = zeModuleCreateTracing(module_create_args.hContext0, module_create_args.hDevice0, &module_create_args.desc0, &module_create_args.hModule0, &module_create_args.hBuildLog0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -502,7 +502,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
setTracerCallbacksAndEnableTracer();
result = zeModuleDestroy_Tracing(module_destroy_args.hModule0);
result = zeModuleDestroyTracing(module_destroy_args.hModule0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -521,14 +521,14 @@ struct {
void *instanceData3;
} module_get_native_binary_args;
static void module_get_native_binary_native_binary_init_random(uint8_t *binary, size_t size) {
static void moduleGetNativeBinaryNativeBinaryInitRandom(uint8_t *binary, size_t size) {
uint8_t *ptr = binary;
for (size_t i = 0; i < size; i++) {
*ptr = generateRandomSize<uint8_t>();
}
}
static bool module_get_native_binary_native_binary_compare(uint8_t *binary0, uint8_t *binary1, size_t size) {
static bool moduleGetNativeBinaryNativeBinaryCompare(uint8_t *binary0, uint8_t *binary1, size_t size) {
if (binary0 == nullptr) {
return false;
}
@@ -543,11 +543,11 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
// initialize initial argument set
module_get_native_binary_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
module_get_native_binary_native_binary_init_random(module_get_native_binary_args.moduleNativeBinary0, moduleGetNativeBinarySize0);
moduleGetNativeBinaryNativeBinaryInitRandom(module_get_native_binary_args.moduleNativeBinary0, moduleGetNativeBinarySize0);
// initialize replacement argument set
module_get_native_binary_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
module_get_native_binary_native_binary_init_random(module_get_native_binary_args.moduleNativeBinary1, moduleGetNativeBinarySize1);
moduleGetNativeBinaryNativeBinaryInitRandom(module_get_native_binary_args.moduleNativeBinary1, moduleGetNativeBinarySize1);
// initialize user instance data
module_get_native_binary_args.instanceData0 = generateRandomHandle<void *>();
@@ -559,8 +559,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(&module_get_native_binary_args.size1, pSize);
EXPECT_EQ(*pSize, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, pModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
pModuleNativeBinary, moduleGetNativeBinarySize0));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
pModuleNativeBinary, moduleGetNativeBinarySize0));
return ZE_RESULT_SUCCESS;
};
@@ -587,8 +587,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize0);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary0, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary0,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize0));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary0,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize0));
*params->phModule = module_get_native_binary_args.hModule1;
*params->ppSize = &module_get_native_binary_args.size1;
*params->ppModuleNativeBinary = module_get_native_binary_args.moduleNativeBinary1;
@@ -627,8 +627,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
@@ -661,8 +661,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -693,8 +693,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -725,8 +725,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
@@ -761,8 +761,8 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
@@ -774,7 +774,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
setTracerCallbacksAndEnableTracer();
result = zeModuleGetNativeBinary_Tracing(module_get_native_binary_args.hModule0, &module_get_native_binary_args.size0, module_get_native_binary_args.moduleNativeBinary0);
result = zeModuleGetNativeBinaryTracing(module_get_native_binary_args.hModule0, &module_get_native_binary_args.size0, module_get_native_binary_args.moduleNativeBinary0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

50
level_zero/experimental/test/unit_tests/sources/tracing/test_module_api_tracing.cpp
View File

@@ -23,7 +23,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleCreateTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeModuleCreate_Tracing(nullptr, nullptr, &desc, &phModule, &phBuildLog);
result = zeModuleCreateTracing(nullptr, nullptr, &desc, &phModule, &phBuildLog);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -38,7 +38,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleDestroyTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeModuleDestroy_Tracing(nullptr);
result = zeModuleDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -53,7 +53,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleBuildLogDestroyTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeModuleBuildLogDestroy_Tracing(nullptr);
result = zeModuleBuildLogDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -71,7 +71,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleBuildLogGetStringTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeModuleBuildLogGetString_Tracing(nullptr, &pSize, &pBuildLog);
result = zeModuleBuildLogGetStringTracing(nullptr, &pSize, &pBuildLog);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -88,7 +88,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetNativeBinaryTracingWrapperW
setTracerCallbacksAndEnableTracer();
result = zeModuleGetNativeBinary_Tracing(nullptr, &pSize, &pModuleNativeBinary);
result = zeModuleGetNativeBinaryTracing(nullptr, &pSize, &pModuleNativeBinary);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -106,7 +106,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetGlobalPointerTracingWrapper
setTracerCallbacksAndEnableTracer();
result = zeModuleGetGlobalPointer_Tracing(nullptr, &pGlobalName, &size, &pptr);
result = zeModuleGetGlobalPointerTracing(nullptr, &pGlobalName, &size, &pptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -123,7 +123,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelCreateTracingWrapperWithOneSet
setTracerCallbacksAndEnableTracer();
result = zeKernelCreate_Tracing(nullptr, &desc, &phKernel);
result = zeKernelCreateTracing(nullptr, &desc, &phKernel);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -138,7 +138,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelDestroyTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeKernelDestroy_Tracing(nullptr);
result = zeKernelDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -155,7 +155,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetFunctionPointerTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeModuleGetFunctionPointer_Tracing(nullptr, &pKernelName, &pfnFunction);
result = zeModuleGetFunctionPointerTracing(nullptr, &pKernelName, &pfnFunction);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -173,7 +173,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetGroupSizeTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeKernelSetGroupSize_Tracing(nullptr, groupSizeX, groupSizeY, groupSizeZ);
result = zeKernelSetGroupSizeTracing(nullptr, groupSizeX, groupSizeY, groupSizeZ);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -194,7 +194,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSuggestGroupSizeTracingWrapper
setTracerCallbacksAndEnableTracer();
result = zeKernelSuggestGroupSize_Tracing(nullptr, globalSizeX, globalSizeY, globalSizeZ, &groupSizeX, &groupSizeY, &groupSizeZ);
result = zeKernelSuggestGroupSizeTracing(nullptr, globalSizeX, globalSizeY, globalSizeZ, &groupSizeX, &groupSizeY, &groupSizeZ);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -212,7 +212,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetArgumentValueTracingWrapper
setTracerCallbacksAndEnableTracer();
result = zeKernelSetArgumentValue_Tracing(nullptr, argIndex, argSize, &pArgValue);
result = zeKernelSetArgumentValueTracing(nullptr, argIndex, argSize, &pArgValue);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -227,7 +227,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetPropertiesTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeKernelGetProperties_Tracing(nullptr, nullptr);
result = zeKernelGetPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -247,7 +247,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelTracing
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendLaunchKernel_Tracing(nullptr, nullptr, &pLaunchFuncArgs, hSignalEvent, numWaitEvents, &phWaitEvents);
result = zeCommandListAppendLaunchKernelTracing(nullptr, nullptr, &pLaunchFuncArgs, hSignalEvent, numWaitEvents, &phWaitEvents);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -267,7 +267,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelIndirec
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendLaunchKernelIndirect_Tracing(nullptr, nullptr, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
result = zeCommandListAppendLaunchKernelIndirectTracing(nullptr, nullptr, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -291,7 +291,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchMultipleKerne
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(nullptr, numKernels, &phKernels, &pNumLaunchArguments, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
result = zeCommandListAppendLaunchMultipleKernelsIndirectTracing(nullptr, numKernels, &phKernels, &pNumLaunchArguments, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -306,7 +306,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchCooperativeKe
setTracerCallbacksAndEnableTracer();
result = zeCommandListAppendLaunchCooperativeKernel_Tracing(nullptr, nullptr, nullptr, nullptr, 1, nullptr);
result = zeCommandListAppendLaunchCooperativeKernelTracing(nullptr, nullptr, nullptr, nullptr, 1, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -321,7 +321,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetKernelNamesTracingWrapperWi
setTracerCallbacksAndEnableTracer();
result = zeModuleGetKernelNames_Tracing(nullptr, nullptr, nullptr);
result = zeModuleGetKernelNamesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -336,7 +336,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSuggestMaxCooperativeGroupCoun
setTracerCallbacksAndEnableTracer();
result = zeKernelSuggestMaxCooperativeGroupCount_Tracing(nullptr, nullptr);
result = zeKernelSuggestMaxCooperativeGroupCountTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -351,7 +351,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetIndirectAccessTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeKernelGetIndirectAccess_Tracing(nullptr, nullptr);
result = zeKernelGetIndirectAccessTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -366,7 +366,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetNameTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeKernelGetName_Tracing(nullptr, nullptr, nullptr);
result = zeKernelGetNameTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -381,7 +381,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetSourceAttributesTracingWrap
setTracerCallbacksAndEnableTracer();
result = zeKernelGetSourceAttributes_Tracing(nullptr, nullptr, nullptr);
result = zeKernelGetSourceAttributesTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -396,7 +396,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetIndirectAccessTracingWrappe
setTracerCallbacksAndEnableTracer();
result = zeKernelSetIndirectAccess_Tracing(nullptr, ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST);
result = zeKernelSetIndirectAccessTracing(nullptr, ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -411,7 +411,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleDynamicLinkTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zeModuleDynamicLink_Tracing(1U, nullptr, nullptr);
result = zeModuleDynamicLinkTracing(1U, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -426,7 +426,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetPropertiesTracingWrapperWit
setTracerCallbacksAndEnableTracer();
result = zeModuleGetProperties_Tracing(nullptr, nullptr);
result = zeModuleGetPropertiesTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}

24
level_zero/experimental/test/unit_tests/sources/tracing/test_residency_api_tracing.cpp
View File

@@ -19,7 +19,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextCreateTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeContextCreate_Tracing(nullptr, nullptr, nullptr);
result = zeContextCreateTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -33,7 +33,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextDestroyTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeContextDestroy_Tracing(nullptr);
result = zeContextDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -47,7 +47,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextGetStatusTracingWrapperWithOn
setTracerCallbacksAndEnableTracer();
result = zeContextGetStatus_Tracing(nullptr);
result = zeContextGetStatusTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -61,7 +61,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextSystemBarrierTracingWrapperWi
setTracerCallbacksAndEnableTracer();
result = zeContextSystemBarrier_Tracing(nullptr, nullptr);
result = zeContextSystemBarrierTracing(nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -75,7 +75,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextMakeMemoryResidentTracingWrap
setTracerCallbacksAndEnableTracer();
result = zeContextMakeMemoryResident_Tracing(nullptr, nullptr, nullptr, 1024);
result = zeContextMakeMemoryResidentTracing(nullptr, nullptr, nullptr, 1024);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -89,7 +89,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextEvictMemoryTracingWrapperWith
setTracerCallbacksAndEnableTracer();
result = zeContextEvictMemory_Tracing(nullptr, nullptr, nullptr, 1024);
result = zeContextEvictMemoryTracing(nullptr, nullptr, nullptr, 1024);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -103,7 +103,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextMakeImageResidentTracingWrapp
setTracerCallbacksAndEnableTracer();
result = zeContextMakeImageResident_Tracing(nullptr, nullptr, nullptr);
result = zeContextMakeImageResidentTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -117,7 +117,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingContextEvictImageTracingWrapperWithO
setTracerCallbacksAndEnableTracer();
result = zeContextEvictImage_Tracing(nullptr, nullptr, nullptr);
result = zeContextEvictImageTracing(nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -284,7 +284,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
setTracerCallbacksAndEnableTracer();
result = zeContextMakeMemoryResident_Tracing(MakeMemoryResident_args.hContext0, MakeMemoryResident_args.hDevice0, MakeMemoryResident_args.ptr0, MakeMemoryResident_args.size0);
result = zeContextMakeMemoryResidentTracing(MakeMemoryResident_args.hContext0, MakeMemoryResident_args.hDevice0, MakeMemoryResident_args.ptr0, MakeMemoryResident_args.size0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -447,7 +447,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
setTracerCallbacksAndEnableTracer();
result = zeContextEvictMemory_Tracing(EvictMemory_args.hContext0, EvictMemory_args.hDevice0, EvictMemory_args.ptr0, EvictMemory_args.size0);
result = zeContextEvictMemoryTracing(EvictMemory_args.hContext0, EvictMemory_args.hDevice0, EvictMemory_args.ptr0, EvictMemory_args.size0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -602,7 +602,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
setTracerCallbacksAndEnableTracer();
result = zeContextMakeImageResident_Tracing(MakeImageResident_args.hContext0, MakeImageResident_args.hDevice0, MakeImageResident_args.hImage0);
result = zeContextMakeImageResidentTracing(MakeImageResident_args.hContext0, MakeImageResident_args.hDevice0, MakeImageResident_args.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -757,7 +757,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
setTracerCallbacksAndEnableTracer();
result = zeContextMakeImageResident_Tracing(EvictImage_args.hContext0, EvictImage_args.hDevice0, EvictImage_args.hImage0);
result = zeContextMakeImageResidentTracing(EvictImage_args.hContext0, EvictImage_args.hDevice0, EvictImage_args.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

8
level_zero/experimental/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp
View File

@@ -19,7 +19,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingSamplerCreateTracingWrapperWithOneSe
setTracerCallbacksAndEnableTracer();
result = zeSamplerCreate_Tracing(nullptr, nullptr, nullptr, nullptr);
result = zeSamplerCreateTracing(nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -33,7 +33,7 @@ TEST_F(zeAPITracingRuntimeTests, WhenCallingSamplerDestroyTracingWrapperWithOneS
setTracerCallbacksAndEnableTracer();
result = zeSamplerDestroy_Tracing(nullptr);
result = zeSamplerDestroyTracing(nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultUserData, 1);
}
@@ -286,7 +286,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
setTracerCallbacksAndEnableTracer();
result = zeSamplerCreate_Tracing(sampler_create_args.hContext0, sampler_create_args.hDevice0, &sampler_create_args.Desc0, &sampler_create_args.hSampler0);
result = zeSamplerCreateTracing(sampler_create_args.hContext0, sampler_create_args.hDevice0, &sampler_create_args.Desc0, &sampler_create_args.hSampler0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(sampler_create_args.hSampler1, sampler_create_args.hSamplerAPI);
validateDefaultUserDataFinal();
@@ -418,7 +418,7 @@ TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
setTracerCallbacksAndEnableTracer();
result = zeSamplerDestroy_Tracing(sampler_destroy_args.hSampler0);
result = zeSamplerDestroyTracing(sampler_destroy_args.hSampler0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

4
level_zero/source/inc/ze_intel_gpu.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -11,7 +11,7 @@
#include <stdlib.h>
#include <string.h>
inline bool getenv_tobool(const char *name) {
inline bool getEnvToBool(const char *name) {
const char *env = getenv(name);
if ((nullptr == env) || (0 == strcmp("0", env)))
return false;

28
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.cpp
View File

@@ -101,7 +101,7 @@ bool SingleDeviceTestRunner::run() {
//////////////
/// query_test
//////////////
bool query_test() {
bool queryTest() {
// This test verifies Query mode for a metric group for all devices OR specific device
bool status = true;
@@ -153,7 +153,7 @@ bool query_test() {
///////////////
/// stream_test
///////////////
bool stream_test() {
bool streamTest() {
// This test verifies Streamer mode for a metric group for all devices OR specific device
@@ -205,7 +205,7 @@ bool stream_test() {
////////////////////////////////////
/// stream_multi_metric_domain_test
////////////////////////////////////
bool stream_multi_metric_domain_test() {
bool streamMultiMetricDomainTest() {
// This test validates that metric groups of different domains can be captured concurrently
@@ -266,7 +266,7 @@ bool stream_multi_metric_domain_test() {
//////////////////////////////////////////////
/// stream_mt_collection_workload_same_thread
//////////////////////////////////////////////
bool stream_mt_collection_workload_same_thread() {
bool streamMtCollectionWorkloadSameThread() {
// This test collects Metrics on sub-devices from different threads
// Each thread runs the workload and collects for a single sub-device
@@ -329,7 +329,7 @@ bool stream_mt_collection_workload_same_thread() {
////////////////////////////////////////////////////
/// stream_mt_collection_workload_different_threads
////////////////////////////////////////////////////
bool stream_mt_collection_workload_different_threads() {
bool streamMtCollectionWorkloadDifferentThreads() {
// This test collects Metrics on one device from different threads
// One thread collects metrics and other runs the workload
@@ -417,7 +417,7 @@ bool stream_mt_collection_workload_different_threads() {
//////////////////////////////////////////////
/// stream_mp_collection_workload_same_process
//////////////////////////////////////////////
bool stream_mp_collection_workload_same_process() {
bool streamMpCollectionWorkloadSameProcess() {
// This test collects Metric on devices from different processes
// Each process runs the workload and collects for a single device
@@ -482,7 +482,7 @@ bool stream_mp_collection_workload_same_process() {
////////////////////////////////////////////////////
/// stream_mp_collection_workload_different_process
////////////////////////////////////////////////////
bool stream_mp_collection_workload_different_process() {
bool streamMpCollectionWorkloadDifferentProcess() {
// This test collects EuStallSampling Metric on one process and runs the workload on another process
@@ -583,13 +583,13 @@ int main(int argc, char *argv[]) {
std::map<std::string, std::function<bool()>> tests;
tests["query_test"] = query_test;
tests["stream_test"] = stream_test;
tests["stream_multi_metric_domain_test"] = stream_multi_metric_domain_test;
tests["stream_mt_collection_workload_same_thread"] = stream_mt_collection_workload_same_thread;
tests["stream_mt_collection_workload_different_threads"] = stream_mt_collection_workload_different_threads;
tests["stream_mp_collection_workload_same_process"] = stream_mp_collection_workload_same_process;
tests["stream_mp_collection_workload_different_process"] = stream_mp_collection_workload_different_process;
tests["query_test"] = queryTest;
tests["stream_test"] = streamTest;
tests["stream_multi_metric_domain_test"] = streamMultiMetricDomainTest;
tests["stream_mt_collection_workload_same_thread"] = streamMtCollectionWorkloadSameThread;
tests["stream_mt_collection_workload_different_threads"] = streamMtCollectionWorkloadDifferentThreads;
tests["stream_mp_collection_workload_same_process"] = streamMpCollectionWorkloadSameProcess;
tests["stream_mp_collection_workload_different_process"] = streamMpCollectionWorkloadDifferentProcess;
auto testSettings = zmu::TestSettings::get();
testSettings->parseArguments(argc, argv);

360
opencl/source/api/api.cpp
View File

File diff suppressed because it is too large Load Diff

4
opencl/source/command_queue/command_queue.cpp
View File

@@ -394,7 +394,7 @@ bool CommandQueue::isQueueBlocked() {
taskLevel = getGpgpuCommandStreamReceiver().peekTaskLevel();
}
FileLoggerInstance().log(DebugManager.flags.EventsDebugEnable.get(), "isQueueBlocked taskLevel change from", taskLevel, "to new from virtualEvent", this->virtualEvent, "new tasklevel", this->virtualEvent->taskLevel.load());
fileLoggerInstance().log(DebugManager.flags.EventsDebugEnable.get(), "isQueueBlocked taskLevel change from", taskLevel, "to new from virtualEvent", this->virtualEvent, "new tasklevel", this->virtualEvent->taskLevel.load());
// close the access to virtual event, driver added only 1 ref count.
this->virtualEvent->decRefInternal();
@@ -503,7 +503,7 @@ void CommandQueue::updateFromCompletionStamp(const CompletionStamp &completionSt
if (outEvent) {
outEvent->updateCompletionStamp(completionStamp.taskCount, outEvent->peekBcsTaskCountFromCommandQueue(), completionStamp.taskLevel, completionStamp.flushStamp);
FileLoggerInstance().log(DebugManager.flags.EventsDebugEnable.get(), "updateCompletionStamp Event", outEvent, "taskLevel", outEvent->taskLevel.load());
fileLoggerInstance().log(DebugManager.flags.EventsDebugEnable.get(), "updateCompletionStamp Event", outEvent, "taskLevel", outEvent->taskLevel.load());
}
}

6
opencl/source/command_queue/command_queue_hw_xehp_and_later.inl
View File

@@ -20,7 +20,7 @@ void CommandQueueHw<Family>::submitCacheFlush(Surface **surfaces,
uint64_t postSyncAddress) {
if constexpr (Family::isUsingL3Control) {
StackVec<L3Range, 128> subranges;
for (auto surface : CreateRange(surfaces, numSurfaces)) {
for (auto surface : createRange(surfaces, numSurfaces)) {
auto resource = reinterpret_cast<ResourceSurface *>(surface);
auto alloc = resource->getGraphicsAllocation();
coverRangeExact(alloc->getGpuAddress(), alloc->getUnderlyingBufferSize(), subranges, resource->resourceType);
@@ -28,7 +28,7 @@ void CommandQueueHw<Family>::submitCacheFlush(Surface **surfaces,
for (size_t subrangeNumber = 0; subrangeNumber < subranges.size(); subrangeNumber += maxFlushSubrangeCount) {
size_t rangeCount = subranges.size() <= subrangeNumber + maxFlushSubrangeCount ? subranges.size() - subrangeNumber : maxFlushSubrangeCount;
Range<L3Range> range = CreateRange(subranges.begin() + subrangeNumber, rangeCount);
Range<L3Range> range = createRange(subranges.begin() + subrangeNumber, rangeCount);
uint64_t postSyncAddressToFlush = 0;
if (rangeCount < maxFlushSubrangeCount || subranges.size() - subrangeNumber - maxFlushSubrangeCount == 0) {
postSyncAddressToFlush = postSyncAddress;
@@ -55,7 +55,7 @@ LinearStream &getCommandStream<Family, CL_COMMAND_RESOURCE_BARRIER>(CommandQueue
if constexpr (Family::isUsingL3Control) {
StackVec<L3Range, 128> subranges;
for (auto surface : CreateRange(surfaces, numSurfaces)) {
for (auto surface : createRange(surfaces, numSurfaces)) {
ResourceSurface *resource = reinterpret_cast<ResourceSurface *>(surface);
auto alloc = resource->getGraphicsAllocation();
coverRangeExact(alloc->getGpuAddress(), alloc->getUnderlyingBufferSize(), subranges, resource->resourceType);

6
opencl/source/command_queue/enqueue_common.h
View File

@@ -689,7 +689,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
bool anyUncacheableArgs = false;
auto requiresCoherency = false;
for (auto surface : CreateRange(surfaces, surfaceCount)) {
for (auto surface : createRange(surfaces, surfaceCount)) {
surface->makeResident(getGpgpuCommandStreamReceiver());
requiresCoherency |= surface->IsCoherent;
if (!surface->allowsL3Caching()) {
@@ -925,7 +925,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlocked(
}
allSurfaces.reserve(allSurfaces.size() + surfaceCount);
for (auto &surface : CreateRange(surfaces, surfaceCount)) {
for (auto &surface : createRange(surfaces, surfaceCount)) {
allSurfaces.push_back(surface->duplicate());
}
@@ -998,7 +998,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
timestampPacketDependencies.cacheFlushNodes.makeResident(getGpgpuCommandStreamReceiver());
}
for (auto surface : CreateRange(surfaces, surfaceCount)) {
for (auto surface : createRange(surfaces, surfaceCount)) {
surface->makeResident(getGpgpuCommandStreamReceiver());
}

2
opencl/source/command_queue/hardware_interface_base.inl
View File

@@ -171,7 +171,7 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
HardwareCommandsHelper<GfxFamily>::programCacheFlushAfterWalkerCommand(commandStream, commandQueue, mainKernel, postSyncAddress);
}
if (PauseOnGpuProperties::GpuScratchRegWriteAllowed(DebugManager.flags.GpuScratchRegWriteAfterWalker.get(), commandQueue.getGpgpuCommandStreamReceiver().peekTaskCount())) {
if (PauseOnGpuProperties::gpuScratchRegWriteAllowed(DebugManager.flags.GpuScratchRegWriteAfterWalker.get(), commandQueue.getGpgpuCommandStreamReceiver().peekTaskCount())) {
uint32_t registerOffset = DebugManager.flags.GpuScratchRegWriteRegisterOffset.get();
uint32_t registerData = DebugManager.flags.GpuScratchRegWriteRegisterData.get();
LriHelper<GfxFamily>::program(commandStream, registerOffset, registerData, EncodeSetMMIO<GfxFamily>::isRemapApplicable(registerOffset));

6
opencl/source/command_queue/resource_barrier.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,11 +16,11 @@
namespace NEO {
BarrierCommand::BarrierCommand(CommandQueue *commandQueue, const cl_resource_barrier_descriptor_intel *descriptors, uint32_t numDescriptors) : numSurfaces(numDescriptors) {
for (auto description : CreateRange(descriptors, numDescriptors)) {
for (auto description : createRange(descriptors, numDescriptors)) {
GraphicsAllocation *allocation;
if (description.mem_object) {
MemObj *memObj = nullptr;
WithCastToInternal(description.mem_object, &memObj);
withCastToInternal(description.mem_object, &memObj);
allocation = memObj->getGraphicsAllocation(commandQueue->getDevice().getRootDeviceIndex());
} else {
auto svmData = commandQueue->getContext().getSVMAllocsManager()->getSVMAlloc(description.svm_allocation_pointer);

2
opencl/source/context/context.cpp
View File

@@ -458,7 +458,7 @@ Platform *Context::getPlatformFromProperties(const cl_context_properties *proper
propertiesCurrent += 2;
if (CL_CONTEXT_PLATFORM == propertyType) {
Platform *pPlatform = nullptr;
errcode = validateObject(WithCastToInternal(reinterpret_cast<cl_platform_id>(propertyValue), &pPlatform));
errcode = validateObject(withCastToInternal(reinterpret_cast<cl_platform_id>(propertyValue), &pPlatform));
return pPlatform;
}
}

4
opencl/source/gtpin/gtpin_init.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,7 +13,7 @@
extern "C" {
#endif
gtpin::GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, gtpin::driver_services_t *pDriverServices, gtpin::interface_version_t *pDriverVersion);
gtpin::GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, gtpin::driver_services_t *pDriverServices, gtpin::interface_version_t *pDriverVersion); // NOLINT(readability-identifier-naming)
#ifdef __cplusplus
}

4
opencl/source/helpers/cl_validators.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -24,7 +24,7 @@ enum NonZeroBufferSize : size_t;
enum PatternSize : size_t;
template <typename CLType, typename InternalType>
CLType WithCastToInternal(CLType clObject, InternalType **internalObject) {
CLType withCastToInternal(CLType clObject, InternalType **internalObject) {
*internalObject = NEO::castToObject<InternalType>(clObject);
return (*internalObject) ? clObject : nullptr;
}

2
opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl
View File

@@ -184,7 +184,7 @@ void HardwareCommandsHelper<GfxFamily>::programCacheFlushAfterWalkerCommand(Line
}
for (size_t subrangeNumber = 0; subrangeNumber < subranges.size(); subrangeNumber += maxFlushSubrangeCount) {
size_t rangeCount = subranges.size() <= subrangeNumber + maxFlushSubrangeCount ? subranges.size() - subrangeNumber : maxFlushSubrangeCount;
Range<L3Range> range = CreateRange(subranges.begin() + subrangeNumber, rangeCount);
Range<L3Range> range = createRange(subranges.begin() + subrangeNumber, rangeCount);
uint64_t postSyncAddressToFlush = 0;
if (rangeCount < maxFlushSubrangeCount || subranges.size() - subrangeNumber - maxFlushSubrangeCount == 0) {
postSyncAddressToFlush = postSyncAddress;

6
opencl/source/helpers/sampler_helpers.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -28,7 +28,7 @@ enum SAMPLER_PATCH_ENUM {
CLK_FILTER_LINEAR = 0x00,
};
inline SAMPLER_PATCH_ENUM GetAddrModeEnum(cl_addressing_mode addressingMode) {
inline SAMPLER_PATCH_ENUM getAddrModeEnum(cl_addressing_mode addressingMode) {
switch (addressingMode) {
case CL_ADDRESS_REPEAT:
return CLK_ADDRESS_REPEAT;
@@ -44,7 +44,7 @@ inline SAMPLER_PATCH_ENUM GetAddrModeEnum(cl_addressing_mode addressingMode) {
return CLK_ADDRESS_NONE;
}
inline SAMPLER_PATCH_ENUM GetNormCoordsEnum(cl_bool normalizedCoords) {
inline SAMPLER_PATCH_ENUM getNormCoordsEnum(cl_bool normalizedCoords) {
if (normalizedCoords == CL_TRUE) {
return CLK_NORMALIZED_COORDS_TRUE;
} else {

6
opencl/source/kernel/kernel.cpp
View File

@@ -1662,8 +1662,8 @@ cl_int Kernel::setArgSampler(uint32_t argIndex,
pSampler->setArg(const_cast<void *>(samplerState), clDevice.getHardwareInfo());
patch<uint32_t, uint32_t>(pSampler->getSnapWaValue(), crossThreadData, argAsSmp.metadataPayload.samplerSnapWa);
patch<uint32_t, uint32_t>(GetAddrModeEnum(pSampler->addressingMode), crossThreadData, argAsSmp.metadataPayload.samplerAddressingMode);
patch<uint32_t, uint32_t>(GetNormCoordsEnum(pSampler->normalizedCoordinates), crossThreadData, argAsSmp.metadataPayload.samplerNormalizedCoords);
patch<uint32_t, uint32_t>(getAddrModeEnum(pSampler->addressingMode), crossThreadData, argAsSmp.metadataPayload.samplerAddressingMode);
patch<uint32_t, uint32_t>(getNormCoordsEnum(pSampler->normalizedCoordinates), crossThreadData, argAsSmp.metadataPayload.samplerNormalizedCoords);
if (arg.getExtendedTypeInfo().hasDeviceSideEnqueueExtendedDescriptor) {
const auto &explicitArgsExtendedDescriptors = kernelInfo.kernelDescriptor.payloadMappings.explicitArgsExtendedDescriptors;
UNRECOVERABLE_IF(argIndex >= explicitArgsExtendedDescriptors.size());
@@ -1816,7 +1816,7 @@ cl_int Kernel::checkCorrectImageAccessQualifier(cl_uint argIndex,
if (arg.is<ArgDescriptor::ArgTImage>()) {
cl_mem mem = *(static_cast<const cl_mem *>(argValue));
MemObj *pMemObj = nullptr;
WithCastToInternal(mem, &pMemObj);
withCastToInternal(mem, &pMemObj);
if (pMemObj) {
auto accessQualifier = arg.getTraits().accessQualifier;
cl_mem_flags flags = pMemObj->getFlags();

4
opencl/source/kernel/kernel.h
View File

@@ -105,10 +105,10 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
*errcodeRet = retVal;
}
if (FileLoggerInstance().enabled()) {
if (fileLoggerInstance().enabled()) {
std::string source;
program->getSource(source);
FileLoggerInstance().dumpKernel(kernelInfo.kernelDescriptor.kernelMetadata.kernelName, source);
fileLoggerInstance().dumpKernel(kernelInfo.kernelDescriptor.kernelMetadata.kernelName, source);
}
return pKernel;

2
opencl/source/mem_obj/buffer.cpp
View File

@@ -101,7 +101,7 @@ cl_mem Buffer::validateInputAndCreateBuffer(cl_context context,
void *hostPtr,
cl_int &retVal) {
Context *pContext = nullptr;
retVal = validateObjects(WithCastToInternal(context, &pContext));
retVal = validateObjects(withCastToInternal(context, &pContext));
if (retVal != CL_SUCCESS) {
return nullptr;
}

2
opencl/source/mem_obj/image.cpp
View File

@@ -1171,7 +1171,7 @@ cl_mem Image::validateAndCreateImage(cl_context context,
cl_int &errcodeRet) {
Context *pContext = nullptr;
errcodeRet = validateObjects(WithCastToInternal(context, &pContext));
errcodeRet = validateObjects(withCastToInternal(context, &pContext));
if (errcodeRet != CL_SUCCESS) {
return nullptr;
}

38
opencl/source/os_interface/windows/api_win.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -99,7 +99,7 @@ void *NEO::Context::getOsContextInfo(cl_context_info &paramName, size_t *srcPara
cl_int CL_API_CALL clGetDeviceIDsFromDX9INTEL(cl_platform_id platform, cl_dx9_device_source_intel dx9DeviceSource, void *dx9Object,
cl_dx9_device_set_intel dx9DeviceSet, cl_uint numEntries, cl_device_id *devices, cl_uint *numDevices) {
Platform *platformInternal = nullptr;
auto retVal = validateObjects(WithCastToInternal(platform, &platformInternal));
auto retVal = validateObjects(withCastToInternal(platform, &platformInternal));
API_ENTER(&retVal);
DBG_LOG_INPUTS("platform", platform,
"dx9DeviceSource", dx9DeviceSource,
@@ -153,7 +153,7 @@ cl_int CL_API_CALL clEnqueueAcquireDX9ObjectsINTEL(cl_command_queue commandQueue
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -172,7 +172,7 @@ cl_int CL_API_CALL clEnqueueAcquireDX9ObjectsINTEL(cl_command_queue commandQueue
cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL(cl_command_queue commandQueue, cl_uint numObjects, cl_mem *memObjects,
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -205,7 +205,7 @@ cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(cl_platform_id platform,
cl_dx9_media_adapter_set_khr mediaAdapterSet, cl_uint numEntries,
cl_device_id *devices, cl_uint *numDevices) {
Platform *platformInternal = nullptr;
auto retVal = validateObjects(WithCastToInternal(platform, &platformInternal));
auto retVal = validateObjects(withCastToInternal(platform, &platformInternal));
API_ENTER(&retVal);
DBG_LOG_INPUTS("platform", platform,
"numMediaAdapters", numMediaAdapters,
@@ -245,7 +245,7 @@ cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(cl_context context, cl_mem_fla
cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(cl_command_queue commandQueue, cl_uint numObjects, const cl_mem *memObjects,
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -265,7 +265,7 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -311,7 +311,7 @@ cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(cl_platform_id platform, cl_d3d10_
Platform *platformInternal = nullptr;
ClDevice *device = nullptr;
auto retVal = validateObjects(WithCastToInternal(platform, &platformInternal));
auto retVal = validateObjects(withCastToInternal(platform, &platformInternal));
API_ENTER(&retVal);
DBG_LOG_INPUTS("platform", platform,
"d3dDeviceSource", d3dDeviceSource,
@@ -378,7 +378,7 @@ cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(cl_context context, cl_mem_flags f
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
@@ -401,7 +401,7 @@ cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(cl_context context, cl_mem_flag
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
@@ -424,7 +424,7 @@ cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(cl_context context, cl_mem_flag
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
@@ -441,7 +441,7 @@ cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(cl_command_queue commandQueue
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -474,7 +474,7 @@ cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(cl_command_queue commandQueue
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -522,7 +522,7 @@ cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(cl_platform_id platform, cl_d3d11_
Platform *platformInternal = nullptr;
ClDevice *device = nullptr;
auto retVal = validateObjects(WithCastToInternal(platform, &platformInternal));
auto retVal = validateObjects(withCastToInternal(platform, &platformInternal));
API_ENTER(&retVal);
DBG_LOG_INPUTS("platform", platform,
"d3dDeviceSource", d3dDeviceSource,
@@ -589,7 +589,7 @@ cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(cl_context context, cl_mem_flags f
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
}
@@ -611,7 +611,7 @@ cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(cl_context context, cl_mem_flag
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
}
@@ -633,7 +633,7 @@ cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(cl_context context, cl_mem_flag
ErrorCodeHelper err(errcodeRet, CL_SUCCESS);
Context *ctx = nullptr;
err.set(validateObjects(WithCastToInternal(context, &ctx)));
err.set(validateObjects(withCastToInternal(context, &ctx)));
if (err.localErrcode != CL_SUCCESS) {
return nullptr;
@@ -650,7 +650,7 @@ cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(cl_command_queue commandQueue
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
@@ -683,7 +683,7 @@ cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(cl_command_queue commandQueue
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {
CommandQueue *cmdQ = nullptr;
auto retVal = validateObjects(WithCastToInternal(commandQueue, &cmdQ));
auto retVal = validateObjects(withCastToInternal(commandQueue, &cmdQ));
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,

26
opencl/source/sharings/gl/windows/cl_gl_api.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -42,7 +42,7 @@ cl_mem CL_API_CALL clCreateFromGLBuffer(cl_context context, cl_mem_flags flags,
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
@@ -72,7 +72,7 @@ cl_mem CL_API_CALL clCreateFromGLTexture(cl_context context, cl_mem_flags flags,
DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture);
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
cl_mem image = nullptr;
@@ -101,7 +101,7 @@ cl_mem CL_API_CALL clCreateFromGLTexture2D(cl_context context, cl_mem_flags flag
API_ENTER(errcodeRet);
DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture);
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
cl_mem image = nullptr;
@@ -131,7 +131,7 @@ cl_mem CL_API_CALL clCreateFromGLTexture3D(cl_context context, cl_mem_flags flag
API_ENTER(errcodeRet);
DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture);
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
cl_mem image = nullptr;
@@ -159,7 +159,7 @@ cl_mem CL_API_CALL clCreateFromGLRenderbuffer(cl_context context, cl_mem_flags f
API_ENTER(errcodeRet);
DBG_LOG_INPUTS("context", context, "flags", flags, "renderbuffer", renderbuffer);
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
@@ -208,8 +208,8 @@ cl_int CL_API_CALL clGetGLTextureInfo(cl_mem memobj, cl_gl_texture_info paramNam
cl_int retValue = CL_SUCCESS;
API_ENTER(&retValue);
DBG_LOG_INPUTS("memobj", memobj, "paramName", paramName, "paramValueSize", paramValueSize, "paramValueSize",
FileLoggerInstance().infoPointerToString(paramValue, paramValueSize), "paramValueSizeRet",
FileLoggerInstance().getInput(paramValueSizeRet, 0));
fileLoggerInstance().infoPointerToString(paramValue, paramValueSize), "paramValueSizeRet",
fileLoggerInstance().getInput(paramValueSizeRet, 0));
retValue = validateObjects(memobj);
if (retValue == CL_SUCCESS) {
auto pMemObj = castToObject<MemObj>(memobj);
@@ -231,7 +231,7 @@ cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue commandQueue, cl_u
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(WithCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));
retVal = validateObjects(withCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));
if (retVal == CL_SUCCESS) {
if (pCommandQueue->getContext().getSharing<GLSharingFunctions>() == nullptr) {
@@ -268,7 +268,7 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(WithCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));
retVal = validateObjects(withCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));
if (retVal == CL_SUCCESS) {
if (pCommandQueue->getContext().getSharing<GLSharingFunctions>() == nullptr) {
@@ -290,7 +290,7 @@ cl_event CL_API_CALL clCreateEventFromGLsyncKHR(cl_context context, cl_GLsync sy
API_ENTER(errcodeRet);
DBG_LOG_INPUTS("context", context, "sync", sync);
Context *pContext = nullptr;
auto returnCode = validateObjects(WithCastToInternal(context, &pContext));
auto returnCode = validateObjects(withCastToInternal(context, &pContext));
ErrorCodeHelper err(errcodeRet, returnCode);
@@ -311,8 +311,8 @@ cl_int CL_API_CALL clGetGLContextInfoKHR(const cl_context_properties *properties
cl_int retVal = CL_SUCCESS;
API_ENTER(&retVal);
DBG_LOG_INPUTS("properties", properties, "paramName", paramName, "paramValueSize", paramValueSize, "paramValue",
FileLoggerInstance().infoPointerToString(paramValue, paramValueSize), "paramValueSizeRet",
FileLoggerInstance().getInput(paramValueSizeRet, 0));
fileLoggerInstance().infoPointerToString(paramValue, paramValueSize), "paramValueSizeRet",
fileLoggerInstance().getInput(paramValueSizeRet, 0));
GetInfoHelper info(paramValue, paramValueSize, paramValueSizeRet);
uint32_t GLHGLRCHandle = 0;

Some files were not shown because too many files have changed in this diff Show More