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

level-zero v1.0 (2/N)

Browse Source 
Change-Id: I1419231a721fab210e166d26a264cae04d661dcd
Signed-off-by: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
Signed-off-by: macabral <matias.a.cabral@intel.com>
Signed-off-by: davidoli <david.olien@intel.com>
Signed-off-by: Aravind Gopalakrishnan <Aravind.Gopalakrishnan@intel.com>
Signed-off-by: Spruit, Neil R <neil.r.spruit@intel.com>
Signed-off-by: Latif, Raiyan <raiyan.latif@intel.com>
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Jaime Arteaga
2020-07-29 02:45:54 -07:00
committed by sys_ocldev
parent e8246a8179
commit 902fc2f6c4
255 changed files with 3200 additions and 12829 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
level_zero/CMakeLists.txt
View File

@ -21,9 +21,7 @@ if(BUILD_WITH_L0)
if(IS_DIRECTORY "${LEVEL_ZERO_ROOT_tmp}")
set(CUSTOM_L0_INCLUDE_PATH "${LEVEL_ZERO_ROOT_tmp}/include/level_zero/")
file(GLOB LEVEL_ZERO_SOURCE_HEADERS
"${LEVEL_ZERO_ROOT_tmp}/include/core/*"
"${LEVEL_ZERO_ROOT_tmp}/include/tools/*"
"${LEVEL_ZERO_ROOT_tmp}/include/experimental/*"
"${LEVEL_ZERO_ROOT_tmp}/include/*.h"
)
file(MAKE_DIRECTORY ${CUSTOM_L0_INCLUDE_PATH})
file(COPY ${LEVEL_ZERO_SOURCE_HEADERS} DESTINATION ${CUSTOM_L0_INCLUDE_PATH})
@ -46,6 +44,7 @@ if(BUILD_WITH_L0)
add_definitions( -DL0_PROJECT_VERSION_MAJOR="${PROJECT_VERSION_MAJOR}" )
add_definitions( -DL0_PROJECT_VERSION_MINOR="${PROJECT_VERSION_MINOR}" )
add_definitions( -DL0_PROJECT_VERSION_PATCH="${PROJECT_VERSION_PATCH}" )
add_definitions( -DNEO_VERSION_BUILD="${NEO_VERSION_BUILD}" )
add_definitions( -DZE_ENABLE_OCL_INTEROP=1)
@ -448,7 +447,7 @@ set_property(TARGET ${TARGET_NAME_L0} APPEND_STRING PROPERTY COMPILE_FLAGS ${ASA
set_target_properties(${TARGET_NAME_L0} PROPERTIES
FOLDER ${TARGET_NAME_L0}
VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
SOVERSION "${PROJECT_VERSION_MAJOR}"
)
if(UNIX)

2
level_zero/api/CMakeLists.txt
View File

@ -8,11 +8,13 @@ add_subdirectory(core)
add_subdirectory(experimental${BRANCH_DIR_SUFFIX}/)
add_subdirectory(experimental/tracing)
add_subdirectory(tools)
add_subdirectory(sysman)
set(L0_API "")
append_sources_from_properties(L0_API
L0_SRCS_API
L0_EXPERIMENTAL_API
L0_EXPERIMENTAL_TRACING_API
L0_SYSMAN_API
L0_TOOLS_API)
set_property(GLOBAL PROPERTY L0_API ${L0_API})

1
level_zero/api/core/CMakeLists.txt
View File

@ -7,7 +7,6 @@
set(L0_SRCS_API
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/ze_barrier.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ze_cl_interop.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ze_cmdlist.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ze_cmdqueue.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ze_context.cpp

4
level_zero/api/core/ze_barrier.cpp
View File

@ -8,8 +8,6 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendBarrier(
ze_command_list_handle_t hCommandList,
@ -36,5 +34,3 @@ zeDeviceSystemBarrier(
ze_device_handle_t hDevice) {
return L0::Device::fromHandle(hDevice)->systemBarrier();
}
} // extern "C"

40
level_zero/api/core/ze_cl_interop.cpp
View File

@ -1,40 +0,0 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceRegisterCLMemory(
ze_device_handle_t hDevice,
cl_context context,
cl_mem mem,
void **ptr) {
return L0::Device::fromHandle(hDevice)->registerCLMemory(context, mem, ptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceRegisterCLProgram(
ze_device_handle_t hDevice,
cl_context context,
cl_program program,
ze_module_handle_t *phModule) {
return L0::Device::fromHandle(hDevice)->registerCLProgram(context, program, phModule);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceRegisterCLCommandQueue(
ze_device_handle_t hDevice,
cl_context context,
cl_command_queue commandQueue,
ze_command_queue_handle_t *phCommandQueue) {
return L0::Device::fromHandle(hDevice)->registerCLCommandQueue(context, commandQueue, phCommandQueue);
}
} // extern "C"

24
level_zero/api/core/ze_cmdlist.cpp
View File

@ -9,20 +9,8 @@
#include "level_zero/core/source/context/context.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreate(
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList) {
return L0::Device::fromHandle(hDevice)->createCommandList(desc, phCommandList);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
@ -32,14 +20,6 @@ zeCommandListCreateExt(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediate(
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList) {
return L0::Device::fromHandle(hDevice)->createCommandListImmediate(altdesc, phCommandList);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
@ -66,7 +46,7 @@ zeCommandListReset(
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendWriteGlobalTimestampExt(
zeCommandListAppendWriteGlobalTimestamp(
ze_command_list_handle_t hCommandList,
uint64_t *dstptr,
ze_event_handle_t hSignalEvent,
@ -74,5 +54,3 @@ zeCommandListAppendWriteGlobalTimestampExt(
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendWriteGlobalTimestamp(dstptr, hSignalEvent, numWaitEvents, phWaitEvents);
}
} // extern "C"

14
level_zero/api/core/ze_cmdqueue.cpp
View File

@ -9,18 +9,8 @@
#include "level_zero/core/source/context/context.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreate(
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue) {
return L0::Device::fromHandle(hDevice)->createCommandQueue(desc, phCommandQueue);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
@ -46,8 +36,6 @@ zeCommandQueueExecuteCommandLists(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueSynchronize(
ze_command_queue_handle_t hCommandQueue,
uint32_t timeout) {
uint64_t timeout) {
return L0::CommandQueue::fromHandle(hCommandQueue)->synchronize(timeout);
}
} // extern "C"

6
level_zero/api/core/ze_context.cpp
View File

@ -9,10 +9,6 @@
#include "level_zero/core/source/driver/driver_handle.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeContextCreate(
ze_driver_handle_t hDriver,
@ -110,5 +106,3 @@ zeVirtualMemGetAccessAttribute(
size_t *outSize) {
return L0::Context::fromHandle(hContext)->getVirtualMemAccessAttribute(ptr, size, access, outSize);
}
} // extern "C"

36
level_zero/api/core/ze_copy.cpp
View File

@ -8,15 +8,15 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListAppendMemoryCopy(
ze_command_list_handle_t hCommandList,
void *dstptr,
const void *srcptr,
size_t size,
ze_event_handle_t hEvent) {
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendMemoryCopy(dstptr, srcptr, size, hEvent, 0, nullptr);
}
@ -27,7 +27,9 @@ zeCommandListAppendMemoryFill(
const void *pattern,
size_t patternSize,
size_t size,
ze_event_handle_t hEvent) {
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendMemoryFill(ptr, pattern, patternSize, size, hEvent);
}
@ -42,7 +44,9 @@ zeCommandListAppendMemoryCopyRegion(
const ze_copy_region_t *srcRegion,
uint32_t srcPitch,
uint32_t srcSlicePitch,
ze_event_handle_t hEvent) {
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendMemoryCopyRegion(dstptr, dstRegion, dstPitch, dstSlicePitch, srcptr, srcRegion, srcPitch, srcSlicePitch, hEvent);
}
@ -51,7 +55,9 @@ zeCommandListAppendImageCopy(
ze_command_list_handle_t hCommandList,
ze_image_handle_t hDstImage,
ze_image_handle_t hSrcImage,
ze_event_handle_t hEvent) {
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopy(hDstImage, hSrcImage, hEvent, 0, nullptr);
}
@ -62,7 +68,9 @@ zeCommandListAppendImageCopyRegion(
ze_image_handle_t hSrcImage,
const ze_image_region_t *pDstRegion,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent) {
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopyRegion(hDstImage, hSrcImage, pDstRegion, pSrcRegion, hEvent, 0, nullptr);
}
@ -72,8 +80,10 @@ zeCommandListAppendImageCopyToMemory(
void *dstptr,
ze_image_handle_t hSrcImage,
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hEvent) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopyToMemory(dstptr, hSrcImage, pSrcRegion, hEvent, 0, nullptr);
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopyToMemory(dstptr, hSrcImage, pSrcRegion, hEvent, numWaitEvents, phWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -82,8 +92,10 @@ zeCommandListAppendImageCopyFromMemory(
ze_image_handle_t hDstImage,
const void *srcptr,
const ze_image_region_t *pDstRegion,
ze_event_handle_t hEvent) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopyFromMemory(hDstImage, srcptr, pDstRegion, hEvent, 0, nullptr);
ze_event_handle_t hEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendImageCopyFromMemory(hDstImage, srcptr, pDstRegion, hEvent, numWaitEvents, phWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -116,5 +128,3 @@ zeCommandListAppendMemoryCopyFromContext(
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendMemoryCopyFromContext(dstptr, hContextSrc, srcptr, size, hSignalEvent, numWaitEvents, phWaitEvents);
}
} // extern "C"

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

@ -11,11 +11,8 @@
#include <level_zero/zet_api.h>
#include <level_zero/zet_ddi.h>
#include "third_party/level_zero/ze_api_ext.h"
#include "ze_ddi_tables.h"
extern "C" {
ze_gpu_driver_dditable_t driver_ddiTable;
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -31,23 +28,14 @@ zeGetDriverProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGet = (ze_pfnDriverGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGet");
pDdiTable->pfnGetApiVersion = (ze_pfnDriverGetApiVersion_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetApiVersion");
pDdiTable->pfnGetProperties = (ze_pfnDriverGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetProperties");
pDdiTable->pfnGetIPCProperties = (ze_pfnDriverGetIPCProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetIPCProperties");
pDdiTable->pfnGetExtensionFunctionAddress = (ze_pfnDriverGetExtensionFunctionAddress_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetExtensionFunctionAddress");
pDdiTable->pfnAllocSharedMem = (ze_pfnDriverAllocSharedMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocSharedMem");
pDdiTable->pfnAllocDeviceMem = (ze_pfnDriverAllocDeviceMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocDeviceMem");
pDdiTable->pfnAllocHostMem = (ze_pfnDriverAllocHostMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocHostMem");
pDdiTable->pfnFreeMem = (ze_pfnDriverFreeMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverFreeMem");
pDdiTable->pfnGetMemAllocProperties = (ze_pfnDriverGetMemAllocProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemAllocProperties");
pDdiTable->pfnGetMemAddressRange = (ze_pfnDriverGetMemAddressRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemAddressRange");
pDdiTable->pfnGetMemIpcHandle = (ze_pfnDriverGetMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemIpcHandle");
pDdiTable->pfnOpenMemIpcHandle = (ze_pfnDriverOpenMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverOpenMemIpcHandle");
pDdiTable->pfnCloseMemIpcHandle = (ze_pfnDriverCloseMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverCloseMemIpcHandle");
pDdiTable->pfnGetIpcProperties = (ze_pfnDriverGetIpcProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetIpcProperties");
pDdiTable->pfnGetExtensionProperties = (ze_pfnDriverGetExtensionProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetExtensionFunctionAddress");
driver_ddiTable.core_ddiTable.Driver = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnGet = (ze_pfnDriverGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGet_Tracing");
@ -62,49 +50,234 @@ zeGetDriverProcAddrTable(
if (nullptr == pDdiTable->pfnGetProperties) {
pDdiTable->pfnGetProperties = driver_ddiTable.core_ddiTable.Driver.pfnGetProperties;
}
pDdiTable->pfnGetIPCProperties = (ze_pfnDriverGetIPCProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetIPCProperties_Tracing");
if (nullptr == pDdiTable->pfnGetIPCProperties) {
pDdiTable->pfnGetIPCProperties = driver_ddiTable.core_ddiTable.Driver.pfnGetIPCProperties;
pDdiTable->pfnGetIpcProperties = (ze_pfnDriverGetIpcProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetIPCProperties_Tracing");
if (nullptr == pDdiTable->pfnGetIpcProperties) {
pDdiTable->pfnGetIpcProperties = driver_ddiTable.core_ddiTable.Driver.pfnGetIpcProperties;
}
pDdiTable->pfnGetExtensionFunctionAddress = (ze_pfnDriverGetExtensionFunctionAddress_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetExtensionFunctionAddress_Tracing");
if (nullptr == pDdiTable->pfnGetExtensionFunctionAddress) {
pDdiTable->pfnGetExtensionFunctionAddress = driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionFunctionAddress;
pDdiTable->pfnGetExtensionProperties = (ze_pfnDriverGetExtensionProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetExtensionFunctionAddress_Tracing");
if (nullptr == pDdiTable->pfnGetExtensionProperties) {
pDdiTable->pfnGetExtensionProperties = driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionProperties;
}
pDdiTable->pfnAllocSharedMem = (ze_pfnDriverAllocSharedMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocSharedMem_Tracing");
if (nullptr == pDdiTable->pfnAllocSharedMem) {
pDdiTable->pfnAllocSharedMem = driver_ddiTable.core_ddiTable.Driver.pfnAllocSharedMem;
}
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zeGetMemProcAddrTable(
ze_api_version_t version,
ze_mem_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
driver_ddiTable.driverLibrary = LOAD_INTEL_GPU_LIBRARY();
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
pDdiTable->pfnAllocDeviceMem = (ze_pfnDriverAllocDeviceMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocDeviceMem_Tracing");
if (nullptr == pDdiTable->pfnAllocDeviceMem) {
pDdiTable->pfnAllocDeviceMem = driver_ddiTable.core_ddiTable.Driver.pfnAllocDeviceMem;
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAllocShared = (ze_pfnMemAllocShared_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocShared");
pDdiTable->pfnAllocDevice = (ze_pfnMemAllocDevice_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocDevice");
pDdiTable->pfnAllocHost = (ze_pfnMemAllocHost_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocHost");
pDdiTable->pfnFree = (ze_pfnMemFree_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemFree");
pDdiTable->pfnGetAllocProperties = (ze_pfnMemGetAllocProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetAllocProperties");
pDdiTable->pfnGetAddressRange = (ze_pfnMemGetAddressRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetAddressRange");
pDdiTable->pfnGetIpcHandle = (ze_pfnMemGetIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetIpcHandle");
pDdiTable->pfnOpenIpcHandle = (ze_pfnMemOpenIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemOpenIpcHandle");
pDdiTable->pfnCloseIpcHandle = (ze_pfnMemCloseIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemCloseIpcHandle");
driver_ddiTable.core_ddiTable.Mem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnAllocShared = (ze_pfnMemAllocShared_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocShared_Tracing");
if (nullptr == pDdiTable->pfnAllocShared) {
pDdiTable->pfnAllocShared = driver_ddiTable.core_ddiTable.Mem.pfnAllocShared;
}
pDdiTable->pfnAllocHostMem = (ze_pfnDriverAllocHostMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverAllocHostMem_Tracing");
if (nullptr == pDdiTable->pfnAllocHostMem) {
pDdiTable->pfnAllocHostMem = driver_ddiTable.core_ddiTable.Driver.pfnAllocHostMem;
pDdiTable->pfnAllocDevice = (ze_pfnMemAllocDevice_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocDevice_Tracing");
if (nullptr == pDdiTable->pfnAllocDevice) {
pDdiTable->pfnAllocDevice = driver_ddiTable.core_ddiTable.Mem.pfnAllocDevice;
}
pDdiTable->pfnFreeMem = (ze_pfnDriverFreeMem_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverFreeMem_Tracing");
if (nullptr == pDdiTable->pfnFreeMem) {
pDdiTable->pfnFreeMem = driver_ddiTable.core_ddiTable.Driver.pfnFreeMem;
pDdiTable->pfnAllocHost = (ze_pfnMemAllocHost_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemAllocHost_Tracing");
if (nullptr == pDdiTable->pfnAllocHost) {
pDdiTable->pfnAllocHost = driver_ddiTable.core_ddiTable.Mem.pfnAllocHost;
}
pDdiTable->pfnGetMemAllocProperties = (ze_pfnDriverGetMemAllocProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemAllocProperties_Tracing");
if (nullptr == pDdiTable->pfnGetMemAllocProperties) {
pDdiTable->pfnGetMemAllocProperties = driver_ddiTable.core_ddiTable.Driver.pfnGetMemAllocProperties;
pDdiTable->pfnFree = (ze_pfnMemFree_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemFree_Tracing");
if (nullptr == pDdiTable->pfnAllocHost) {
pDdiTable->pfnAllocHost = driver_ddiTable.core_ddiTable.Mem.pfnAllocHost;
}
pDdiTable->pfnGetMemAddressRange = (ze_pfnDriverGetMemAddressRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemAddressRange_Tracing");
if (nullptr == pDdiTable->pfnGetMemAddressRange) {
pDdiTable->pfnGetMemAddressRange = driver_ddiTable.core_ddiTable.Driver.pfnGetMemAddressRange;
pDdiTable->pfnGetAllocProperties = (ze_pfnMemGetAllocProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetAllocProperties_Tracing");
if (nullptr == pDdiTable->pfnGetAllocProperties) {
pDdiTable->pfnGetAllocProperties = driver_ddiTable.core_ddiTable.Mem.pfnGetAllocProperties;
}
pDdiTable->pfnGetMemIpcHandle = (ze_pfnDriverGetMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverGetMemIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnGetMemIpcHandle) {
pDdiTable->pfnGetMemIpcHandle = driver_ddiTable.core_ddiTable.Driver.pfnGetMemIpcHandle;
pDdiTable->pfnGetAddressRange = (ze_pfnMemGetAddressRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetAddressRange_Tracing");
if (nullptr == pDdiTable->pfnGetAddressRange) {
pDdiTable->pfnGetAddressRange = driver_ddiTable.core_ddiTable.Mem.pfnGetAddressRange;
}
pDdiTable->pfnOpenMemIpcHandle = (ze_pfnDriverOpenMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverOpenMemIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnOpenMemIpcHandle) {
pDdiTable->pfnOpenMemIpcHandle = driver_ddiTable.core_ddiTable.Driver.pfnOpenMemIpcHandle;
pDdiTable->pfnGetIpcHandle = (ze_pfnMemGetIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemGetIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnGetIpcHandle) {
pDdiTable->pfnGetIpcHandle = driver_ddiTable.core_ddiTable.Mem.pfnGetIpcHandle;
}
pDdiTable->pfnCloseMemIpcHandle = (ze_pfnDriverCloseMemIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDriverCloseMemIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnCloseMemIpcHandle) {
pDdiTable->pfnCloseMemIpcHandle = driver_ddiTable.core_ddiTable.Driver.pfnCloseMemIpcHandle;
pDdiTable->pfnOpenIpcHandle = (ze_pfnMemOpenIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemOpenIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnOpenIpcHandle) {
pDdiTable->pfnOpenIpcHandle = driver_ddiTable.core_ddiTable.Mem.pfnOpenIpcHandle;
}
pDdiTable->pfnCloseIpcHandle = (ze_pfnMemCloseIpcHandle_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeMemCloseIpcHandle_Tracing");
if (nullptr == pDdiTable->pfnCloseIpcHandle) {
pDdiTable->pfnCloseIpcHandle = driver_ddiTable.core_ddiTable.Mem.pfnCloseIpcHandle;
}
}
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zeGetContextProcAddrTable(
ze_api_version_t version,
ze_context_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
driver_ddiTable.driverLibrary = LOAD_INTEL_GPU_LIBRARY();
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnContextCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextCreate");
pDdiTable->pfnDestroy = (ze_pfnContextDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextDestroy");
pDdiTable->pfnGetStatus = (ze_pfnContextGetStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextGetStatus");
pDdiTable->pfnSystemBarrier = (ze_pfnContextSystemBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextSystemBarrier");
pDdiTable->pfnMakeMemoryResident = (ze_pfnContextMakeMemoryResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextMakeMemoryResident");
pDdiTable->pfnEvictMemory = (ze_pfnContextEvictMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextEvictMemory");
pDdiTable->pfnMakeImageResident = (ze_pfnContextMakeImageResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextMakeImageResident");
pDdiTable->pfnEvictImage = (ze_pfnContextEvictImage_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextEvictImage");
driver_ddiTable.core_ddiTable.Context = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = (ze_pfnContextCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextCreate_Tracing");
if (nullptr == pDdiTable->pfnCreate) {
pDdiTable->pfnCreate = driver_ddiTable.core_ddiTable.Context.pfnCreate;
}
pDdiTable->pfnDestroy = (ze_pfnContextDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextDestroy_Tracing");
if (nullptr == pDdiTable->pfnDestroy) {
pDdiTable->pfnDestroy = driver_ddiTable.core_ddiTable.Context.pfnDestroy;
}
pDdiTable->pfnGetStatus = (ze_pfnContextGetStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextGetStatus_Tracing");
if (nullptr == pDdiTable->pfnGetStatus) {
pDdiTable->pfnGetStatus = driver_ddiTable.core_ddiTable.Context.pfnGetStatus;
}
pDdiTable->pfnSystemBarrier = (ze_pfnContextSystemBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextSystemBarrier_Tracing");
if (nullptr == pDdiTable->pfnSystemBarrier) {
pDdiTable->pfnSystemBarrier = driver_ddiTable.core_ddiTable.Context.pfnSystemBarrier;
}
pDdiTable->pfnMakeMemoryResident = (ze_pfnContextMakeMemoryResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextMakeMemoryResident_Tracing");
if (nullptr == pDdiTable->pfnMakeMemoryResident) {
pDdiTable->pfnMakeMemoryResident = driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident;
}
pDdiTable->pfnEvictMemory = (ze_pfnContextEvictMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextEvictMemory_Tracing");
if (nullptr == pDdiTable->pfnEvictMemory) {
pDdiTable->pfnEvictMemory = driver_ddiTable.core_ddiTable.Context.pfnEvictMemory;
}
pDdiTable->pfnMakeImageResident = (ze_pfnContextMakeImageResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextMakeImageResident_Tracing");
if (nullptr == pDdiTable->pfnMakeImageResident) {
pDdiTable->pfnMakeImageResident = driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident;
}
pDdiTable->pfnEvictImage = (ze_pfnContextEvictImage_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeContextEvictImage_Tracing");
if (nullptr == pDdiTable->pfnEvictImage) {
pDdiTable->pfnEvictImage = driver_ddiTable.core_ddiTable.Context.pfnEvictImage;
}
}
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zeGetPhysicalMemProcAddrTable(
ze_api_version_t version,
ze_physical_mem_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
driver_ddiTable.driverLibrary = LOAD_INTEL_GPU_LIBRARY();
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnPhysicalMemCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zePhysicalMemCreate");
pDdiTable->pfnDestroy = (ze_pfnPhysicalMemDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zePhysicalMemDestory");
driver_ddiTable.core_ddiTable.PhysicalMem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = (ze_pfnPhysicalMemCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zePhysicalMemCreate");
if (nullptr == pDdiTable->pfnCreate) {
pDdiTable->pfnCreate = driver_ddiTable.core_ddiTable.PhysicalMem.pfnCreate;
}
pDdiTable->pfnDestroy = (ze_pfnPhysicalMemDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zePhysicalMemDestory");
if (nullptr == pDdiTable->pfnDestroy) {
pDdiTable->pfnDestroy = driver_ddiTable.core_ddiTable.PhysicalMem.pfnDestroy;
}
}
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zeGetVirtualMemProcAddrTable(
ze_api_version_t version,
ze_virtual_mem_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
driver_ddiTable.driverLibrary = LOAD_INTEL_GPU_LIBRARY();
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnReserve = (ze_pfnVirtualMemReserve_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemReserve");
pDdiTable->pfnFree = (ze_pfnVirtualMemFree_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemFree");
pDdiTable->pfnQueryPageSize = (ze_pfnVirtualMemQueryPageSize_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemQueryPageSize");
pDdiTable->pfnMap = (ze_pfnVirtualMemMap_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemMap ");
pDdiTable->pfnUnmap = (ze_pfnVirtualMemUnmap_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemUnmap ");
pDdiTable->pfnSetAccessAttribute = (ze_pfnVirtualMemSetAccessAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemSetAccessAttribute");
pDdiTable->pfnGetAccessAttribute = (ze_pfnVirtualMemGetAccessAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemGetAccessAttribute");
driver_ddiTable.core_ddiTable.VirtualMem = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnReserve = (ze_pfnVirtualMemReserve_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemReserve_Tracing");
if (nullptr == pDdiTable->pfnReserve) {
pDdiTable->pfnReserve = driver_ddiTable.core_ddiTable.VirtualMem.pfnReserve;
}
pDdiTable->pfnFree = (ze_pfnVirtualMemFree_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemFree_Tracing");
if (nullptr == pDdiTable->pfnFree) {
pDdiTable->pfnFree = driver_ddiTable.core_ddiTable.VirtualMem.pfnFree;
}
pDdiTable->pfnQueryPageSize = (ze_pfnVirtualMemQueryPageSize_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemQueryPageSize_Tracing");
if (nullptr == pDdiTable->pfnQueryPageSize) {
pDdiTable->pfnQueryPageSize = driver_ddiTable.core_ddiTable.VirtualMem.pfnQueryPageSize;
}
pDdiTable->pfnMap = (ze_pfnVirtualMemMap_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemMap_Tracing");
if (nullptr == pDdiTable->pfnMap) {
pDdiTable->pfnMap = driver_ddiTable.core_ddiTable.VirtualMem.pfnMap;
}
pDdiTable->pfnUnmap = (ze_pfnVirtualMemUnmap_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemUnmap_Tracing");
if (nullptr == pDdiTable->pfnUnmap) {
pDdiTable->pfnUnmap = driver_ddiTable.core_ddiTable.VirtualMem.pfnUnmap;
}
pDdiTable->pfnSetAccessAttribute = (ze_pfnVirtualMemSetAccessAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemSetAccessAttribute_Tracing");
if (nullptr == pDdiTable->pfnSetAccessAttribute) {
pDdiTable->pfnSetAccessAttribute = driver_ddiTable.core_ddiTable.VirtualMem.pfnSetAccessAttribute;
}
pDdiTable->pfnGetAccessAttribute = (ze_pfnVirtualMemGetAccessAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeVirtualMemGetAccessAttribute_Tracing");
if (nullptr == pDdiTable->pfnGetAccessAttribute) {
pDdiTable->pfnGetAccessAttribute = driver_ddiTable.core_ddiTable.VirtualMem.pfnGetAccessAttribute;
}
}
return result;
@ -123,7 +296,7 @@ zeGetGlobalProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnInit = (ze_pfnInit_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeInit");
@ -150,35 +323,32 @@ zeGetDeviceProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGet = (ze_pfnDeviceGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGet");
pDdiTable->pfnGetCommandQueueGroupProperties = (ze_pfnDeviceGetCommandQueueGroupProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetCommandQueueGroupProperties");
pDdiTable->pfnGetSubDevices = (ze_pfnDeviceGetSubDevices_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetSubDevices");
pDdiTable->pfnGetProperties = (ze_pfnDeviceGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetProperties");
pDdiTable->pfnSystemBarrier = (ze_pfnDeviceSystemBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceSystemBarrier");
pDdiTable->pfnRegisterCLMemory = (ze_pfnDeviceRegisterCLMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLMemory");
pDdiTable->pfnRegisterCLProgram = (ze_pfnDeviceRegisterCLProgram_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLProgram");
pDdiTable->pfnRegisterCLCommandQueue = (ze_pfnDeviceRegisterCLCommandQueue_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLCommandQueue");
pDdiTable->pfnGetComputeProperties = (ze_pfnDeviceGetComputeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetComputeProperties");
pDdiTable->pfnGetKernelProperties = (ze_pfnDeviceGetKernelProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetKernelProperties");
pDdiTable->pfnGetModuleProperties = (ze_pfnDeviceGetModuleProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetKernelProperties");
pDdiTable->pfnGetMemoryProperties = (ze_pfnDeviceGetMemoryProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetMemoryProperties");
pDdiTable->pfnGetMemoryAccessProperties = (ze_pfnDeviceGetMemoryAccessProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetMemoryAccessProperties");
pDdiTable->pfnGetCacheProperties = (ze_pfnDeviceGetCacheProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetCacheProperties");
pDdiTable->pfnGetImageProperties = (ze_pfnDeviceGetImageProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetImageProperties");
pDdiTable->pfnGetP2PProperties = (ze_pfnDeviceGetP2PProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetP2PProperties");
pDdiTable->pfnCanAccessPeer = (ze_pfnDeviceCanAccessPeer_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceCanAccessPeer");
pDdiTable->pfnSetLastLevelCacheConfig = (ze_pfnDeviceSetLastLevelCacheConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceSetLastLevelCacheConfig");
pDdiTable->pfnMakeMemoryResident = (ze_pfnDeviceMakeMemoryResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceMakeMemoryResident");
pDdiTable->pfnEvictMemory = (ze_pfnDeviceEvictMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceEvictMemory");
pDdiTable->pfnMakeImageResident = (ze_pfnDeviceMakeImageResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceMakeImageResident");
pDdiTable->pfnEvictImage = (ze_pfnDeviceEvictImage_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceEvictImage");
pDdiTable->pfnGetStatus = (ze_pfnDeviceGetStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetStatus");
driver_ddiTable.core_ddiTable.Device = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnGet = (ze_pfnDeviceGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGet_Tracing");
if (nullptr == pDdiTable->pfnGet) {
pDdiTable->pfnGet = driver_ddiTable.core_ddiTable.Device.pfnGet;
}
pDdiTable->pfnGetCommandQueueGroupProperties = (ze_pfnDeviceGetCommandQueueGroupProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetCommandQueueGroupProperties_Tracing");
if (nullptr == pDdiTable->pfnGetCommandQueueGroupProperties) {
pDdiTable->pfnGetCommandQueueGroupProperties = driver_ddiTable.core_ddiTable.Device.pfnGetCommandQueueGroupProperties;
}
pDdiTable->pfnGetSubDevices = (ze_pfnDeviceGetSubDevices_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetSubDevices_Tracing");
if (nullptr == pDdiTable->pfnGetSubDevices) {
pDdiTable->pfnGetSubDevices = driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices;
@ -187,29 +357,13 @@ zeGetDeviceProcAddrTable(
if (nullptr == pDdiTable->pfnGetProperties) {
pDdiTable->pfnGetProperties = driver_ddiTable.core_ddiTable.Device.pfnGetProperties;
}
pDdiTable->pfnSystemBarrier = (ze_pfnDeviceSystemBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceSystemBarrier_Tracing");
if (nullptr == pDdiTable->pfnSystemBarrier) {
pDdiTable->pfnSystemBarrier = driver_ddiTable.core_ddiTable.Device.pfnSystemBarrier;
}
pDdiTable->pfnRegisterCLMemory = (ze_pfnDeviceRegisterCLMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLMemory_Tracing");
if (nullptr == pDdiTable->pfnRegisterCLMemory) {
pDdiTable->pfnRegisterCLMemory = driver_ddiTable.core_ddiTable.Device.pfnRegisterCLMemory;
}
pDdiTable->pfnRegisterCLProgram = (ze_pfnDeviceRegisterCLProgram_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLProgram_Tracing");
if (nullptr == pDdiTable->pfnRegisterCLProgram) {
pDdiTable->pfnRegisterCLProgram = driver_ddiTable.core_ddiTable.Device.pfnRegisterCLProgram;
}
pDdiTable->pfnRegisterCLCommandQueue = (ze_pfnDeviceRegisterCLCommandQueue_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceRegisterCLCommandQueue_Tracing");
if (nullptr == pDdiTable->pfnRegisterCLCommandQueue) {
pDdiTable->pfnRegisterCLCommandQueue = driver_ddiTable.core_ddiTable.Device.pfnRegisterCLCommandQueue;
}
pDdiTable->pfnGetComputeProperties = (ze_pfnDeviceGetComputeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetComputeProperties_Tracing");
if (nullptr == pDdiTable->pfnGetComputeProperties) {
pDdiTable->pfnGetComputeProperties = driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties;
}
pDdiTable->pfnGetKernelProperties = (ze_pfnDeviceGetKernelProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetKernelProperties_Tracing");
if (nullptr == pDdiTable->pfnGetKernelProperties) {
pDdiTable->pfnGetKernelProperties = driver_ddiTable.core_ddiTable.Device.pfnGetKernelProperties;
pDdiTable->pfnGetModuleProperties = (ze_pfnDeviceGetModuleProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetKernelProperties_Tracing");
if (nullptr == pDdiTable->pfnGetModuleProperties) {
pDdiTable->pfnGetModuleProperties = driver_ddiTable.core_ddiTable.Device.pfnGetModuleProperties;
}
pDdiTable->pfnGetMemoryProperties = (ze_pfnDeviceGetMemoryProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetMemoryProperties_Tracing");
if (nullptr == pDdiTable->pfnGetMemoryProperties) {
@ -235,25 +389,9 @@ zeGetDeviceProcAddrTable(
if (nullptr == pDdiTable->pfnCanAccessPeer) {
pDdiTable->pfnCanAccessPeer = driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer;
}
pDdiTable->pfnSetLastLevelCacheConfig = (ze_pfnDeviceSetLastLevelCacheConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceSetLastLevelCacheConfig_Tracing");
if (nullptr == pDdiTable->pfnSetLastLevelCacheConfig) {
pDdiTable->pfnSetLastLevelCacheConfig = driver_ddiTable.core_ddiTable.Device.pfnSetLastLevelCacheConfig;
}
pDdiTable->pfnMakeMemoryResident = (ze_pfnDeviceMakeMemoryResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceMakeMemoryResident_Tracing");
if (nullptr == pDdiTable->pfnMakeMemoryResident) {
pDdiTable->pfnMakeMemoryResident = driver_ddiTable.core_ddiTable.Device.pfnMakeMemoryResident;
}
pDdiTable->pfnEvictMemory = (ze_pfnDeviceEvictMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceEvictMemory_Tracing");
if (nullptr == pDdiTable->pfnEvictMemory) {
pDdiTable->pfnEvictMemory = driver_ddiTable.core_ddiTable.Device.pfnEvictMemory;
}
pDdiTable->pfnMakeImageResident = (ze_pfnDeviceMakeImageResident_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceMakeImageResident_Tracing");
if (nullptr == pDdiTable->pfnMakeImageResident) {
pDdiTable->pfnMakeImageResident = driver_ddiTable.core_ddiTable.Device.pfnMakeImageResident;
}
pDdiTable->pfnEvictImage = (ze_pfnDeviceEvictImage_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceEvictImage_Tracing");
if (nullptr == pDdiTable->pfnEvictImage) {
pDdiTable->pfnEvictImage = driver_ddiTable.core_ddiTable.Device.pfnEvictImage;
pDdiTable->pfnGetStatus = (ze_pfnDeviceGetStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeDeviceGetStatus_Tracing");
if (nullptr == pDdiTable->pfnGetStatus) {
pDdiTable->pfnGetStatus = driver_ddiTable.core_ddiTable.Device.pfnGetStatus;
}
}
return result;
@ -272,7 +410,7 @@ zeGetCommandQueueProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnCommandQueueCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeCommandQueueCreate");
@ -314,7 +452,7 @@ zeGetCommandListProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAppendBarrier = (ze_pfnCommandListAppendBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeCommandListAppendBarrier");
@ -451,7 +589,7 @@ zeGetFenceProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnFenceCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeFenceCreate");
@ -498,7 +636,7 @@ zeGetEventPoolProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnEventPoolCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventPoolCreate");
@ -545,7 +683,7 @@ zeGetEventProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnEventCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventCreate");
@ -554,7 +692,6 @@ zeGetEventProcAddrTable(
pDdiTable->pfnHostSynchronize = (ze_pfnEventHostSynchronize_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventHostSynchronize");
pDdiTable->pfnQueryStatus = (ze_pfnEventQueryStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventQueryStatus");
pDdiTable->pfnHostReset = (ze_pfnEventHostReset_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventHostReset");
pDdiTable->pfnGetTimestamp = (ze_pfnEventGetTimestamp_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventGetTimestamp");
driver_ddiTable.core_ddiTable.Event = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnCreate = (ze_pfnEventCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventCreate_Tracing");
@ -581,10 +718,6 @@ zeGetEventProcAddrTable(
if (nullptr == pDdiTable->pfnHostReset) {
pDdiTable->pfnHostReset = driver_ddiTable.core_ddiTable.Event.pfnHostReset;
}
pDdiTable->pfnGetTimestamp = (ze_pfnEventGetTimestamp_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeEventGetTimestamp_Tracing");
if (nullptr == pDdiTable->pfnGetTimestamp) {
pDdiTable->pfnGetTimestamp = driver_ddiTable.core_ddiTable.Event.pfnGetTimestamp;
}
}
return result;
}
@ -602,7 +735,7 @@ zeGetImageProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (ze_pfnImageGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeImageGetProperties");
@ -639,7 +772,7 @@ zeGetModuleProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnModuleCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeModuleCreate");
@ -691,7 +824,7 @@ zeGetModuleBuildLogProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnDestroy = (ze_pfnModuleBuildLogDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeModuleBuildLogDestroy");
@ -723,25 +856,21 @@ zeGetKernelProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnSetIntermediateCacheConfig = (ze_pfnKernelSetIntermediateCacheConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetIntermediateCacheConfig");
pDdiTable->pfnCreate = (ze_pfnKernelCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelCreate");
pDdiTable->pfnDestroy = (ze_pfnKernelDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelDestroy");
pDdiTable->pfnSetGroupSize = (ze_pfnKernelSetGroupSize_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetGroupSize");
pDdiTable->pfnSuggestGroupSize = (ze_pfnKernelSuggestGroupSize_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSuggestGroupSize");
pDdiTable->pfnSuggestMaxCooperativeGroupCount = (ze_pfnKernelSuggestMaxCooperativeGroupCount_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSuggestMaxCooperativeGroupCount");
pDdiTable->pfnSetArgumentValue = (ze_pfnKernelSetArgumentValue_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetArgumentValue");
pDdiTable->pfnSetAttribute = (ze_pfnKernelSetAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetAttribute");
pDdiTable->pfnGetAttribute = (ze_pfnKernelGetAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetAttribute");
pDdiTable->pfnSetIndirectAccess = (ze_pfnKernelSetIndirectAccess_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetIndirectAccess");
pDdiTable->pfnGetIndirectAccess = (ze_pfnKernelGetIndirectAccess_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetIndirectAccess");
pDdiTable->pfnGetSourceAttributes = (ze_pfnKernelGetSourceAttributes_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetAttribute");
pDdiTable->pfnGetProperties = (ze_pfnKernelGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetProperties");
driver_ddiTable.core_ddiTable.Kernel = *pDdiTable;
if (driver_ddiTable.enableTracing) {
pDdiTable->pfnSetIntermediateCacheConfig = (ze_pfnKernelSetIntermediateCacheConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetIntermediateCacheConfig_Tracing");
if (nullptr == pDdiTable->pfnSetIntermediateCacheConfig) {
pDdiTable->pfnSetIntermediateCacheConfig = driver_ddiTable.core_ddiTable.Kernel.pfnSetIntermediateCacheConfig;
}
pDdiTable->pfnCreate = (ze_pfnKernelCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelCreate_Tracing");
if (nullptr == pDdiTable->pfnCreate) {
pDdiTable->pfnCreate = driver_ddiTable.core_ddiTable.Kernel.pfnCreate;
@ -766,13 +895,17 @@ zeGetKernelProcAddrTable(
if (nullptr == pDdiTable->pfnSetArgumentValue) {
pDdiTable->pfnSetArgumentValue = driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue;
}
pDdiTable->pfnSetAttribute = (ze_pfnKernelSetAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetAttribute_Tracing");
if (nullptr == pDdiTable->pfnSetAttribute) {
pDdiTable->pfnSetAttribute = driver_ddiTable.core_ddiTable.Kernel.pfnSetAttribute;
pDdiTable->pfnSetIndirectAccess = (ze_pfnKernelSetIndirectAccess_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelSetIndirectAccess_Tracing");
if (nullptr == pDdiTable->pfnSetIndirectAccess) {
pDdiTable->pfnSetIndirectAccess = driver_ddiTable.core_ddiTable.Kernel.pfnSetIndirectAccess;
}
pDdiTable->pfnGetAttribute = (ze_pfnKernelGetAttribute_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetAttribute_Tracing");
if (nullptr == pDdiTable->pfnGetAttribute) {
pDdiTable->pfnGetAttribute = driver_ddiTable.core_ddiTable.Kernel.pfnGetAttribute;
pDdiTable->pfnGetIndirectAccess = (ze_pfnKernelGetIndirectAccess_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetIndirectAccess_Tracing");
if (nullptr == pDdiTable->pfnGetIndirectAccess) {
pDdiTable->pfnGetIndirectAccess = driver_ddiTable.core_ddiTable.Kernel.pfnGetIndirectAccess;
}
pDdiTable->pfnGetSourceAttributes = (ze_pfnKernelGetSourceAttributes_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetAttribute_Tracing");
if (nullptr == pDdiTable->pfnGetSourceAttributes) {
pDdiTable->pfnGetSourceAttributes = driver_ddiTable.core_ddiTable.Kernel.pfnGetSourceAttributes;
}
pDdiTable->pfnGetProperties = (ze_pfnKernelGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeKernelGetProperties_Tracing");
if (nullptr == pDdiTable->pfnGetProperties) {
@ -795,7 +928,7 @@ zeGetSamplerProcAddrTable(
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
driver_ddiTable.enableTracing = getenv_tobool("ZE_ENABLE_API_TRACING");
driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (ze_pfnSamplerCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zeSamplerCreate");
@ -813,5 +946,3 @@ zeGetSamplerProcAddrTable(
}
return result;
}
} // extern "C"

9
level_zero/api/core/ze_device.cpp
View File

@ -11,8 +11,6 @@
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGet(
ze_driver_handle_t hDriver,
@ -46,7 +44,7 @@ zeDeviceGetComputeProperties(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetKernelProperties(
ze_device_handle_t hDevice,
ze_device_kernel_properties_t *pKernelProperties) {
ze_device_module_properties_t *pKernelProperties) {
return L0::Device::fromHandle(hDevice)->getKernelProperties(pKernelProperties);
}
@ -68,6 +66,7 @@ zeDeviceGetMemoryAccessProperties(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceGetCacheProperties(
ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties) {
return L0::Device::fromHandle(hDevice)->getCacheProperties(pCacheProperties);
}
@ -98,7 +97,7 @@ zeDeviceCanAccessPeer(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceSetLastLevelCacheConfig(
ze_device_handle_t hDevice,
ze_cache_config_t cacheConfig) {
ze_cache_config_flags_t cacheConfig) {
return L0::Device::fromHandle(hDevice)->setLastLevelCacheConfig(cacheConfig);
}
@ -109,5 +108,3 @@ zeDeviceGetCommandQueueGroupProperties(
ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {
return L0::Device::fromHandle(hDevice)->getCommandQueueGroupProperties(pCount, pCommandQueueGroupProperties);
}
} // extern "C"

8
level_zero/api/core/ze_driver.cpp
View File

@ -9,11 +9,9 @@
#include "level_zero/core/source/driver/driver_handle.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeInit(
ze_init_flag_t flags) {
ze_init_flags_t flags) {
return L0::init(flags);
}
@ -39,7 +37,7 @@ zeDriverGetApiVersion(
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetIPCProperties(
zeDriverGetIpcProperties(
ze_driver_handle_t hDriver,
ze_driver_ipc_properties_t *pIPCProperties) {
return L0::DriverHandle::fromHandle(hDriver)->getIPCProperties(pIPCProperties);
@ -60,5 +58,3 @@ zeDriverGetExtensionProperties(
ze_driver_extension_properties_t *pExtensionProperties) {
return L0::DriverHandle::fromHandle(hDriver)->getExtensionProperties(pCount, pExtensionProperties);
}
} // extern "C"

27
level_zero/api/core/ze_event.cpp
View File

@ -8,16 +8,14 @@
#include "level_zero/core/source/event/event.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolCreate(
ze_driver_handle_t hDriver,
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) {
return L0::DriverHandle::fromHandle(hDriver)->createEventPool(desc, numDevices, phDevices, phEventPool);
return L0::Context::fromHandle(hContext)->createEventPool(desc, numDevices, phDevices, phEventPool);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -49,10 +47,10 @@ zeEventPoolGetIpcHandle(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventPoolOpenIpcHandle(
ze_driver_handle_t hDriver,
ze_context_handle_t hContext,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) {
return L0::DriverHandle::fromHandle(hDriver)->openEventPoolIpcHandle(hIpc, phEventPool);
return L0::Context::fromHandle(hContext)->openEventPoolIpcHandle(hIpc, phEventPool);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -85,7 +83,7 @@ zeEventHostSignal(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventHostSynchronize(
ze_event_handle_t hEvent,
uint32_t timeout) {
uint64_t timeout) {
return L0::Event::fromHandle(hEvent)->hostSynchronize(timeout);
}
@ -109,17 +107,8 @@ zeEventHostReset(
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventGetTimestamp(
zeEventQueryKernelTimestamp(
ze_event_handle_t hEvent,
ze_event_timestamp_type_t timestampType,
void *dstptr) {
return L0::Event::fromHandle(hEvent)->getTimestamp(timestampType, dstptr);
ze_kernel_timestamp_result_t *timestampType) {
return L0::Event::fromHandle(hEvent)->queryKernelTimestamp(timestampType);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeEventQueryKernelTimestampExt(
ze_event_handle_t hEvent,
ze_kernel_timestamp_result_t *dstptr) {
return L0::Event::fromHandle(hEvent)->queryKernelTimestamp(dstptr);
}
} // extern "C"

6
level_zero/api/core/ze_fence.cpp
View File

@ -8,8 +8,6 @@
#include "level_zero/core/source/fence/fence.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceCreate(
ze_command_queue_handle_t hCommandQueue,
@ -27,7 +25,7 @@ zeFenceDestroy(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeFenceHostSynchronize(
ze_fence_handle_t hFence,
uint32_t timeout) {
uint64_t timeout) {
return L0::Fence::fromHandle(hFence)->hostSynchronize(timeout);
}
@ -42,5 +40,3 @@ zeFenceReset(
ze_fence_handle_t hFence) {
return L0::Fence::fromHandle(hFence)->reset();
}
} // extern "C"

7
level_zero/api/core/ze_image.cpp
View File

@ -8,8 +8,6 @@
#include "level_zero/core/source/image/image.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageGetProperties(
ze_device_handle_t hDevice,
@ -20,10 +18,11 @@ zeImageGetProperties(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeImageCreate(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) {
return L0::Device::fromHandle(hDevice)->createImage(desc, phImage);
return L0::Context::fromHandle(hContext)->createImage(hDevice, desc, phImage);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -31,5 +30,3 @@ zeImageDestroy(
ze_image_handle_t hImage) {
return L0::Image::fromHandle(hImage)->destroy();
}
} // extern "C"

103
level_zero/api/core/ze_memory.cpp
View File

@ -8,93 +8,46 @@
#include "level_zero/core/source/driver/driver_handle.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverAllocSharedMem(
ze_driver_handle_t hDriver,
zeMemAllocShared(
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) {
return L0::DriverHandle::fromHandle(hDriver)->allocSharedMem(hDevice, deviceDesc->flags, hostDesc->flags, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocShared(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) {
return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc->flags, hostDesc->flags, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverAllocDeviceMem(
ze_driver_handle_t hDriver,
zeMemAllocDevice(
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) {
return L0::DriverHandle::fromHandle(hDriver)->allocDeviceMem(hDevice, deviceDesc->flags, size, alignment, pptr);
return L0::Context::fromHandle(hContext)->allocDeviceMem(hDevice, 0, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocDevice(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) {
return L0::Context::fromHandle(hContext)->allocDeviceMem(hDevice, deviceDesc->flags, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverAllocHostMem(
ze_driver_handle_t hDriver,
zeMemAllocHost(
ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr) {
return L0::DriverHandle::fromHandle(hDriver)->allocHostMem(hostDesc->flags, size, alignment, pptr);
return L0::Context::fromHandle(hContext)->allocHostMem(0, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemAllocHost(ze_context_handle_t hContext,
const ze_host_mem_alloc_desc_t *hostDesc,
size_t size,
size_t alignment,
void **pptr) {
return L0::Context::fromHandle(hContext)->allocHostMem(hostDesc->flags, size, alignment, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverFreeMem(
ze_driver_handle_t hDriver,
zeMemFree(
ze_context_handle_t hContext,
void *ptr) {
return L0::DriverHandle::fromHandle(hDriver)->freeMem(ptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemFree(ze_context_handle_t hContext,
void *ptr) {
return L0::Context::fromHandle(hContext)->freeMem(ptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetMemAllocProperties(
ze_driver_handle_t hDriver,
const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) {
return L0::DriverHandle::fromHandle(hDriver)->getMemAllocProperties(ptr, pMemAllocProperties, phDevice);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAllocProperties(
ze_context_handle_t hContext,
@ -104,15 +57,6 @@ zeMemGetAllocProperties(
return L0::Context::fromHandle(hContext)->getMemAllocProperties(ptr, pMemAllocProperties, phDevice);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetMemAddressRange(
ze_driver_handle_t hDriver,
const void *ptr,
void **pBase,
size_t *pSize) {
return L0::DriverHandle::fromHandle(hDriver)->getMemAddressRange(ptr, pBase, pSize);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetAddressRange(
ze_context_handle_t hContext,
@ -122,14 +66,6 @@ zeMemGetAddressRange(
return L0::Context::fromHandle(hContext)->getMemAddressRange(ptr, pBase, pSize);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverGetMemIpcHandle(
ze_driver_handle_t hDriver,
const void *ptr,
ze_ipc_mem_handle_t *pIpcHandle) {
return L0::DriverHandle::fromHandle(hDriver)->getIpcMemHandle(ptr, pIpcHandle);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemGetIpcHandle(
ze_context_handle_t hContext,
@ -138,16 +74,6 @@ zeMemGetIpcHandle(
return L0::Context::fromHandle(hContext)->getIpcMemHandle(ptr, pIpcHandle);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverOpenMemIpcHandle(
ze_driver_handle_t hDriver,
ze_device_handle_t hDevice,
ze_ipc_mem_handle_t handle,
ze_ipc_memory_flag_t flags,
void **pptr) {
return L0::DriverHandle::fromHandle(hDriver)->openIpcMemHandle(hDevice, handle, flags, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemOpenIpcHandle(
ze_context_handle_t hContext,
@ -158,18 +84,9 @@ zeMemOpenIpcHandle(
return L0::Context::fromHandle(hContext)->openIpcMemHandle(hDevice, handle, flags, pptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDriverCloseMemIpcHandle(
ze_driver_handle_t hDriver,
const void *ptr) {
return L0::DriverHandle::fromHandle(hDriver)->closeIpcMemHandle(ptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeMemCloseIpcHandle(
ze_context_handle_t hContext,
const void *ptr) {
return L0::Context::fromHandle(hContext)->closeIpcMemHandle(ptr);
}
} // extern "C"

44
level_zero/api/core/ze_module.cpp
View File

@ -8,21 +8,8 @@
#include "level_zero/core/source/module/module.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreate(
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
return L0::Device::fromHandle(hDevice)->createModule(desc, phModule, phBuildLog);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
@ -63,6 +50,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleGetGlobalPointer(
ze_module_handle_t hModule,
const char *pGlobalName,
size_t *pSize,
void **pptr) {
return L0::Module::fromHandle(hModule)->getGlobalPointer(pGlobalName, pptr);
}
@ -135,27 +123,31 @@ zeKernelSetArgumentValue(
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetAttribute(
zeKernelSetIndirectAccess(
ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t size,
const void *pValue) {
return L0::Kernel::fromHandle(hKernel)->setAttribute(attr, size, pValue);
ze_kernel_indirect_access_flags_t flags) {
return L0::Kernel::fromHandle(hKernel)->setIndirectAccess(flags);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetAttribute(
zeKernelGetIndirectAccess(
ze_kernel_handle_t hKernel,
ze_kernel_indirect_access_flags_t *pFlags) {
return L0::Kernel::fromHandle(hKernel)->getIndirectAccess(pFlags);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetSourceAttributes(
ze_kernel_handle_t hKernel,
ze_kernel_attribute_t attr,
uint32_t *pSize,
void *pValue) {
return L0::Kernel::fromHandle(hKernel)->getAttribute(attr, pSize, pValue);
char **pString) {
return L0::Kernel::fromHandle(hKernel)->getSourceAttributes(pSize, pString);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelSetIntermediateCacheConfig(
ze_kernel_handle_t hKernel,
ze_cache_config_t cacheConfig) {
ze_cache_config_flags_t cacheConfig) {
return L0::Kernel::fromHandle(hKernel)->setIntermediateCacheConfig(cacheConfig);
}
@ -215,8 +207,8 @@ zeCommandListAppendLaunchMultipleKernelsIndirect(
ZE_APIEXPORT ze_result_t ZE_APICALL
zeKernelGetPropertiesExt(
ze_kernel_handle_t hKernel,
ze_kernel_propertiesExt_t *pKernelProperties) {
return L0::Kernel::fromHandle(hKernel)->getPropertiesExt(pKernelProperties);
ze_kernel_properties_t *pKernelProperties) {
return L0::Kernel::fromHandle(hKernel)->getProperties(pKernelProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -234,5 +226,3 @@ zeModuleDynamicLinkExt(
ze_module_build_log_handle_t *phLinkLog) {
return L0::Module::fromHandle(phModules[0])->performDynamicLink(numModules, phModules, phLinkLog);
}
} // extern "C"

4
level_zero/api/core/ze_residency.cpp
View File

@ -8,8 +8,6 @@
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceMakeMemoryResident(
ze_device_handle_t hDevice,
@ -39,5 +37,3 @@ zeDeviceEvictImage(
ze_image_handle_t hImage) {
return L0::Device::fromHandle(hDevice)->evictImage(hImage);
}
} // extern "C"

12
level_zero/api/core/ze_sampler.cpp
View File

@ -9,18 +9,8 @@
#include "level_zero/core/source/sampler/sampler.h"
#include <level_zero/ze_api.h>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreate(
ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
ze_sampler_handle_t *phSampler) {
return L0::Device::fromHandle(hDevice)->createSampler(desc, phSampler);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
@ -33,5 +23,3 @@ zeSamplerDestroy(
ze_sampler_handle_t hSampler) {
return L0::Sampler::fromHandle(hSampler)->destroy();
}
} // extern "C"

32
level_zero/api/experimental/tracing/zet_tracing.cpp
View File

@ -8,43 +8,37 @@
#include "level_zero/experimental/source/tracing/tracing.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/ze_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zetTracerCreate(
zet_driver_handle_t hDriver,
const zet_tracer_desc_t *desc,
zet_tracer_handle_t *phTracer) {
return L0::createAPITracer(hDriver, desc, phTracer);
zetTracerExpCreate(
zet_context_handle_t hContext,
const zet_tracer_exp_desc_t *desc,
zet_tracer_exp_handle_t *phTracer) {
return L0::createAPITracer(hContext, desc, phTracer);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetTracerDestroy(
zet_tracer_handle_t hTracer) {
zetTracerExpDestroy(
zet_tracer_exp_handle_t hTracer) {
return L0::APITracer::fromHandle(hTracer)->destroyTracer(hTracer);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetTracerSetPrologues(
zet_tracer_handle_t hTracer,
zetTracerExpSetPrologues(
zet_tracer_exp_handle_t hTracer,
zet_core_callbacks_t *pCoreCbs) {
return L0::APITracer::fromHandle(hTracer)->setPrologues(pCoreCbs);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetTracerSetEpilogues(
zet_tracer_handle_t hTracer,
zetTracerExpSetEpilogues(
zet_tracer_exp_handle_t hTracer,
zet_core_callbacks_t *pCoreCbs) {
return L0::APITracer::fromHandle(hTracer)->setEpilogues(pCoreCbs);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetTracerSetEnabled(
zet_tracer_handle_t hTracer,
zetTracerExpSetEnabled(
zet_tracer_exp_handle_t hTracer,
ze_bool_t enable) {
return L0::APITracer::fromHandle(hTracer)->enableTracer(enable);
}
} // extern C

11
level_zero/api/sysman/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_SYSMAN_API
${CMAKE_CURRENT_SOURCE_DIR}/ze_sysman_loader.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zes_sysman.cpp
)
set_property(GLOBAL PROPERTY L0_SYSMAN_API ${L0_SYSMAN_API})

389
level_zero/api/sysman/ze_sysman_loader.cpp Normal file
View File

@ -0,0 +1,389 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/source/inc/ze_intel_gpu.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include <level_zero/zes_api.h>
#include <level_zero/zes_ddi.h>
#include <level_zero/zet_api.h>
#include <level_zero/zet_ddi.h>
#include "ze_ddi_tables.h"
extern ze_gpu_driver_dditable_t driver_ddiTable;
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetDeviceProcAddrTable(
ze_api_version_t version,
zes_device_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnDeviceGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceGetProperties");
pDdiTable->pfnGetState = (zes_pfnDeviceGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceGetState");
pDdiTable->pfnReset = (zes_pfnDeviceReset_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceReset");
pDdiTable->pfnProcessesGetState = (zes_pfnDeviceProcessesGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceProcessesGetState");
pDdiTable->pfnPciGetProperties = (zes_pfnDevicePciGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDevicePciGetProperties");
pDdiTable->pfnPciGetState = (zes_pfnDevicePciGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDevicePciGetState");
pDdiTable->pfnPciGetBars = (zes_pfnDevicePciGetBars_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDevicePciGetBars");
pDdiTable->pfnPciGetStats = (zes_pfnDevicePciGetStats_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDevicePciGetStats");
pDdiTable->pfnEnumDiagnosticTestSuites = (zes_pfnDeviceEnumDiagnosticTestSuites_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumDiagnosticTestSuites");
pDdiTable->pfnEnumEngineGroups = (zes_pfnDeviceEnumEngineGroups_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumEngineGroups");
pDdiTable->pfnEventRegister = (zes_pfnDeviceEventRegister_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEventRegister");
pDdiTable->pfnEnumFabricPorts = (zes_pfnDeviceEnumFabricPorts_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumFabricPorts");
pDdiTable->pfnEnumFans = (zes_pfnDeviceEnumFans_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumFans");
pDdiTable->pfnEnumFirmwares = (zes_pfnDeviceEnumFirmwares_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumFirmwares");
pDdiTable->pfnEnumFrequencyDomains = (zes_pfnDeviceEnumFrequencyDomains_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumFrequencyDomains");
pDdiTable->pfnEnumLeds = (zes_pfnDeviceEnumLeds_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumLeds");
pDdiTable->pfnEnumMemoryModules = (zes_pfnDeviceEnumMemoryModules_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumMemoryModules");
pDdiTable->pfnEnumPerformanceFactorDomains = (zes_pfnDeviceEnumPerformanceFactorDomains_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumPerformanceFactorDomains");
pDdiTable->pfnEnumPowerDomains = (zes_pfnDeviceEnumPowerDomains_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumPowerDomains");
pDdiTable->pfnEnumPsus = (zes_pfnDeviceEnumPsus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumPsus");
pDdiTable->pfnEnumRasErrorSets = (zes_pfnDeviceEnumRasErrorSets_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumRasErrorSets");
pDdiTable->pfnEnumSchedulers = (zes_pfnDeviceEnumSchedulers_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumSchedulers");
pDdiTable->pfnEnumStandbyDomains = (zes_pfnDeviceEnumStandbyDomains_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumStandbyDomains");
pDdiTable->pfnEnumTemperatureSensors = (zes_pfnDeviceEnumTemperatureSensors_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDeviceEnumTemperatureSensors");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetDriverProcAddrTable(
ze_api_version_t version,
zes_driver_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnEventListen = (zes_pfnDriverEventListen_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDriverEventListen");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetDiagnosticsProcAddrTable(
ze_api_version_t version,
zes_diagnostics_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnDiagnosticsGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDiagnosticsGetProperties");
pDdiTable->pfnGetTests = (zes_pfnDiagnosticsGetTests_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDiagnosticsGetTests");
pDdiTable->pfnRunTests = (zes_pfnDiagnosticsRunTests_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesDiagnosticsRunTests");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetEngineProcAddrTable(
ze_api_version_t version,
zes_engine_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnEngineGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesEngineGetProperties");
pDdiTable->pfnGetActivity = (zes_pfnEngineGetActivity_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesEngineGetActivity");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetFabricPortProcAddrTable(
ze_api_version_t version,
zes_fabric_port_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnFabricPortGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortGetProperties");
pDdiTable->pfnGetLinkType = (zes_pfnFabricPortGetLinkType_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortGetLinkType");
pDdiTable->pfnGetConfig = (zes_pfnFabricPortGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortGetConfig");
pDdiTable->pfnSetConfig = (zes_pfnFabricPortSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortSetConfig");
pDdiTable->pfnGetState = (zes_pfnFabricPortGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortGetState");
pDdiTable->pfnGetThroughput = (zes_pfnFabricPortGetThroughput_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFabricPortGetThroughput");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetFanProcAddrTable(
ze_api_version_t version,
zes_fan_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnFanGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanGetProperties");
pDdiTable->pfnGetConfig = (zes_pfnFanGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanGetConfig");
pDdiTable->pfnSetDefaultMode = (zes_pfnFanSetDefaultMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanSetDefaultMode");
pDdiTable->pfnSetFixedSpeedMode = (zes_pfnFanSetFixedSpeedMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanSetFixedSpeedMode");
pDdiTable->pfnSetSpeedTableMode = (zes_pfnFanSetSpeedTableMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanSetSpeedTableMode");
pDdiTable->pfnGetState = (zes_pfnFanGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFanGetState");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetFirmwareProcAddrTable(
ze_api_version_t version,
zes_firmware_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnFirmwareGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFirmwareGetProperties");
pDdiTable->pfnFlash = (zes_pfnFirmwareFlash_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFirmwareFlash");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetFrequencyProcAddrTable(
ze_api_version_t version,
zes_frequency_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnFrequencyGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyGetProperties");
pDdiTable->pfnGetAvailableClocks = (zes_pfnFrequencyGetAvailableClocks_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyGetAvailableClocks");
pDdiTable->pfnGetRange = (zes_pfnFrequencyGetRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyGetRange");
pDdiTable->pfnSetRange = (zes_pfnFrequencySetRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencySetRange");
pDdiTable->pfnGetState = (zes_pfnFrequencyGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyGetState");
pDdiTable->pfnGetThrottleTime = (zes_pfnFrequencyGetThrottleTime_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyGetThrottleTime");
pDdiTable->pfnOcGetCapabilities = (zes_pfnFrequencyOcGetCapabilities_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetCapabilities");
pDdiTable->pfnOcGetFrequencyTarget = (zes_pfnFrequencyOcGetFrequencyTarget_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetFrequencyTarget");
pDdiTable->pfnOcSetFrequencyTarget = (zes_pfnFrequencyOcSetFrequencyTarget_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcSetFrequencyTarget");
pDdiTable->pfnOcGetVoltageTarget = (zes_pfnFrequencyOcGetVoltageTarget_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetVoltageTarget");
pDdiTable->pfnOcSetVoltageTarget = (zes_pfnFrequencyOcSetVoltageTarget_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcSetVoltageTarget");
pDdiTable->pfnOcSetMode = (zes_pfnFrequencyOcSetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcSetMode");
pDdiTable->pfnOcGetMode = (zes_pfnFrequencyOcGetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetMode");
pDdiTable->pfnOcGetIccMax = (zes_pfnFrequencyOcGetIccMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetIccMax");
pDdiTable->pfnOcSetIccMax = (zes_pfnFrequencyOcSetIccMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcSetIccMax");
pDdiTable->pfnOcGetTjMax = (zes_pfnFrequencyOcGetTjMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcGetTjMax");
pDdiTable->pfnOcSetTjMax = (zes_pfnFrequencyOcSetTjMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesFrequencyOcSetTjMax");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetLedProcAddrTable(
ze_api_version_t version,
zes_led_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnLedGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesLedGetProperties");
pDdiTable->pfnGetState = (zes_pfnLedGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesLedGetState");
pDdiTable->pfnSetState = (zes_pfnLedSetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesLedSetState");
pDdiTable->pfnSetColor = (zes_pfnLedSetColor_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesLedSetColor");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetMemoryProcAddrTable(
ze_api_version_t version,
zes_memory_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnMemoryGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesMemoryGetProperties");
pDdiTable->pfnGetState = (zes_pfnMemoryGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesMemoryGetState");
pDdiTable->pfnGetBandwidth = (zes_pfnMemoryGetBandwidth_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesMemoryGetBandwidth");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetPerformanceFactorProcAddrTable(
ze_api_version_t version,
zes_performance_factor_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnPerformanceFactorGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPerformanceFactorGetProperties");
pDdiTable->pfnGetConfig = (zes_pfnPerformanceFactorGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPerformanceFactorGetConfig");
pDdiTable->pfnSetConfig = (zes_pfnPerformanceFactorSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPerformanceFactorSetConfig");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetPowerProcAddrTable(
ze_api_version_t version,
zes_power_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnPowerGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerGetProperties");
pDdiTable->pfnGetEnergyCounter = (zes_pfnPowerGetEnergyCounter_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerGetEnergyCounter");
pDdiTable->pfnGetLimits = (zes_pfnPowerGetLimits_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerGetLimits");
pDdiTable->pfnSetLimits = (zes_pfnPowerSetLimits_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerSetLimits");
pDdiTable->pfnGetEnergyThreshold = (zes_pfnPowerGetEnergyThreshold_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerGetEnergyThreshold");
pDdiTable->pfnSetEnergyThreshold = (zes_pfnPowerSetEnergyThreshold_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPowerSetEnergyThreshold");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetPsuProcAddrTable(
ze_api_version_t version,
zes_psu_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnPsuGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPsuGetProperties");
pDdiTable->pfnGetState = (zes_pfnPsuGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesPsuGetState");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetRasProcAddrTable(
ze_api_version_t version,
zes_ras_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnRasGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesRasGetProperties");
pDdiTable->pfnGetConfig = (zes_pfnRasGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesRasGetConfig");
pDdiTable->pfnSetConfig = (zes_pfnRasSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesRasSetConfig");
pDdiTable->pfnGetState = (zes_pfnRasGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesRasGetState");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetSchedulerProcAddrTable(
ze_api_version_t version,
zes_scheduler_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnSchedulerGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerGetProperties");
pDdiTable->pfnGetCurrentMode = (zes_pfnSchedulerGetCurrentMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerGetCurrentMode");
pDdiTable->pfnGetTimeoutModeProperties = (zes_pfnSchedulerGetTimeoutModeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerGetTimeoutModeProperties");
pDdiTable->pfnGetTimesliceModeProperties = (zes_pfnSchedulerGetTimesliceModeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerGetTimesliceModeProperties");
pDdiTable->pfnSetTimeoutMode = (zes_pfnSchedulerSetTimeoutMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerSetTimeoutMode");
pDdiTable->pfnSetTimesliceMode = (zes_pfnSchedulerSetTimesliceMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerSetTimesliceMode");
pDdiTable->pfnSetExclusiveMode = (zes_pfnSchedulerSetExclusiveMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerSetExclusiveMode");
pDdiTable->pfnSetComputeUnitDebugMode = (zes_pfnSchedulerSetComputeUnitDebugMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesSchedulerSetComputeUnitDebugMode");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetStandbyProcAddrTable(
ze_api_version_t version,
zes_standby_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnStandbyGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesStandbyGetProperties");
pDdiTable->pfnGetMode = (zes_pfnStandbyGetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesStandbyGetMode");
pDdiTable->pfnSetMode = (zes_pfnStandbySetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesStandbySetMode");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zesGetTemperatureProcAddrTable(
ze_api_version_t version,
zes_temperature_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zes_pfnTemperatureGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesTemperatureGetProperties");
pDdiTable->pfnGetConfig = (zes_pfnTemperatureGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesTemperatureGetConfig");
pDdiTable->pfnSetConfig = (zes_pfnTemperatureSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesTemperatureSetConfig");
pDdiTable->pfnGetState = (zes_pfnTemperatureGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zesTemperatureGetState");
return result;
}

733
level_zero/api/sysman/zes_sysman.cpp Normal file
View File

@ -0,0 +1,733 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include <level_zero/zet_api.h>
#include "sysman/sysman.h"
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceGetProperties(
zes_device_handle_t hDevice,
zes_device_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceGetState(
zes_device_handle_t hDevice,
zes_device_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumSchedulers(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_sched_handle_t *phScheduler) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerGetProperties(
zes_sched_handle_t hScheduler,
zes_sched_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerGetCurrentMode(
zes_sched_handle_t hScheduler,
zes_sched_mode_t *pMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerGetTimeoutModeProperties(
zes_sched_handle_t hScheduler,
ze_bool_t getDefaults,
zes_sched_timeout_properties_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerGetTimesliceModeProperties(
zes_sched_handle_t hScheduler,
ze_bool_t getDefaults,
zes_sched_timeslice_properties_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerSetTimeoutMode(
zes_sched_handle_t hScheduler,
zes_sched_timeout_properties_t *pProperties,
ze_bool_t *pNeedReload) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerSetTimesliceMode(
zes_sched_handle_t hScheduler,
zes_sched_timeslice_properties_t *pProperties,
ze_bool_t *pNeedReload) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerSetExclusiveMode(
zes_sched_handle_t hScheduler,
ze_bool_t *pNeedReload) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesSchedulerSetComputeUnitDebugMode(
zes_sched_handle_t hScheduler,
ze_bool_t *pNeedReload) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceProcessesGetState(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_process_state_t *pProcesses) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceReset(
zes_device_handle_t hDevice,
ze_bool_t force) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetProperties(
zes_device_handle_t hDevice,
zes_pci_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetState(
zes_device_handle_t hDevice,
zes_pci_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetBars(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_pci_bar_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetStats(
zes_device_handle_t hDevice,
zes_pci_stats_t *pStats) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumPowerDomains(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_pwr_handle_t *phPower) {
return L0::SysmanDevice::fromHandle(hDevice)->powerGet(pCount, phPower);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerGetProperties(
zes_pwr_handle_t hPower,
zes_power_properties_t *pProperties) {
return L0::Power::fromHandle(hPower)->powerGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerGetEnergyCounter(
zes_pwr_handle_t hPower,
zes_power_energy_counter_t *pEnergy) {
return L0::Power::fromHandle(hPower)->powerGetEnergyCounter(pEnergy);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerGetLimits(
zes_pwr_handle_t hPower,
zes_power_sustained_limit_t *pSustained,
zes_power_burst_limit_t *pBurst,
zes_power_peak_limit_t *pPeak) {
return L0::Power::fromHandle(hPower)->powerGetLimits(pSustained, pBurst, pPeak);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerSetLimits(
zes_pwr_handle_t hPower,
const zes_power_sustained_limit_t *pSustained,
const zes_power_burst_limit_t *pBurst,
const zes_power_peak_limit_t *pPeak) {
return L0::Power::fromHandle(hPower)->powerSetLimits(pSustained, pBurst, pPeak);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerGetEnergyThreshold(
zes_pwr_handle_t hPower,
zes_energy_threshold_t *pThreshold) {
return L0::Power::fromHandle(hPower)->powerGetEnergyThreshold(pThreshold);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPowerSetEnergyThreshold(
zes_pwr_handle_t hPower,
double threshold) {
return L0::Power::fromHandle(hPower)->powerSetEnergyThreshold(threshold);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumFrequencyDomains(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_freq_handle_t *phFrequency) {
return L0::SysmanDevice::fromHandle(hDevice)->frequencyGet(pCount, phFrequency);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyGetProperties(
zes_freq_handle_t hFrequency,
zes_freq_properties_t *pProperties) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyGetAvailableClocks(
zes_freq_handle_t hFrequency,
uint32_t *pCount,
double *phFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyGetRange(
zes_freq_handle_t hFrequency,
zes_freq_range_t *pLimits) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencySetRange(
zes_freq_handle_t hFrequency,
const zes_freq_range_t *pLimits) {
return L0::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyGetState(
zes_freq_handle_t hFrequency,
zes_freq_state_t *pState) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyGetThrottleTime(
zes_freq_handle_t hFrequency,
zes_freq_throttle_time_t *pThrottleTime) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetThrottleTime(pThrottleTime);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetFrequencyTarget(
zes_freq_handle_t hFrequency,
double *pCurrentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcSetFrequencyTarget(
zes_freq_handle_t hFrequency,
double currentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetVoltageTarget(
zes_freq_handle_t hFrequency,
double *pCurrentVoltageTarget,
double *pCurrentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcSetVoltageTarget(
zes_freq_handle_t hFrequency,
double currentVoltageTarget,
double currentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcSetMode(
zes_freq_handle_t hFrequency,
zes_oc_mode_t currentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetMode(
zes_freq_handle_t hFrequency,
zes_oc_mode_t *pCurrentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetCapabilities(
zes_freq_handle_t hFrequency,
zes_oc_capabilities_t *pOcCapabilities) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetIccMax(
zes_freq_handle_t hFrequency,
double *pOcIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcSetIccMax(
zes_freq_handle_t hFrequency,
double ocIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcGetTjMax(
zes_freq_handle_t hFrequency,
double *pOcTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFrequencyOcSetTjMax(
zes_freq_handle_t hFrequency,
double ocTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumEngineGroups(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_engine_handle_t *phEngine) {
return L0::SysmanDevice::fromHandle(hDevice)->engineGet(pCount, phEngine);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesEngineGetProperties(
zes_engine_handle_t hEngine,
zes_engine_properties_t *pProperties) {
return L0::Engine::fromHandle(hEngine)->engineGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesEngineGetActivity(
zes_engine_handle_t hEngine,
zes_engine_stats_t *pStats) {
return L0::Engine::fromHandle(hEngine)->engineGetActivity(pStats);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumStandbyDomains(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_standby_handle_t *phStandby) {
return L0::SysmanDevice::fromHandle(hDevice)->standbyGet(pCount, phStandby);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesStandbyGetProperties(
zes_standby_handle_t hStandby,
zes_standby_properties_t *pProperties) {
return L0::Standby::fromHandle(hStandby)->standbyGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesStandbyGetMode(
zes_standby_handle_t hStandby,
zes_standby_promo_mode_t *pMode) {
return L0::Standby::fromHandle(hStandby)->standbyGetMode(pMode);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesStandbySetMode(
zes_standby_handle_t hStandby,
zes_standby_promo_mode_t mode) {
return L0::Standby::fromHandle(hStandby)->standbySetMode(mode);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumFirmwares(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_firmware_handle_t *phFirmware) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFirmwareGetProperties(
zes_firmware_handle_t hFirmware,
zes_firmware_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFirmwareFlash(
zes_firmware_handle_t hFirmware,
void *pImage,
uint32_t size) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumMemoryModules(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_mem_handle_t *phMemory) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesMemoryGetProperties(
zes_mem_handle_t hMemory,
zes_mem_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesMemoryGetState(
zes_mem_handle_t hMemory,
zes_mem_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesMemoryGetBandwidth(
zes_mem_handle_t hMemory,
zes_mem_bandwidth_t *pBandwidth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumFabricPorts(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_fabric_port_handle_t *phPort) {
return L0::SysmanDevice::fromHandle(hDevice)->fabricPortGet(pCount, phPort);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortGetProperties(
zes_fabric_port_handle_t hPort,
zes_fabric_port_properties_t *pProperties) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortGetLinkType(
zes_fabric_port_handle_t hPort,
zes_fabric_link_type_t *pLinkType) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetLinkType(pLinkType);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortGetConfig(
zes_fabric_port_handle_t hPort,
zes_fabric_port_config_t *pConfig) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetConfig(pConfig);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortSetConfig(
zes_fabric_port_handle_t hPort,
const zes_fabric_port_config_t *pConfig) {
return L0::FabricPort::fromHandle(hPort)->fabricPortSetConfig(pConfig);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortGetState(
zes_fabric_port_handle_t hPort,
zes_fabric_port_state_t *pState) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetState(pState);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFabricPortGetThroughput(
zes_fabric_port_handle_t hPort,
zes_fabric_port_throughput_t *pThroughput) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetThroughput(pThroughput);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumTemperatureSensors(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_temp_handle_t *phTemperature) {
return L0::SysmanDevice::fromHandle(hDevice)->temperatureGet(pCount, phTemperature);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesTemperatureGetProperties(
zes_temp_handle_t hTemperature,
zes_temp_properties_t *pProperties) {
return L0::Temperature::fromHandle(hTemperature)->temperatureGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesTemperatureGetConfig(
zes_temp_handle_t hTemperature,
zes_temp_config_t *pConfig) {
return L0::Temperature::fromHandle(hTemperature)->temperatureGetConfig(pConfig);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesTemperatureSetConfig(
zes_temp_handle_t hTemperature,
const zes_temp_config_t *pConfig) {
return L0::Temperature::fromHandle(hTemperature)->temperatureSetConfig(pConfig);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesTemperatureGetState(
zes_temp_handle_t hTemperature,
double *pTemperature) {
return L0::Temperature::fromHandle(hTemperature)->temperatureGetState(pTemperature);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumPsus(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_psu_handle_t *phPsu) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPsuGetProperties(
zes_psu_handle_t hPsu,
zes_psu_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPsuGetState(
zes_psu_handle_t hPsu,
zes_psu_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumFans(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_fan_handle_t *phFan) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanGetProperties(
zes_fan_handle_t hFan,
zes_fan_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanGetConfig(
zes_fan_handle_t hFan,
zes_fan_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanSetDefaultMode(
zes_fan_handle_t hFan) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanSetFixedSpeedMode(
zes_fan_handle_t hFan,
const zes_fan_speed_t *speed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanSetSpeedTableMode(
zes_fan_handle_t hFan,
const zes_fan_speed_table_t *speedTable) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesFanGetState(
zes_fan_handle_t hFan,
zes_fan_speed_units_t units,
int32_t *pSpeed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumLeds(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_led_handle_t *phLed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesLedGetProperties(
zes_led_handle_t hLed,
zes_led_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesLedGetState(
zes_led_handle_t hLed,
zes_led_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesLedSetState(
zes_led_handle_t hLed,
ze_bool_t enable) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesLedSetColor(
zes_led_handle_t hLed,
const zes_led_color_t *pColor) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumRasErrorSets(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_ras_handle_t *phRas) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesRasGetProperties(
zes_ras_handle_t hRas,
zes_ras_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesRasGetConfig(
zes_ras_handle_t hRas,
zes_ras_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesRasSetConfig(
zes_ras_handle_t hRas,
const zes_ras_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesRasGetState(
zes_ras_handle_t hRas,
ze_bool_t clear,
zes_ras_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEventRegister(
zes_device_handle_t hDevice,
zes_event_type_flags_t events) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDriverEventListen(
ze_driver_handle_t hDriver,
uint32_t timeout,
uint32_t count,
zes_device_handle_t *phDevices,
uint32_t *pNumDeviceEvents,
zes_event_type_flags_t *pEvents) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumDiagnosticTestSuites(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_diag_handle_t *phDiagnostics) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDiagnosticsGetProperties(
zes_diag_handle_t hDiagnostics,
zes_diag_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDiagnosticsGetTests(
zes_diag_handle_t hDiagnostics,
uint32_t *pCount,
zes_diag_test_t *pTests) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDiagnosticsRunTests(
zes_diag_handle_t hDiagnostics,
uint32_t start,
uint32_t end,
zes_diag_result_t *pResult) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDeviceEnumPerformanceFactorDomains(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_perf_handle_t *phPerf) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPerformanceFactorGetProperties(
zes_perf_handle_t hPerf,
zes_perf_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPerformanceFactorGetConfig(
zes_perf_handle_t hPerf,
double *pFactor) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesPerformanceFactorSetConfig(
zes_perf_handle_t hPerf,
double factor) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

2
level_zero/api/tools/CMakeLists.txt
View File

@ -7,8 +7,6 @@
set(L0_TOOLS_API
${CMAKE_CURRENT_SOURCE_DIR}/ze_tools_loader.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zet_metric.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zet_sysman.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zet_driver.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zet_module.cpp
)
set_property(GLOBAL PROPERTY L0_TOOLS_API ${L0_TOOLS_API})

418
level_zero/api/tools/ze_tools_loader.cpp
View File

@ -8,20 +8,35 @@
#include "level_zero/source/inc/ze_intel_gpu.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include <level_zero/zes_api.h>
#include <level_zero/zes_ddi.h>
#include <level_zero/zet_api.h>
#include <level_zero/zet_ddi.h>
#include "third_party/level_zero/ze_api_ext.h"
#include "ze_ddi_tables.h"
extern "C" {
extern ze_gpu_driver_dditable_t driver_ddiTable;
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetGlobalProcAddrTable(
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetContextProcAddrTable(
ze_api_version_t version,
zet_global_dditable_t *pDdiTable) {
zet_context_dditable_t *pDdiTable) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
pDdiTable->pfnActivateMetricGroups = (zet_pfnContextActivateMetricGroups_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetContextActivateMetricGroups");
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricStreamerProcAddrTable(
ze_api_version_t version,
zet_metric_streamer_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
@ -30,14 +45,18 @@ zetGetGlobalProcAddrTable(
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnInit = (zet_pfnInit_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetInit");
pDdiTable->pfnOpen = (zet_pfnMetricStreamerOpen_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricStreamerOpen");
pDdiTable->pfnClose = (zet_pfnMetricStreamerClose_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricStreamerClose");
pDdiTable->pfnReadData = (zet_pfnMetricStreamerReadData_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricStreamerReadData");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetDeviceProcAddrTable(
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetTracerExpProcAddrTable(
ze_api_version_t version,
zet_device_dditable_t *pDdiTable) {
zet_tracer_exp_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
@ -46,11 +65,15 @@ zetGetDeviceProcAddrTable(
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnActivateMetricGroups = (zet_pfnDeviceActivateMetricGroups_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDeviceActivateMetricGroups");
pDdiTable->pfnCreate = (zet_pfnTracerExpCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerExpCreate");
pDdiTable->pfnDestroy = (zet_pfnTracerExpDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerExpDestroy");
pDdiTable->pfnSetPrologues = (zet_pfnTracerExpSetPrologues_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerExpSetPrologues");
pDdiTable->pfnSetEpilogues = (zet_pfnTracerExpSetEpilogues_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerExpSetEpilogues");
pDdiTable->pfnSetEnabled = (zet_pfnTracerExpSetEnabled_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerExpSetEnabled");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetCommandListProcAddrTable(
ze_api_version_t version,
zet_command_list_dditable_t *pDdiTable) {
@ -62,14 +85,14 @@ zetGetCommandListProcAddrTable(
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAppendMetricTracerMarker = (zet_pfnCommandListAppendMetricTracerMarker_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetCommandListAppendMetricTracerMarker");
pDdiTable->pfnAppendMetricStreamerMarker = (zet_pfnCommandListAppendMetricStreamerMarker_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetCommandListAppendMetricStreamerMarker");
pDdiTable->pfnAppendMetricQueryBegin = (zet_pfnCommandListAppendMetricQueryBegin_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetCommandListAppendMetricQueryBegin");
pDdiTable->pfnAppendMetricQueryEnd = (zet_pfnCommandListAppendMetricQueryEnd_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetCommandListAppendMetricQueryEnd");
pDdiTable->pfnAppendMetricMemoryBarrier = (zet_pfnCommandListAppendMetricMemoryBarrier_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetCommandListAppendMetricMemoryBarrier");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetModuleProcAddrTable(
ze_api_version_t version,
zet_module_dditable_t *pDdiTable) {
@ -85,7 +108,7 @@ zetGetModuleProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetKernelProcAddrTable(
ze_api_version_t version,
zet_kernel_dditable_t *pDdiTable) {
@ -101,7 +124,7 @@ zetGetKernelProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricGroupProcAddrTable(
ze_api_version_t version,
zet_metric_group_dditable_t *pDdiTable) {
@ -119,7 +142,7 @@ zetGetMetricGroupProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricProcAddrTable(
ze_api_version_t version,
zet_metric_dditable_t *pDdiTable) {
@ -136,25 +159,7 @@ zetGetMetricProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetMetricTracerProcAddrTable(
ze_api_version_t version,
zet_metric_tracer_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnOpen = (zet_pfnMetricTracerOpen_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricTracerOpen");
pDdiTable->pfnClose = (zet_pfnMetricTracerClose_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricTracerClose");
pDdiTable->pfnReadData = (zet_pfnMetricTracerReadData_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetMetricTracerReadData");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricQueryPoolProcAddrTable(
ze_api_version_t version,
zet_metric_query_pool_dditable_t *pDdiTable) {
@ -171,7 +176,7 @@ zetGetMetricQueryPoolProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricQueryProcAddrTable(
ze_api_version_t version,
zet_metric_query_dditable_t *pDdiTable) {
@ -190,10 +195,10 @@ zetGetMetricQueryProcAddrTable(
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetTracerProcAddrTable(
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetDeviceProcAddrTable(
ze_api_version_t version,
zet_tracer_dditable_t *pDdiTable) {
zet_device_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
@ -202,334 +207,11 @@ zetGetTracerProcAddrTable(
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreate = (zet_pfnTracerCreate_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerCreate");
pDdiTable->pfnDestroy = (zet_pfnTracerDestroy_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerDestroy");
pDdiTable->pfnSetPrologues = (zet_pfnTracerSetPrologues_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerSetPrologues");
pDdiTable->pfnSetEpilogues = (zet_pfnTracerSetEpilogues_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerSetEpilogues");
pDdiTable->pfnSetEnabled = (zet_pfnTracerSetEnabled_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetTracerSetEnabled");
pDdiTable->pfnGetDebugProperties = (zet_pfnDeviceGetDebugProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDeviceGetDebugProperties");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanProcAddrTable(
ze_api_version_t version,
zet_sysman_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGet = (zet_pfnSysmanGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanGet");
pDdiTable->pfnDeviceGetProperties = (zet_pfnSysmanDeviceGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDeviceGetProperties");
pDdiTable->pfnSchedulerGetSupportedModes = (zet_pfnSysmanSchedulerGetSupportedModes_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerGetSupportedModes");
pDdiTable->pfnSchedulerGetCurrentMode = (zet_pfnSysmanSchedulerGetCurrentMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerGetCurrentMode");
pDdiTable->pfnSchedulerGetTimeoutModeProperties = (zet_pfnSysmanSchedulerGetTimeoutModeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerGetTimeoutModeProperties");
pDdiTable->pfnSchedulerGetTimesliceModeProperties = (zet_pfnSysmanSchedulerGetTimesliceModeProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerGetTimesliceModeProperties");
pDdiTable->pfnSchedulerSetTimeoutMode = (zet_pfnSysmanSchedulerSetTimeoutMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerSetTimeoutMode");
pDdiTable->pfnSchedulerSetTimesliceMode = (zet_pfnSysmanSchedulerSetTimesliceMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerSetTimesliceMode");
pDdiTable->pfnSchedulerSetExclusiveMode = (zet_pfnSysmanSchedulerSetExclusiveMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerSetExclusiveMode");
pDdiTable->pfnSchedulerSetComputeUnitDebugMode = (zet_pfnSysmanSchedulerSetComputeUnitDebugMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanSchedulerSetComputeUnitDebugMode");
pDdiTable->pfnPerformanceProfileGetSupported = (zet_pfnSysmanPerformanceProfileGetSupported_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPerformanceProfileGetSupported");
pDdiTable->pfnPerformanceProfileGet = (zet_pfnSysmanPerformanceProfileGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPerformanceProfileGet");
pDdiTable->pfnPerformanceProfileSet = (zet_pfnSysmanPerformanceProfileSet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPerformanceProfileSet");
pDdiTable->pfnProcessesGetState = (zet_pfnSysmanProcessesGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanProcessesGetState");
pDdiTable->pfnDeviceReset = (zet_pfnSysmanDeviceReset_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDeviceReset");
pDdiTable->pfnDeviceGetRepairStatus = (zet_pfnSysmanDeviceGetRepairStatus_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDeviceGetRepairStatus");
pDdiTable->pfnPciGetProperties = (zet_pfnSysmanPciGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPciGetProperties");
pDdiTable->pfnPciGetState = (zet_pfnSysmanPciGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPciGetState");
pDdiTable->pfnPciGetBars = (zet_pfnSysmanPciGetBars_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPciGetBars");
pDdiTable->pfnPciGetStats = (zet_pfnSysmanPciGetStats_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPciGetStats");
pDdiTable->pfnPowerGet = (zet_pfnSysmanPowerGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerGet");
pDdiTable->pfnFrequencyGet = (zet_pfnSysmanFrequencyGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGet");
pDdiTable->pfnEngineGet = (zet_pfnSysmanEngineGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEngineGet");
pDdiTable->pfnStandbyGet = (zet_pfnSysmanStandbyGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanStandbyGet");
pDdiTable->pfnFirmwareGet = (zet_pfnSysmanFirmwareGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFirmwareGet");
pDdiTable->pfnMemoryGet = (zet_pfnSysmanMemoryGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanMemoryGet");
pDdiTable->pfnFabricPortGet = (zet_pfnSysmanFabricPortGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGet");
pDdiTable->pfnTemperatureGet = (zet_pfnSysmanTemperatureGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanTemperatureGet");
pDdiTable->pfnPsuGet = (zet_pfnSysmanPsuGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPsuGet");
pDdiTable->pfnFanGet = (zet_pfnSysmanFanGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFanGet");
pDdiTable->pfnLedGet = (zet_pfnSysmanLedGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanLedGet");
pDdiTable->pfnRasGet = (zet_pfnSysmanRasGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanRasGet");
pDdiTable->pfnEventGet = (zet_pfnSysmanEventGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEventGet");
pDdiTable->pfnDiagnosticsGet = (zet_pfnSysmanDiagnosticsGet_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDiagnosticsGet");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanPowerProcAddrTable(
ze_api_version_t version,
zet_sysman_power_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanPowerGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerGetProperties");
pDdiTable->pfnGetEnergyCounter = (zet_pfnSysmanPowerGetEnergyCounter_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerGetEnergyCounter");
pDdiTable->pfnGetLimits = (zet_pfnSysmanPowerGetLimits_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerGetLimits");
pDdiTable->pfnSetLimits = (zet_pfnSysmanPowerSetLimits_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerSetLimits");
pDdiTable->pfnGetEnergyThreshold = (zet_pfnSysmanPowerGetEnergyThreshold_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerGetEnergyThreshold");
pDdiTable->pfnSetEnergyThreshold = (zet_pfnSysmanPowerSetEnergyThreshold_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPowerSetEnergyThreshold");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanFrequencyProcAddrTable(
ze_api_version_t version,
zet_sysman_frequency_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanFrequencyGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGetProperties");
pDdiTable->pfnGetAvailableClocks = (zet_pfnSysmanFrequencyGetAvailableClocks_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGetAvailableClocks");
pDdiTable->pfnGetRange = (zet_pfnSysmanFrequencyGetRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGetRange");
pDdiTable->pfnSetRange = (zet_pfnSysmanFrequencySetRange_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencySetRange");
pDdiTable->pfnGetState = (zet_pfnSysmanFrequencyGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGetState");
pDdiTable->pfnGetThrottleTime = (zet_pfnSysmanFrequencyGetThrottleTime_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyGetThrottleTime");
pDdiTable->pfnOcGetCapabilities = (zet_pfnSysmanFrequencyOcGetCapabilities_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcGetCapabilities");
pDdiTable->pfnOcGetConfig = (zet_pfnSysmanFrequencyOcGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcGetConfig");
pDdiTable->pfnOcSetConfig = (zet_pfnSysmanFrequencyOcSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcSetConfig");
pDdiTable->pfnOcGetIccMax = (zet_pfnSysmanFrequencyOcGetIccMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcGetIccMax");
pDdiTable->pfnOcSetIccMax = (zet_pfnSysmanFrequencyOcSetIccMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcSetIccMax");
pDdiTable->pfnOcGetTjMax = (zet_pfnSysmanFrequencyOcGetTjMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcGetTjMax");
pDdiTable->pfnOcSetTjMax = (zet_pfnSysmanFrequencyOcSetTjMax_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFrequencyOcSetTjMax");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanEngineProcAddrTable(
ze_api_version_t version,
zet_sysman_engine_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanEngineGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEngineGetProperties");
pDdiTable->pfnGetActivity = (zet_pfnSysmanEngineGetActivity_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEngineGetActivity");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanStandbyProcAddrTable(
ze_api_version_t version,
zet_sysman_standby_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanStandbyGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanStandbyGetProperties");
pDdiTable->pfnGetMode = (zet_pfnSysmanStandbyGetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanStandbyGetMode");
pDdiTable->pfnSetMode = (zet_pfnSysmanStandbySetMode_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanStandbySetMode");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanFirmwareProcAddrTable(
ze_api_version_t version,
zet_sysman_firmware_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanFirmwareGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFirmwareGetProperties");
pDdiTable->pfnGetChecksum = (zet_pfnSysmanFirmwareGetChecksum_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFirmwareGetChecksum");
pDdiTable->pfnFlash = (zet_pfnSysmanFirmwareFlash_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFirmwareFlash");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanMemoryProcAddrTable(
ze_api_version_t version,
zet_sysman_memory_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanMemoryGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanMemoryGetProperties");
pDdiTable->pfnGetState = (zet_pfnSysmanMemoryGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanMemoryGetState");
pDdiTable->pfnGetBandwidth = (zet_pfnSysmanMemoryGetBandwidth_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanMemoryGetBandwidth");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanFabricPortProcAddrTable(
ze_api_version_t version,
zet_sysman_fabric_port_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanFabricPortGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGetProperties");
pDdiTable->pfnGetLinkType = (zet_pfnSysmanFabricPortGetLinkType_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGetLinkType");
pDdiTable->pfnGetConfig = (zet_pfnSysmanFabricPortGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGetConfig");
pDdiTable->pfnSetConfig = (zet_pfnSysmanFabricPortSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortSetConfig");
pDdiTable->pfnGetState = (zet_pfnSysmanFabricPortGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGetState");
pDdiTable->pfnGetThroughput = (zet_pfnSysmanFabricPortGetThroughput_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFabricPortGetThroughput");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanTemperatureProcAddrTable(
ze_api_version_t version,
zet_sysman_temperature_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanTemperatureGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanTemperatureGetProperties");
pDdiTable->pfnGetConfig = (zet_pfnSysmanTemperatureGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanTemperatureGetConfig");
pDdiTable->pfnSetConfig = (zet_pfnSysmanTemperatureSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanTemperatureSetConfig");
pDdiTable->pfnGetState = (zet_pfnSysmanTemperatureGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanTemperatureGetState");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanPsuProcAddrTable(
ze_api_version_t version,
zet_sysman_psu_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanPsuGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPsuGetProperties");
pDdiTable->pfnGetState = (zet_pfnSysmanPsuGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanPsuGetState");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanFanProcAddrTable(
ze_api_version_t version,
zet_sysman_fan_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanFanGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFanGetProperties");
pDdiTable->pfnGetConfig = (zet_pfnSysmanFanGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFanGetConfig");
pDdiTable->pfnSetConfig = (zet_pfnSysmanFanSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFanSetConfig");
pDdiTable->pfnGetState = (zet_pfnSysmanFanGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanFanGetState");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanLedProcAddrTable(
ze_api_version_t version,
zet_sysman_led_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanLedGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanLedGetProperties");
pDdiTable->pfnGetState = (zet_pfnSysmanLedGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanLedGetState");
pDdiTable->pfnSetState = (zet_pfnSysmanLedSetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanLedSetState");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanRasProcAddrTable(
ze_api_version_t version,
zet_sysman_ras_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanRasGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanRasGetProperties");
pDdiTable->pfnGetConfig = (zet_pfnSysmanRasGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanRasGetConfig");
pDdiTable->pfnSetConfig = (zet_pfnSysmanRasSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanRasSetConfig");
pDdiTable->pfnGetState = (zet_pfnSysmanRasGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanRasGetState");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanDiagnosticsProcAddrTable(
ze_api_version_t version,
zet_sysman_diagnostics_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetProperties = (zet_pfnSysmanDiagnosticsGetProperties_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDiagnosticsGetProperties");
pDdiTable->pfnGetTests = (zet_pfnSysmanDiagnosticsGetTests_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDiagnosticsGetTests");
pDdiTable->pfnRunTests = (zet_pfnSysmanDiagnosticsRunTests_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanDiagnosticsRunTests");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetGetSysmanEventProcAddrTable(
ze_api_version_t version,
zet_sysman_event_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (driver_ddiTable.version < version)
return ZE_RESULT_ERROR_UNKNOWN;
if (nullptr == driver_ddiTable.driverLibrary) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetConfig = (zet_pfnSysmanEventGetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEventGetConfig");
pDdiTable->pfnSetConfig = (zet_pfnSysmanEventSetConfig_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEventSetConfig");
pDdiTable->pfnGetState = (zet_pfnSysmanEventGetState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEventGetState");
pDdiTable->pfnListen = (zet_pfnSysmanEventListen_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetSysmanEventListen");
return result;
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetDebugProcAddrTable(
ze_api_version_t version,
zet_debug_dditable_t *pDdiTable) {
@ -543,15 +225,11 @@ zetGetDebugProcAddrTable(
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnAttach = (zet_pfnDebugAttach_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugAttach");
pDdiTable->pfnDetach = (zet_pfnDebugDetach_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugDetach");
pDdiTable->pfnGetNumThreads = (zet_pfnDebugGetNumThreads_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugGetNumThreads");
pDdiTable->pfnReadEvent = (zet_pfnDebugReadEvent_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugReadEvent");
pDdiTable->pfnInterrupt = (zet_pfnDebugInterrupt_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugInterrupt");
pDdiTable->pfnResume = (zet_pfnDebugResume_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugResume");
pDdiTable->pfnReadMemory = (zet_pfnDebugReadMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugReadMemory");
pDdiTable->pfnWriteMemory = (zet_pfnDebugWriteMemory_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugWriteMemory");
pDdiTable->pfnReadState = (zet_pfnDebugReadState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugReadState");
pDdiTable->pfnWriteState = (zet_pfnDebugWriteState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugWriteState");
return result;
}
} // extern C

23
level_zero/api/tools/zet_driver.cpp
View File

@ -1,23 +0,0 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/tools_init.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/ze_api_ext.h"
#include <iostream>
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
zetInit(
ze_init_flag_t flags) {
return L0::ToolsInit::get()->initTools(flags);
}
} // extern C

123
level_zero/api/tools/zet_metric.cpp
View File

@ -10,11 +10,7 @@
#include "level_zero/tools/source/metrics/metric.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zet_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricGroupGet(
zet_device_handle_t hDevice,
uint32_t *pCount,
@ -22,22 +18,14 @@ zetMetricGroupGet(
return L0::metricGroupGet(hDevice, pCount, phMetricGroups);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricGroupGetProperties(
zet_metric_group_handle_t hMetricGroup,
zet_metric_group_properties_t *pProperties) {
return L0::MetricGroup::fromHandle(hMetricGroup)->getProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupGetPropertiesExt(
zet_metric_group_handle_t hMetricGroup,
zet_metric_group_properties_ext_t *pProperties) {
return L0::MetricGroup::fromHandle(hMetricGroup)->getPropertiesExt(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricGet(
zet_metric_group_handle_t hMetricGroup,
uint32_t *pCount,
@ -45,32 +33,15 @@ zetMetricGet(
return L0::MetricGroup::fromHandle(hMetricGroup)->getMetric(pCount, phMetrics);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricGetProperties(
zet_metric_handle_t hMetric,
zet_metric_properties_t *pProperties) {
return L0::Metric::fromHandle(hMetric)->getProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGetPropertiesExt(
zet_metric_handle_t hMetric,
zet_metric_properties_ext_t *pProperties) {
return L0::Metric::fromHandle(hMetric)->getPropertiesExt(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricGroupCalculateMetricValues(
zet_metric_group_handle_t hMetricGroup,
size_t rawDataSize,
const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupCalculateMetricValuesExt(
zet_metric_group_handle_t hMetricGroup,
zet_metric_group_calculation_type_t type,
size_t rawDataSize,
@ -80,15 +51,7 @@ zetMetricGroupCalculateMetricValuesExt(
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetDeviceActivateMetricGroups(
zet_device_handle_t hDevice,
uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
return L0::Device::fromHandle(hDevice)->activateMetricGroups(count, phMetricGroups);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetContextActivateMetricGroups(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
@ -97,39 +60,6 @@ zetContextActivateMetricGroups(
return L0::Context::fromHandle(hContext)->activateMetricGroups(hDevice, count, phMetricGroups);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricTracerOpen(
zet_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t *pDesc,
ze_event_handle_t hNotificationEvent,
zet_metric_tracer_handle_t *phMetricTracer) {
return L0::metricTracerOpen(hDevice, hMetricGroup, pDesc, hNotificationEvent, phMetricTracer);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetCommandListAppendMetricTracerMarker(
ze_command_list_handle_t hCommandList,
zet_metric_tracer_handle_t hMetricTracer,
uint32_t value) {
return L0::CommandList::fromHandle(hCommandList)->appendMetricTracerMarker(hMetricTracer, value);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricTracerClose(
zet_metric_tracer_handle_t hMetricTracer) {
return L0::MetricTracer::fromHandle(hMetricTracer)->close();
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricTracerReadData(
zet_metric_tracer_handle_t hMetricTracer,
uint32_t maxReportCount,
size_t *pRawDataSize,
uint8_t *pRawData) {
return L0::MetricTracer::fromHandle(hMetricTracer)->readData(maxReportCount, pRawDataSize, pRawData);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricStreamerOpen(
zet_context_handle_t hContext,
@ -164,32 +94,23 @@ zetMetricStreamerReadData(
return L0::MetricStreamer::fromHandle(hMetricStreamer)->readData(maxReportCount, pRawDataSize, pRawData);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryPoolCreate(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) {
return L0::metricQueryPoolCreate(hDevice, hMetricGroup, desc, phMetricQueryPool);
return L0::metricQueryPoolCreate(hContext, hDevice, hMetricGroup, desc, phMetricQueryPool);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricQueryPoolCreateExt(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_ext_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) {
return L0::metricQueryPoolCreateExt(hContext, hDevice, hMetricGroup, desc, phMetricQueryPool);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryPoolDestroy(
zet_metric_query_pool_handle_t hMetricQueryPool) {
return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->destroy();
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryCreate(
zet_metric_query_pool_handle_t hMetricQueryPool,
uint32_t index,
@ -197,35 +118,27 @@ zetMetricQueryCreate(
return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->createMetricQuery(index, phMetricQuery);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryDestroy(
zet_metric_query_handle_t hMetricQuery) {
return L0::MetricQuery::fromHandle(hMetricQuery)->destroy();
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryReset(
zet_metric_query_handle_t hMetricQuery) {
return L0::MetricQuery::fromHandle(hMetricQuery)->reset();
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetCommandListAppendMetricQueryBegin(
zet_command_list_handle_t hCommandList,
zet_metric_query_handle_t hMetricQuery) {
return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryBegin(hMetricQuery);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetCommandListAppendMetricQueryEnd(
zet_command_list_handle_t hCommandList,
zet_metric_query_handle_t hMetricQuery,
ze_event_handle_t hCompletionEvent) {
return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryEnd(hMetricQuery, hCompletionEvent, 0, nullptr);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetCommandListAppendMetricQueryEndExt(
zet_command_list_handle_t hCommandList,
zet_metric_query_handle_t hMetricQuery,
ze_event_handle_t hSignalEvent,
@ -234,18 +147,16 @@ zetCommandListAppendMetricQueryEndExt(
return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryEnd(hMetricQuery, hSignalEvent, numWaitEvents, phWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetCommandListAppendMetricMemoryBarrier(
zet_command_list_handle_t hCommandList) {
return L0::CommandList::fromHandle(hCommandList)->appendMetricMemoryBarrier();
}
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetMetricQueryGetData(
zet_metric_query_handle_t hMetricQuery,
size_t *pRawDataSize,
uint8_t *pRawData) {
return L0::MetricQuery::fromHandle(hMetricQuery)->getData(pRawDataSize, pRawData);
}
} // extern C

10
level_zero/api/tools/zet_module.cpp
View File

@ -8,11 +8,7 @@
#include "level_zero/core/source/module/module.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zet_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetModuleGetDebugInfo(
zet_module_handle_t hModule,
zet_module_debug_info_format_t format,
@ -22,10 +18,8 @@ zetModuleGetDebugInfo(
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetKernelGetProfileInfoExt(
zetKernelGetProfileInfo(
zet_kernel_handle_t hKernel,
zet_profile_properties_t *pProfileProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // extern C

1405
level_zero/api/tools/zet_sysman.cpp
View File

File diff suppressed because it is too large Load Diff

2
level_zero/core/source/additional_kernel_properties.cpp
View File

@ -9,6 +9,6 @@
namespace L0 {
void DeviceImp::processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_kernel_properties_t *pKernelProperties) {
void DeviceImp::processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_module_properties_t *pKernelProperties) {
}
} // namespace L0

4
level_zero/core/source/builtin/builtin_functions_lib_impl.cpp
View File

@ -139,7 +139,7 @@ std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> BuiltinFunctionsLibImpl::l
ze_result_t res;
std::unique_ptr<Module> module;
ze_module_handle_t moduleHandle;
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
moduleDesc.pInputModule = reinterpret_cast<uint8_t *>(&builtInCode.resource[0]);
moduleDesc.inputSize = builtInCode.resource.size();
@ -150,7 +150,7 @@ std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> BuiltinFunctionsLibImpl::l
std::unique_ptr<Kernel> kernel;
ze_kernel_handle_t kernelHandle;
ze_kernel_desc_t kernelDesc = {ZE_KERNEL_DESC_VERSION_CURRENT};
ze_kernel_desc_t kernelDesc = {};
kernelDesc.pKernelName = builtInName;
res = module->createKernel(&kernelDesc, &kernelHandle);
DEBUG_BREAK_IF(res != ZE_RESULT_SUCCESS);

4
level_zero/core/source/cmdlist/cmdlist.h
View File

@ -16,8 +16,6 @@
#include <level_zero/ze_api.h>
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zet_api_ext.h"
#include <vector>
struct _ze_command_list_handle_t {};
@ -112,8 +110,6 @@ struct CommandList : _ze_command_list_handle_t {
virtual ze_result_t appendMetricMemoryBarrier() = 0;
virtual ze_result_t appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,
uint32_t value) = 0;
virtual ze_result_t appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
uint32_t value) = 0;
virtual ze_result_t appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) = 0;
virtual ze_result_t appendMetricQueryEnd(zet_metric_query_handle_t hMetricQuery, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;

8
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@ -61,7 +61,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::executeCommandListImmediate(bo
this->close();
ze_command_list_handle_t immediateHandle = this->toHandle();
this->cmdQImmediate->executeCommandLists(1, &immediateHandle, nullptr, performMigration);
this->cmdQImmediate->synchronize(std::numeric_limits<uint32_t>::max());
this->cmdQImmediate->synchronize(std::numeric_limits<uint64_t>::max());
this->reset();
return ZE_RESULT_SUCCESS;
@ -1301,7 +1301,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
NEO::EncodeMiFlushDW<GfxFamily>::programMiFlushDw(*commandContainer.getCommandStream(), event->getGpuAddress(), Event::STATE_SIGNALED, false, true);
} else {
NEO::PipeControlArgs args;
args.dcFlushEnable = (event->signalScope == ZE_EVENT_SCOPE_FLAG_NONE) ? false : true;
args.dcFlushEnable = (!event->signalScope) ? false : true;
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
*commandContainer.getCommandStream(), POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
event->getGpuAddress(), Event::STATE_SIGNALED,
@ -1336,7 +1336,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
eventStateClear,
COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD);
bool dcFlushEnable = (event->waitScope == ZE_EVENT_SCOPE_FLAG_NONE) ? false : true;
bool dcFlushEnable = (!event->waitScope) ? false : true;
if (dcFlushEnable) {
if (isCopyOnlyCmdList) {
NEO::EncodeMiFlushDW<GfxFamily>::programMiFlushDw(*commandContainer.getCommandStream(), 0, 0, false, false);
@ -1389,7 +1389,7 @@ void CommandListCoreFamily<gfxCoreFamily>::appendEventForProfiling(ze_event_hand
NEO::EncodeStoreMMIO<GfxFamily>::encode(*commandContainer.getCommandStream(),
GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW, contextEndAddr);
args.dcFlushEnable = (event->signalScope == ZE_EVENT_SCOPE_FLAG_NONE) ? false : true;
args.dcFlushEnable = (!event->signalScope) ? false : true;
if (args.dcFlushEnable) {
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControl(*commandContainer.getCommandStream(), args);
}

8
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@ -40,14 +40,6 @@ ze_result_t CommandListImp::appendMetricStreamerMarker(zet_metric_streamer_handl
return MetricQuery::appendStreamerMarker(*this, hMetricStreamer, value);
}
ze_result_t CommandListImp::appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
uint32_t value) {
zet_metric_streamer_handle_t hMetricStreamer = reinterpret_cast<zet_metric_streamer_handle_t>(hMetricTracer);
return MetricQuery::appendStreamerMarker(*this, hMetricStreamer, value);
}
ze_result_t CommandListImp::appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) {
return MetricQuery::fromHandle(hMetricQuery)->appendBegin(*this);
}

2
level_zero/core/source/cmdlist/cmdlist_imp.h
View File

@ -20,8 +20,6 @@ struct CommandListImp : CommandList {
ze_result_t appendMetricMemoryBarrier() override;
ze_result_t appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,
uint32_t value) override;
ze_result_t appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
uint32_t value) override;
ze_result_t appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) override;
ze_result_t appendMetricQueryEnd(zet_metric_query_handle_t hMetricQuery, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;

6
level_zero/core/source/cmdqueue/cmdqueue.cpp
View File

@ -60,15 +60,15 @@ void CommandQueueImp::submitBatchBuffer(size_t offset, NEO::ResidencyContainer &
buffers.setCurrentFlushStamp(csr->obtainCurrentFlushStamp());
}
ze_result_t CommandQueueImp::synchronize(uint32_t timeout) {
ze_result_t CommandQueueImp::synchronize(uint64_t timeout) {
return synchronizeByPollingForTaskCount(timeout);
}
ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint32_t timeout) {
ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint64_t timeout) {
UNRECOVERABLE_IF(csr == nullptr);
auto taskCountToWait = this->taskCount;
bool enableTimeout = (timeout != std::numeric_limits<uint32_t>::max());
bool enableTimeout = (timeout != std::numeric_limits<uint64_t>::max());
csr->waitForCompletionWithTimeout(enableTimeout, timeout, this->taskCount);
if (*csr->getTagAddress() < taskCountToWait) {

5
level_zero/core/source/cmdqueue/cmdqueue.h
View File

@ -8,8 +8,7 @@
#pragma once
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_common.h>
#include <level_zero/ze_fence.h>
#include <level_zero/ze_api.h>
#include <atomic>
@ -39,7 +38,7 @@ struct CommandQueue : _ze_command_queue_handle_t {
virtual ze_result_t executeCommands(uint32_t numCommands,
void *phCommands,
ze_fence_handle_t hFence) = 0;
virtual ze_result_t synchronize(uint32_t timeout) = 0;
virtual ze_result_t synchronize(uint64_t timeout) = 0;
static CommandQueue *create(uint32_t productFamily, Device *device, NEO::CommandStreamReceiver *csr,
const ze_command_queue_desc_t *desc, bool isCopyOnly);

2
level_zero/core/source/cmdqueue/cmdqueue_hw.inl
View File

@ -339,7 +339,7 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::executeCommandLists(
csr->makeSurfacePackNonResident(residencyContainer);
if (getSynchronousMode() == ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS) {
this->synchronize(std::numeric_limits<uint32_t>::max());
this->synchronize(std::numeric_limits<uint64_t>::max());
}
return ZE_RESULT_SUCCESS;

4
level_zero/core/source/cmdqueue/cmdqueue_imp.h
View File

@ -66,7 +66,7 @@ struct CommandQueueImp : public CommandQueue {
ze_result_t destroy() override;
ze_result_t synchronize(uint32_t timeout) override;
ze_result_t synchronize(uint64_t timeout) override;
void initialize(bool copyOnly);
@ -83,7 +83,7 @@ struct CommandQueueImp : public CommandQueue {
protected:
void submitBatchBuffer(size_t offset, NEO::ResidencyContainer &residencyContainer, void *endingCmdPtr);
ze_result_t synchronizeByPollingForTaskCount(uint32_t timeout);
ze_result_t synchronizeByPollingForTaskCount(uint64_t timeout);
void printFunctionsPrintfOutput();

21
level_zero/core/source/context/context.h
View File

@ -9,9 +9,7 @@
#include "level_zero/core/source/driver/driver_handle.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
#include "third_party/level_zero/zet_api_ext.h"
#include <level_zero/zet_api.h>
struct _ze_context_handle_t {
virtual ~_ze_context_handle_t() = default;
@ -25,17 +23,17 @@ struct Context : _ze_context_handle_t {
virtual ze_result_t destroy() = 0;
virtual ze_result_t getStatus() = 0;
virtual DriverHandle *getDriverHandle() = 0;
virtual ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags,
virtual ze_result_t allocHostMem(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr) = 0;
virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment, void **ptr) = 0;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags,
size_t size,
size_t alignment,
void **ptr) = 0;
@ -98,6 +96,15 @@ struct Context : _ze_context_handle_t {
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize) = 0;
virtual ze_result_t openEventPoolIpcHandle(ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) = 0;
virtual ze_result_t createEventPool(const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) = 0;
virtual ze_result_t createImage(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) = 0;
static Context *fromHandle(ze_context_handle_t handle) { return static_cast<Context *>(handle); }
inline ze_context_handle_t toHandle() { return this; }

30
level_zero/core/source/context/context_imp.cpp
View File

@ -29,7 +29,7 @@ ContextImp::ContextImp(DriverHandle *driverHandle) {
this->driverHandle = driverHandle;
}
ze_result_t ContextImp::allocHostMem(ze_host_mem_alloc_flag_t flags,
ze_result_t ContextImp::allocHostMem(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr) {
@ -41,7 +41,7 @@ ze_result_t ContextImp::allocHostMem(ze_host_mem_alloc_flag_t flags,
}
ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment, void **ptr) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
@ -53,8 +53,8 @@ ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
}
ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags,
size_t size,
size_t alignment,
void **ptr) {
@ -100,7 +100,7 @@ ze_result_t ContextImp::openIpcMemHandle(ze_device_handle_t hDevice,
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->openIpcMemHandle(hDevice,
handle,
ZE_IPC_MEMORY_FLAG_NONE,
ZE_IPC_MEMORY_FLAG_TBD,
ptr);
}
@ -203,4 +203,24 @@ ze_result_t ContextImp::getVirtualMemAccessAttribute(const void *ptr,
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t ContextImp::openEventPoolIpcHandle(ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->openEventPoolIpcHandle(hIpc, phEventPool);
}
ze_result_t ContextImp::createEventPool(const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) {
DEBUG_BREAK_IF(nullptr == this->driverHandle);
return this->driverHandle->createEventPool(desc, numDevices, phDevices, phEventPool);
}
ze_result_t ContextImp::createImage(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) {
return L0::Device::fromHandle(hDevice)->createImage(desc, phImage);
}
} // namespace L0

17
level_zero/core/source/context/context_imp.h
View File

@ -18,17 +18,17 @@ struct ContextImp : Context {
ze_result_t destroy() override;
ze_result_t getStatus() override;
DriverHandle *getDriverHandle() override;
ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags,
ze_result_t allocHostMem(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr) override;
ze_result_t allocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment, void **ptr) override;
ze_result_t allocSharedMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags,
size_t size,
size_t alignment,
void **ptr) override;
@ -91,6 +91,15 @@ struct ContextImp : Context {
size_t size,
ze_memory_access_attribute_t *access,
size_t *outSize) override;
ze_result_t openEventPoolIpcHandle(ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) override;
ze_result_t createEventPool(const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) override;
ze_result_t createImage(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage) override;
protected:
DriverHandle *driverHandle = nullptr;

8
level_zero/core/source/device/device.h
View File

@ -19,8 +19,6 @@
#include <level_zero/ze_api.h>
#include <level_zero/zet_api.h>
#include "third_party/level_zero/ze_api_ext.h"
struct _ze_device_handle_t {};
namespace NEO {
class Device;
@ -59,15 +57,15 @@ struct Device : _ze_device_handle_t {
virtual ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) = 0;
virtual ze_result_t getP2PProperties(ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) = 0;
virtual ze_result_t getKernelProperties(ze_device_kernel_properties_t *pKernelProperties) = 0;
virtual ze_result_t getKernelProperties(ze_device_module_properties_t *pKernelProperties) = 0;
virtual ze_result_t getMemoryProperties(uint32_t *pCount, ze_device_memory_properties_t *pMemProperties) = 0;
virtual ze_result_t getMemoryAccessProperties(ze_device_memory_access_properties_t *pMemAccessProperties) = 0;
virtual ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) = 0;
virtual ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) = 0;
virtual ze_result_t makeImageResident(ze_image_handle_t hImage) = 0;
virtual ze_result_t makeMemoryResident(void *ptr, size_t size) = 0;
virtual ze_result_t setIntermediateCacheConfig(ze_cache_config_t cacheConfig) = 0;
virtual ze_result_t setLastLevelCacheConfig(ze_cache_config_t cacheConfig) = 0;
virtual ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) = 0;
virtual ze_result_t setLastLevelCacheConfig(ze_cache_config_flags_t cacheConfig) = 0;
virtual ze_result_t getCacheProperties(ze_device_cache_properties_t *pCacheProperties) = 0;
virtual ze_result_t imageGetProperties(const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) = 0;
virtual ze_result_t getDeviceImageProperties(ze_device_image_properties_t *pDeviceImageProperties) = 0;

171
level_zero/core/source/device/device_imp.cpp
View File

@ -86,9 +86,8 @@ ze_result_t DeviceImp::createCommandList(const ze_command_list_desc_t *desc,
ze_command_list_handle_t *commandList) {
auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
bool useBliter = false;
auto ret = isCreatedCommandListCopyOnly(desc, &useBliter, ZE_COMMAND_LIST_FLAG_COPY_ONLY);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
if (desc->commandQueueGroupOrdinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
useBliter = true;
}
*commandList = CommandList::create(productFamily, this, useBliter);
@ -100,11 +99,9 @@ ze_result_t DeviceImp::createCommandListImmediate(const ze_command_queue_desc_t
auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
bool useBliter = false;
auto ret = isCreatedCommandListCopyOnly(desc, &useBliter, ZE_COMMAND_QUEUE_FLAG_COPY_ONLY);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
if (desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
useBliter = true;
}
*phCommandList = CommandList::createImmediate(productFamily, this, desc, false, useBliter);
return ZE_RESULT_SUCCESS;
@ -116,27 +113,26 @@ ze_result_t DeviceImp::createCommandQueue(const ze_command_queue_desc_t *desc,
NEO::CommandStreamReceiver *csr = nullptr;
bool useBliter = false;
auto ret = isCreatedCommandListCopyOnly(desc, &useBliter, ZE_COMMAND_QUEUE_FLAG_COPY_ONLY);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
if (useBliter) {
if (desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
auto &selectorCopyEngine = this->neoDevice->getDeviceById(0)->getSelectorCopyEngine();
csr = this->neoDevice->getDeviceById(0)->getEngine(NEO::EngineHelpers::getBcsEngineType(neoDevice->getHardwareInfo(), selectorCopyEngine), false).commandStreamReceiver;
useBliter = true;
} else {
const auto &hardwareInfo = this->neoDevice->getHardwareInfo();
auto &hwHelper = NEO::HwHelper::get(hardwareInfo.platform.eRenderCoreFamily);
if (desc->ordinal >= NEO::HwHelper::getEnginesCount(this->getNEODevice()->getHardwareInfo())) {
if (desc->ordinal >= static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
uint32_t engineIndex = hwHelper.getComputeEngineIndexByOrdinal(hardwareInfo, desc->ordinal);
if (this->getNEODevice()->getNumAvailableDevices() > 1) {
csr = this->neoDevice->getDeviceById(0)->getEngine(engineIndex).commandStreamReceiver;
if (desc->index >= this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
csr = this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
} else {
csr = this->neoDevice->getEngine(engineIndex).commandStreamReceiver;
if (desc->index >= this->neoDevice->getEngineGroups()[desc->ordinal].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
csr = this->neoDevice->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
}
UNRECOVERABLE_IF(csr == nullptr);
@ -266,9 +262,7 @@ ze_result_t DeviceImp::getComputeProperties(ze_device_compute_properties_t *pCom
ze_result_t DeviceImp::getP2PProperties(ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) {
pP2PProperties->accessSupported = true;
pP2PProperties->atomicsSupported = false;
pP2PProperties->flags = 0;
return ZE_RESULT_SUCCESS;
}
@ -297,28 +291,26 @@ ze_result_t DeviceImp::getMemoryProperties(uint32_t *pCount, ze_device_memory_pr
ze_result_t DeviceImp::getMemoryAccessProperties(ze_device_memory_access_properties_t *pMemAccessProperties) {
pMemAccessProperties->hostAllocCapabilities =
static_cast<ze_memory_access_capabilities_t>(ZE_MEMORY_ACCESS | ZE_MEMORY_ATOMIC_ACCESS);
ZE_MEMORY_ACCESS_CAP_FLAG_RW | ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC;
pMemAccessProperties->deviceAllocCapabilities =
static_cast<ze_memory_access_capabilities_t>(ZE_MEMORY_ACCESS | ZE_MEMORY_ATOMIC_ACCESS);
ZE_MEMORY_ACCESS_CAP_FLAG_RW | ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC;
pMemAccessProperties->sharedSingleDeviceAllocCapabilities =
static_cast<ze_memory_access_capabilities_t>(ZE_MEMORY_ACCESS | ZE_MEMORY_ATOMIC_ACCESS);
pMemAccessProperties->sharedCrossDeviceAllocCapabilities =
ze_memory_access_capabilities_t{};
pMemAccessProperties->sharedSystemAllocCapabilities =
ze_memory_access_capabilities_t{};
ZE_MEMORY_ACCESS_CAP_FLAG_RW | ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC;
pMemAccessProperties->sharedCrossDeviceAllocCapabilities = 0;
pMemAccessProperties->sharedSystemAllocCapabilities = 0;
return ZE_RESULT_SUCCESS;
}
static constexpr ze_fp_capabilities_t defaultFpFlags = static_cast<ze_fp_capabilities_t>(ZE_FP_CAPS_ROUND_TO_NEAREST |
ZE_FP_CAPS_ROUND_TO_ZERO |
ZE_FP_CAPS_ROUND_TO_INF |
ZE_FP_CAPS_INF_NAN |
ZE_FP_CAPS_DENORM |
ZE_FP_CAPS_FMA);
static constexpr ze_device_fp_flags_t defaultFpFlags = static_cast<ze_device_fp_flags_t>(ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST |
ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO |
ZE_DEVICE_FP_FLAG_ROUND_TO_INF |
ZE_DEVICE_FP_FLAG_INF_NAN |
ZE_DEVICE_FP_FLAG_DENORM |
ZE_DEVICE_FP_FLAG_FMA);
ze_result_t DeviceImp::getKernelProperties(ze_device_kernel_properties_t *pKernelProperties) {
memset(pKernelProperties, 0, sizeof(ze_device_kernel_properties_t));
ze_result_t DeviceImp::getKernelProperties(ze_device_module_properties_t *pKernelProperties) {
memset(pKernelProperties, 0, sizeof(ze_device_module_properties_t));
const auto &hardwareInfo = this->neoDevice->getHardwareInfo();
const auto &deviceInfo = this->neoDevice->getDeviceInfo();
auto &hwHelper = NEO::HwHelper::get(hardwareInfo.platform.eRenderCoreFamily);
@ -336,18 +328,23 @@ ze_result_t DeviceImp::getKernelProperties(ze_device_kernel_properties_t *pKerne
return ZE_RESULT_ERROR_UNKNOWN;
}
pKernelProperties->fp16Supported = true;
pKernelProperties->int64AtomicsSupported = hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics;
pKernelProperties->halfFpCapabilities = defaultFpFlags;
pKernelProperties->flags = ZE_DEVICE_MODULE_FLAG_FP16;
if (hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS;
}
pKernelProperties->fp16flags = defaultFpFlags;
pKernelProperties->fp32flags = defaultFpFlags;
if (NEO::DebugManager.flags.OverrideDefaultFP64Settings.get() == 1) {
pKernelProperties->fp64Supported = true;
pKernelProperties->singleFpCapabilities = ZE_FP_CAPS_ROUNDED_DIVIDE_SQRT;
pKernelProperties->doubleFpCapabilities = defaultFpFlags;
pKernelProperties->fp64flags = defaultFpFlags | ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;
} else {
pKernelProperties->fp64Supported = hardwareInfo.capabilityTable.ftrSupportsFP64;
pKernelProperties->singleFpCapabilities = hardwareInfo.capabilityTable.ftrSupports64BitMath ? ZE_FP_CAPS_ROUNDED_DIVIDE_SQRT : ZE_FP_CAPS_NONE;
pKernelProperties->doubleFpCapabilities = hardwareInfo.capabilityTable.ftrSupportsFP64 ? defaultFpFlags : ZE_FP_CAPS_NONE;
pKernelProperties->fp64flags = 0;
if (hardwareInfo.capabilityTable.ftrSupportsFP64) {
pKernelProperties->fp64flags |= defaultFpFlags;
if (hardwareInfo.capabilityTable.ftrSupports64BitMath) {
pKernelProperties->fp64flags |= ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;
}
}
}
pKernelProperties->nativeKernelSupported.id[0] = 0;
@ -372,6 +369,8 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties)
pDeviceProperties->deviceId = hardwareInfo.platform.usDeviceID;
pDeviceProperties->flags = 0u;
uint32_t rootDeviceIndex = this->neoDevice->getRootDeviceIndex();
memset(pDeviceProperties->uuid.id, 0, ZE_MAX_DEVICE_UUID_SIZE);
@ -379,23 +378,13 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties)
memcpy_s(pDeviceProperties->uuid.id + sizeof(uint32_t), sizeof(uint32_t), &pDeviceProperties->deviceId, sizeof(pDeviceProperties->deviceId));
memcpy_s(pDeviceProperties->uuid.id + (2 * sizeof(uint32_t)), sizeof(uint32_t), &rootDeviceIndex, sizeof(rootDeviceIndex));
pDeviceProperties->isSubdevice = isSubdevice;
pDeviceProperties->subdeviceId = isSubdevice ? static_cast<NEO::SubDevice *>(neoDevice)->getSubDeviceIndex() : 0;
pDeviceProperties->coreClockRate = deviceInfo.maxClockFrequency;
pDeviceProperties->unifiedMemorySupported = true;
pDeviceProperties->eccMemorySupported = this->neoDevice->getDeviceInfo().errorCorrectionSupport;
pDeviceProperties->onDemandPageFaultsSupported = hardwareInfo.capabilityTable.supportsOnDemandPageFaults;
pDeviceProperties->maxCommandQueues = 1;
pDeviceProperties->numAsyncComputeEngines = NEO::HwHelper::getEnginesCount(hardwareInfo);
pDeviceProperties->numAsyncCopyEngines = NEO::HwHelper::getCopyEnginesCount(hardwareInfo);
if (hardwareInfo.capabilityTable.supportsOnDemandPageFaults) {
pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_ONDEMANDPAGING;
}
pDeviceProperties->maxCommandQueuePriority = 0;
@ -459,29 +448,18 @@ ze_result_t DeviceImp::makeMemoryResident(void *ptr, size_t size) {
return changeMemoryOperationStatusToL0ResultType(success);
}
ze_result_t DeviceImp::setIntermediateCacheConfig(ze_cache_config_t cacheConfig) {
ze_result_t DeviceImp::setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t DeviceImp::setLastLevelCacheConfig(ze_cache_config_t cacheConfig) {
ze_result_t DeviceImp::setLastLevelCacheConfig(ze_cache_config_flags_t cacheConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t DeviceImp::getCacheProperties(ze_device_cache_properties_t *pCacheProperties) {
const auto &hardwareInfo = this->getHwInfo();
auto &hwHelper = NEO::HwHelper::get(hardwareInfo.platform.eRenderCoreFamily);
pCacheProperties->intermediateCacheControlSupported = false;
pCacheProperties->intermediateCacheSize = getIntermediateCacheSize(hardwareInfo);
pCacheProperties->intermediateCachelineSize = 0;
pCacheProperties->lastLevelCacheSizeControlSupported = hwHelper.isL3Configurable(hardwareInfo);
pCacheProperties->lastLevelCacheSize = static_cast<size_t>(hardwareInfo.gtSystemInfo.L3CacheSizeInKb * KB);
pCacheProperties->lastLevelCachelineSize = this->neoDevice->getDeviceInfo().globalMemCachelineSize;
pCacheProperties->cacheSize = getIntermediateCacheSize(hardwareInfo);
pCacheProperties->flags = 0;
return ZE_RESULT_SUCCESS;
}
@ -491,9 +469,9 @@ ze_result_t DeviceImp::imageGetProperties(const ze_image_desc_t *desc,
const auto &deviceInfo = this->neoDevice->getDeviceInfo();
if (deviceInfo.imageSupport) {
pImageProperties->samplerFilterFlags = ZE_IMAGE_SAMPLER_FILTER_FLAGS_LINEAR;
pImageProperties->samplerFilterFlags = ZE_IMAGE_SAMPLER_FILTER_FLAG_LINEAR;
} else {
pImageProperties->samplerFilterFlags = ZE_IMAGE_SAMPLER_FILTER_FLAGS_NONE;
pImageProperties->samplerFilterFlags = 0;
}
return ZE_RESULT_SUCCESS;
@ -502,7 +480,6 @@ ze_result_t DeviceImp::imageGetProperties(const ze_image_desc_t *desc,
ze_result_t DeviceImp::getDeviceImageProperties(ze_device_image_properties_t *pDeviceImageProperties) {
const auto &deviceInfo = this->neoDevice->getDeviceInfo();
pDeviceImageProperties->supported = deviceInfo.imageSupport;
pDeviceImageProperties->maxImageDims1D = static_cast<uint32_t>(deviceInfo.image2DMaxWidth);
pDeviceImageProperties->maxImageDims2D = static_cast<uint32_t>(deviceInfo.image2DMaxHeight);
pDeviceImageProperties->maxImageDims3D = static_cast<uint32_t>(deviceInfo.image3DMaxDepth);
@ -567,47 +544,12 @@ ze_result_t DeviceImp::registerCLMemory(cl_context context, cl_mem mem, void **p
ze_result_t DeviceImp::registerCLProgram(cl_context context, cl_program program,
ze_module_handle_t *phModule) {
NEO::Program *neoProgram = static_cast<NEO::Program *>(program);
if (neoProgram->getIsSpirV()) {
size_t deviceBinarySize = 0;
if (0 != neoProgram->getInfo(CL_PROGRAM_BINARY_SIZES, sizeof(deviceBinarySize), &deviceBinarySize, nullptr)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
std::vector<uint8_t> deviceBinary;
deviceBinary.resize(deviceBinarySize);
auto deviceBinaryPtr = deviceBinary.data();
if (0 != neoProgram->getInfo(CL_PROGRAM_BINARIES, sizeof(void *), &deviceBinaryPtr, nullptr)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
ze_module_desc_t module_desc;
module_desc.version = ZE_MODULE_DESC_VERSION_CURRENT;
module_desc.format = ZE_MODULE_FORMAT_NATIVE;
module_desc.inputSize = deviceBinarySize;
module_desc.pInputModule = deviceBinary.data();
module_desc.pBuildFlags = nullptr;
return createModule(&module_desc, phModule, nullptr);
} else {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t DeviceImp::registerCLCommandQueue(cl_context context, cl_command_queue commandQueue,
ze_command_queue_handle_t *phCommandQueue) {
ze_command_queue_desc_t desc;
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
desc.flags = ZE_COMMAND_QUEUE_FLAG_NONE;
desc.mode = ZE_COMMAND_QUEUE_MODE_DEFAULT;
desc.priority = ZE_COMMAND_QUEUE_PRIORITY_NORMAL;
auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
auto csr = neoDevice->getDefaultEngine().commandStreamReceiver;
*phCommandQueue = CommandQueue::create(productFamily, this, csr, &desc, false);
return ZE_RESULT_SUCCESS;
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
const NEO::HardwareInfo &DeviceImp::getHwInfo() const { return neoDevice->getHardwareInfo(); }
@ -684,7 +626,6 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
if (supportDualStorageSharedMemory) {
ze_command_queue_desc_t cmdQueueDesc;
cmdQueueDesc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
cmdQueueDesc.ordinal = 0;
cmdQueueDesc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
device->pageFaultCommandList =

8
level_zero/core/source/device/device_imp.h
View File

@ -34,15 +34,15 @@ struct DeviceImp : public Device {
ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) override;
ze_result_t getP2PProperties(ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) override;
ze_result_t getKernelProperties(ze_device_kernel_properties_t *pKernelProperties) override;
ze_result_t getKernelProperties(ze_device_module_properties_t *pKernelProperties) override;
ze_result_t getMemoryProperties(uint32_t *pCount, ze_device_memory_properties_t *pMemProperties) override;
ze_result_t getMemoryAccessProperties(ze_device_memory_access_properties_t *pMemAccessProperties) override;
ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) override;
ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) override;
ze_result_t makeImageResident(ze_image_handle_t hImage) override;
ze_result_t makeMemoryResident(void *ptr, size_t size) override;
ze_result_t setIntermediateCacheConfig(ze_cache_config_t cacheConfig) override;
ze_result_t setLastLevelCacheConfig(ze_cache_config_t cacheConfig) override;
ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) override;
ze_result_t setLastLevelCacheConfig(ze_cache_config_flags_t cacheConfig) override;
ze_result_t getCacheProperties(ze_device_cache_properties_t *pCacheProperties) override;
ze_result_t imageGetProperties(const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) override;
ze_result_t getDeviceImageProperties(ze_device_image_properties_t *pDeviceImageProperties) override;
@ -73,7 +73,7 @@ struct DeviceImp : public Device {
const NEO::DeviceInfo &getDeviceInfo() const override;
NEO::Device *getNEODevice() override;
void activateMetricGroups() override;
void processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_kernel_properties_t *pKernelProperties);
void processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_module_properties_t *pKernelProperties);
NEO::GraphicsAllocation *getDebugSurface() const override { return debugSurface; }
void setDebugSurface(NEO::GraphicsAllocation *debugSurface) { this->debugSurface = debugSurface; };
~DeviceImp() override;

4
level_zero/core/source/driver/driver.cpp
View File

@ -78,7 +78,7 @@ void DriverImp::initialize(ze_result_t *result) {
ze_result_t DriverImp::initStatus(ZE_RESULT_ERROR_UNINITIALIZED);
ze_result_t DriverImp::driverInit(ze_init_flag_t flag) {
ze_result_t DriverImp::driverInit(ze_init_flags_t flags) {
std::call_once(initDriverOnce, [this]() {
ze_result_t result;
this->initialize(&result);
@ -111,6 +111,6 @@ ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandle
static DriverImp driverImp;
Driver *Driver::driver = &driverImp;
ze_result_t init(ze_init_flag_t flag) { return Driver::get()->driverInit(flag); }
ze_result_t init(ze_init_flags_t flags) { return Driver::get()->driverInit(flags); }
} // namespace L0

4
level_zero/core/source/driver/driver.h
View File

@ -13,7 +13,7 @@
namespace L0 {
struct Driver {
virtual ze_result_t driverInit(_ze_init_flag_t) = 0;
virtual ze_result_t driverInit(ze_init_flags_t flags) = 0;
virtual void initialize(ze_result_t *result) = 0;
static Driver *get() { return driver; }
virtual ~Driver() = default;
@ -22,7 +22,7 @@ struct Driver {
static Driver *driver;
};
ze_result_t init(_ze_init_flag_t);
ze_result_t init(ze_init_flags_t);
ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDrivers);
extern uint32_t driverCount;

10
level_zero/core/source/driver/driver_handle.h
View File

@ -13,8 +13,6 @@
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
struct _ze_driver_handle_t {
virtual ~_ze_driver_handle_t() = default;
};
@ -37,13 +35,13 @@ struct DriverHandle : _ze_driver_handle_t {
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) = 0;
virtual ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr) = 0;
virtual ze_result_t allocHostMem(ze_host_mem_alloc_flags_t flags, size_t size, size_t alignment, void **ptr) = 0;
virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size,
virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t flags, size_t size,
size_t alignment, void **ptr) = 0;
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags, size_t size, size_t alignment,
virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
void **ptr) = 0;
virtual ze_result_t freeMem(const void *ptr) = 0;
virtual NEO::MemoryManager *getMemoryManager() = 0;

4
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@ -69,8 +69,8 @@ ze_result_t DriverHandleImp::getProperties(ze_driver_properties_t *properties) {
}
ze_result_t DriverHandleImp::getIPCProperties(ze_driver_ipc_properties_t *pIPCProperties) {
pIPCProperties->eventsSupported = false;
pIPCProperties->memsSupported = true;
pIPCProperties->flags = ZE_IPC_PROPERTY_FLAG_MEMORY;
return ZE_RESULT_SUCCESS;
}

9
level_zero/core/source/driver/driver_handle_imp.h
View File

@ -10,6 +10,7 @@
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/event/event.h"
#include "level_zero/core/source/get_extension_function_lookup_map.h"
namespace L0 {
@ -28,13 +29,13 @@ struct DriverHandleImp : public DriverHandle {
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) override;
ze_result_t allocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr) override;
ze_result_t allocHostMem(ze_host_mem_alloc_flags_t flags, size_t size, size_t alignment, void **ptr) override;
ze_result_t allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size,
ze_result_t allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t flags, size_t size,
size_t alignment, void **ptr) override;
ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags, size_t size, size_t alignment,
ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
void **ptr) override;
ze_result_t getMemAddressRange(const void *ptr, void **pBase, size_t *pSize) override;

2
level_zero/core/source/driver/driver_imp.h
View File

@ -16,7 +16,7 @@ namespace L0 {
class DriverImp : public Driver {
public:
ze_result_t driverInit(_ze_init_flag_t) override;
ze_result_t driverInit(ze_init_flags_t flags) override;
void initialize(ze_result_t *result) override;

49
level_zero/core/source/event/event.cpp
View File

@ -36,7 +36,7 @@ struct EventImp : public Event {
ze_result_t hostSignal() override;
ze_result_t hostSynchronize(uint32_t timeout) override;
ze_result_t hostSynchronize(uint64_t timeout) override;
ze_result_t queryStatus() override {
uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
@ -62,8 +62,6 @@ struct EventImp : public Event {
ze_result_t reset() override;
ze_result_t getTimestamp(ze_event_timestamp_type_t timestampType, void *dstptr) override;
ze_result_t queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) override;
Device *device;
@ -76,8 +74,8 @@ struct EventImp : public Event {
};
struct EventPoolImp : public EventPool {
EventPoolImp(DriverHandle *driver, uint32_t numDevices, ze_device_handle_t *phDevices, uint32_t numEvents, ze_event_pool_flag_t flags) : numEvents(numEvents) {
if (flags & ZE_EVENT_POOL_FLAG_TIMESTAMP) {
EventPoolImp(DriverHandle *driver, uint32_t numDevices, ze_device_handle_t *phDevices, uint32_t numEvents, ze_event_pool_flags_t flags) : numEvents(numEvents) {
if (flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP) {
isEventPoolUsedForTimestamp = true;
}
ze_device_handle_t hDevice;
@ -205,7 +203,7 @@ ze_result_t EventImp::hostEventSetValueTimestamps(uint32_t eventVal) {
auto eventTsSetFunc = [&](auto tsAddr) {
auto tsptr = reinterpret_cast<void *>(tsAddr);
memcpy_s(tsptr, sizeof(uint32_t), static_cast<void *>(&eventVal), sizeof(uint32_t));
if (signalScopeFlag != ZE_EVENT_SCOPE_FLAG_NONE) {
if (!signalScopeFlag) {
NEO::CpuIntrinsics::clFlush(tsptr);
}
};
@ -231,7 +229,7 @@ ze_result_t EventImp::hostEventSetValue(uint32_t eventVal) {
makeAllocationResident();
if (this->signalScope != ZE_EVENT_SCOPE_FLAG_NONE) {
if (!this->signalScope) {
NEO::CpuIntrinsics::clFlush(hostAddr);
}
@ -242,9 +240,9 @@ ze_result_t EventImp::hostSignal() {
return hostEventSetValue(Event::STATE_SIGNALED);
}
ze_result_t EventImp::hostSynchronize(uint32_t timeout) {
ze_result_t EventImp::hostSynchronize(uint64_t timeout) {
std::chrono::high_resolution_clock::time_point time1, time2;
int64_t timeDiff = 0;
uint64_t timeDiff = 0;
ze_result_t ret = ZE_RESULT_NOT_READY;
if (this->csr->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
@ -284,39 +282,6 @@ ze_result_t EventImp::reset() {
return hostEventSetValue(Event::STATE_INITIAL);
}
ze_result_t EventImp::getTimestamp(ze_event_timestamp_type_t timestampType, void *dstptr) {
auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
uint64_t tsAddr = 0u;
constexpr uint64_t tsMask = (1ull << 32) - 1;
uint64_t tsData = Event::STATE_INITIAL & tsMask;
if (!this->isTimestampEvent)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
// Ensure timestamps have been written
if (queryStatus() != ZE_RESULT_SUCCESS) {
memcpy_s(dstptr, sizeof(uint64_t), static_cast<void *>(&tsData), sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
if (timestampType == ZE_EVENT_TIMESTAMP_CONTEXT_START) {
tsAddr = baseAddr + offsetof(KernelTimestampEvent, contextStart);
} else if (timestampType == ZE_EVENT_TIMESTAMP_GLOBAL_START) {
tsAddr = baseAddr + offsetof(KernelTimestampEvent, globalStart);
} else if (timestampType == ZE_EVENT_TIMESTAMP_CONTEXT_END) {
tsAddr = baseAddr + offsetof(KernelTimestampEvent, contextEnd);
} else {
tsAddr = baseAddr + offsetof(KernelTimestampEvent, globalEnd);
}
memcpy_s(static_cast<void *>(&tsData), sizeof(uint32_t), reinterpret_cast<void *>(tsAddr), sizeof(uint32_t));
tsData &= tsMask;
memcpy_s(dstptr, sizeof(uint64_t), static_cast<void *>(&tsData), sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
ze_result_t EventImp::queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) {
auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
constexpr uint64_t tsMask = (1ull << 32) - 1;

9
level_zero/core/source/event/event.h
View File

@ -10,7 +10,7 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include <level_zero/ze_event.h>
#include <level_zero/ze_api.h>
struct _ze_event_handle_t {};
@ -25,10 +25,9 @@ struct Event : _ze_event_handle_t {
virtual ~Event() = default;
virtual ze_result_t destroy();
virtual ze_result_t hostSignal() = 0;
virtual ze_result_t hostSynchronize(uint32_t timeout) = 0;
virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;
virtual ze_result_t queryStatus() = 0;
virtual ze_result_t reset() = 0;
virtual ze_result_t getTimestamp(ze_event_timestamp_type_t timestampType, void *dstptr) = 0;
virtual ze_result_t queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) = 0;
enum State : uint32_t {
@ -51,8 +50,8 @@ struct Event : _ze_event_handle_t {
void *hostAddress = nullptr;
uint64_t gpuAddress;
ze_event_scope_flag_t signalScope; // Saving scope for use later
ze_event_scope_flag_t waitScope;
ze_event_scope_flags_t signalScope; // Saving scope for use later
ze_event_scope_flags_t waitScope;
bool isTimestampEvent = false;

6
level_zero/core/source/fence/fence.cpp
View File

@ -61,9 +61,9 @@ ze_result_t FenceImp::reset() {
return ZE_RESULT_SUCCESS;
}
ze_result_t FenceImp::hostSynchronize(uint32_t timeout) {
ze_result_t FenceImp::hostSynchronize(uint64_t timeout) {
std::chrono::high_resolution_clock::time_point time1, time2;
int64_t timeDiff = 0;
uint64_t timeDiff = 0;
ze_result_t ret = ZE_RESULT_NOT_READY;
if (cmdQueue->getCsr()->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
@ -84,7 +84,7 @@ ze_result_t FenceImp::hostSynchronize(uint32_t timeout) {
std::this_thread::yield();
NEO::CpuIntrinsics::pause();
if (timeout == std::numeric_limits<uint32_t>::max()) {
if (timeout == std::numeric_limits<uint64_t>::max()) {
continue;
}

6
level_zero/core/source/fence/fence.h
View File

@ -11,7 +11,7 @@
#include "level_zero/core/source/cmdqueue/cmdqueue.h"
#include "level_zero/core/source/cmdqueue/cmdqueue_imp.h"
#include <level_zero/ze_fence.h>
#include <level_zero/ze_api.h>
#include <limits>
@ -23,7 +23,7 @@ struct Fence : _ze_fence_handle_t {
static Fence *create(CommandQueueImp *cmdQueue, const ze_fence_desc_t *desc);
virtual ~Fence() = default;
virtual ze_result_t destroy() = 0;
virtual ze_result_t hostSynchronize(uint32_t timeout) = 0;
virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;
virtual ze_result_t queryStatus() = 0;
virtual ze_result_t reset() = 0;
@ -61,7 +61,7 @@ struct FenceImp : public Fence {
return ZE_RESULT_SUCCESS;
}
ze_result_t hostSynchronize(uint32_t timeout) override;
ze_result_t hostSynchronize(uint64_t timeout) override;
ze_result_t queryStatus() override;

2
level_zero/core/source/image/image.h
View File

@ -10,7 +10,7 @@
#include "shared/source/command_container/cmdcontainer.h"
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_image.h>
#include <level_zero/ze_api.h>
struct _ze_image_handle_t {};

4
level_zero/core/source/image/image_format_desc_helper.cpp
View File

@ -11,7 +11,7 @@
namespace L0 {
cl_channel_type getClChannelDataType(const ze_image_format_desc_t &imgDescription) {
cl_channel_type getClChannelDataType(const ze_image_format_t &imgDescription) {
switch (imgDescription.layout) {
case ZE_IMAGE_FORMAT_LAYOUT_8:
case ZE_IMAGE_FORMAT_LAYOUT_8_8:
@ -88,7 +88,7 @@ cl_channel_type getClChannelDataType(const ze_image_format_desc_t &imgDescriptio
return CL_INVALID_VALUE;
}
cl_channel_order getClChannelOrder(const ze_image_format_desc_t &imgDescription) {
cl_channel_order getClChannelOrder(const ze_image_format_t &imgDescription) {
swizzles imgSwizzles{imgDescription.x, imgDescription.y, imgDescription.z, imgDescription.w};
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_1})

4
level_zero/core/source/image/image_format_desc_helper.h
View File

@ -31,7 +31,7 @@ struct swizzles {
}
};
cl_channel_type getClChannelDataType(const ze_image_format_desc_t &imgDescription);
cl_channel_order getClChannelOrder(const ze_image_format_desc_t &imgDescription);
cl_channel_type getClChannelDataType(const ze_image_format_t &imgDescription);
cl_channel_order getClChannelOrder(const ze_image_format_t &imgDescription);
} // namespace L0

2
level_zero/core/source/image/image_formats.h
View File

@ -176,6 +176,6 @@ constexpr FormatTypes layoutP416 = {{{GMM_FORMAT_INVALID, NEO::NUM_GFX3DSTATE_SU
{GMM_FORMAT_INVALID, NEO::NUM_GFX3DSTATE_SURFACEFORMATS, 0, 1, 1, 1}}};
constexpr std::array<FormatTypes, 30> formats = {layout8, layout16, layout32, layout88, layout8888, layout1616, layout16161616, layout3232, layout32323232, layout1010102, layout111110, layout565, layout5551, layout4444, layoutY8,
layoutNV12, layoutYUYV, layoutVYUY, layoutYVYU, layoutUYVY, layoutAYUV, layoutYUAV, layoutP010, layoutY410, layoutP012, layoutY16, layoutP016, layoutY216, layoutP216, layoutP416};
layoutNV12, layoutYUYV, layoutVYUY, layoutYVYU, layoutUYVY, layoutAYUV, layoutP010, layoutY410, layoutP012, layoutY16, layoutP016, layoutY216, layoutP216, layoutP416};
} // namespace ImageFormats
} // namespace L0

10
level_zero/core/source/kernel/kernel.h
View File

@ -14,8 +14,6 @@
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
#include <memory>
#include <vector>
@ -91,11 +89,11 @@ struct Kernel : _ze_kernel_handle_t, virtual NEO::DispatchKernelEncoderI {
~Kernel() override = default;
virtual ze_result_t destroy() = 0;
virtual ze_result_t setAttribute(ze_kernel_attribute_t attr, uint32_t size, const void *pValue) = 0;
virtual ze_result_t getAttribute(ze_kernel_attribute_t attr, uint32_t *pSize, void *pValue) = 0;
virtual ze_result_t setIntermediateCacheConfig(ze_cache_config_t cacheConfig) = 0;
virtual ze_result_t setIndirectAccess(ze_kernel_indirect_access_flags_t flags) = 0;
virtual ze_result_t getIndirectAccess(ze_kernel_indirect_access_flags_t *flags) = 0;
virtual ze_result_t getSourceAttributes(uint32_t *pSize, char **pString) = 0;
virtual ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) = 0;
virtual ze_result_t getProperties(ze_kernel_properties_t *pKernelProperties) = 0;
virtual ze_result_t getPropertiesExt(ze_kernel_propertiesExt_t *pKernelProperties) = 0;
virtual ze_result_t setArgumentValue(uint32_t argIndex, size_t argSize, const void *pArgValue) = 0;
virtual void setGroupCount(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) = 0;

90
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -55,6 +55,8 @@ inline SamplerPatchValues getAddrMode(ze_sampler_address_mode_t addressingMode)
return SamplerPatchValues::AddressNone;
case ZE_SAMPLER_ADDRESS_MODE_MIRROR:
return SamplerPatchValues::AddressMirroredRepeat;
default:
DEBUG_BREAK_IF(true);
}
return SamplerPatchValues::AddressNone;
}
@ -356,53 +358,43 @@ ze_result_t KernelImp::suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::setAttribute(ze_kernel_attribute_t attr, uint32_t size, const void *pValue) {
if (size != sizeof(bool)) {
return ZE_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE;
}
if (attr == ZE_KERNEL_ATTR_INDIRECT_DEVICE_ACCESS) {
this->unifiedMemoryControls.indirectDeviceAllocationsAllowed = *(static_cast<const bool *>(pValue));
} else if (attr == ZE_KERNEL_ATTR_INDIRECT_HOST_ACCESS) {
this->unifiedMemoryControls.indirectHostAllocationsAllowed = *(static_cast<const bool *>(pValue));
} else if (attr == ZE_KERNEL_ATTR_INDIRECT_SHARED_ACCESS) {
this->unifiedMemoryControls.indirectSharedAllocationsAllowed = *(static_cast<const bool *>(pValue));
} else {
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
ze_result_t KernelImp::setIndirectAccess(ze_kernel_indirect_access_flags_t flags) {
if (flags & ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE) {
this->unifiedMemoryControls.indirectDeviceAllocationsAllowed = true;
} else if (flags & ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST) {
this->unifiedMemoryControls.indirectHostAllocationsAllowed = true;
} else if (flags & ZE_KERNEL_INDIRECT_ACCESS_FLAG_SHARED) {
this->unifiedMemoryControls.indirectSharedAllocationsAllowed = true;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::getAttribute(ze_kernel_attribute_t attr, uint32_t *pSize, void *pValue) {
if (attr == ZE_KERNEL_ATTR_INDIRECT_DEVICE_ACCESS) {
memcpy_s(pValue, sizeof(bool), &this->unifiedMemoryControls.indirectDeviceAllocationsAllowed, sizeof(bool));
return ZE_RESULT_SUCCESS;
ze_result_t KernelImp::getIndirectAccess(ze_kernel_indirect_access_flags_t *flags) {
*flags = 0;
if (this->unifiedMemoryControls.indirectDeviceAllocationsAllowed) {
*flags |= ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE;
}
if (this->unifiedMemoryControls.indirectHostAllocationsAllowed) {
*flags |= ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE;
}
if (this->unifiedMemoryControls.indirectSharedAllocationsAllowed) {
*flags |= ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE;
}
if (attr == ZE_KERNEL_ATTR_INDIRECT_HOST_ACCESS) {
memcpy_s(pValue, sizeof(bool), &this->unifiedMemoryControls.indirectHostAllocationsAllowed, sizeof(bool));
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_SUCCESS;
}
if (attr == ZE_KERNEL_ATTR_INDIRECT_SHARED_ACCESS) {
memcpy_s(pValue, sizeof(bool), &this->unifiedMemoryControls.indirectSharedAllocationsAllowed, sizeof(bool));
return ZE_RESULT_SUCCESS;
ze_result_t KernelImp::getSourceAttributes(uint32_t *pSize, char **pString) {
auto &desc = kernelImmData->getDescriptor();
if (pString == nullptr) {
*pSize = (uint32_t)desc.kernelMetadata.kernelLanguageAttributes.length() + 1;
} else {
strncpy_s(*pString, desc.kernelMetadata.kernelLanguageAttributes.length() + 1,
desc.kernelMetadata.kernelLanguageAttributes.c_str(),
desc.kernelMetadata.kernelLanguageAttributes.length() + 1);
}
if (attr == ZE_KERNEL_ATTR_SOURCE_ATTRIBUTE) {
auto &desc = kernelImmData->getDescriptor();
if (pValue == nullptr) {
*pSize = (uint32_t)desc.kernelMetadata.kernelLanguageAttributes.length() + 1;
} else {
strncpy_s((char *)pValue, desc.kernelMetadata.kernelLanguageAttributes.length() + 1,
desc.kernelMetadata.kernelLanguageAttributes.c_str(),
desc.kernelMetadata.kernelLanguageAttributes.length() + 1);
}
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::setArgImmediate(uint32_t argIndex, size_t argSize, const void *argVal) {
@ -549,22 +541,6 @@ ze_result_t KernelImp::setArgSampler(uint32_t argIndex, size_t argSize, const vo
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::getProperties(ze_kernel_properties_t *pKernelProperties) {
size_t kernelNameSize = std::min(this->kernelImmData->getDescriptor().kernelMetadata.kernelName.size(),
(static_cast<size_t>(ZE_MAX_KERNEL_NAME) - 1));
strncpy_s(pKernelProperties->name, ZE_MAX_KERNEL_NAME,
this->kernelImmData->getDescriptor().kernelMetadata.kernelName.c_str(), kernelNameSize);
pKernelProperties->requiredGroupSizeX = this->groupSize[0];
pKernelProperties->requiredGroupSizeY = this->groupSize[1];
pKernelProperties->requiredGroupSizeZ = this->groupSize[2];
pKernelProperties->numKernelArgs =
static_cast<uint32_t>(this->kernelImmData->getDescriptor().payloadMappings.explicitArgs.size());
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::getKernelName(size_t *pSize, char *pName) {
size_t kernelNameSize = this->kernelImmData->getDescriptor().kernelMetadata.kernelName.size() + 1;
if (0 == *pSize || nullptr == pName) {
@ -579,11 +555,7 @@ ze_result_t KernelImp::getKernelName(size_t *pSize, char *pName) {
return ZE_RESULT_SUCCESS;
}
ze_result_t KernelImp::getPropertiesExt(ze_kernel_propertiesExt_t *pKernelProperties) {
size_t kernelNameSize = std::min(this->kernelImmData->getDescriptor().kernelMetadata.kernelName.size(),
(static_cast<size_t>(ZE_MAX_KERNEL_NAME) - 1));
strncpy_s(pKernelProperties->name, ZE_MAX_KERNEL_NAME,
this->kernelImmData->getDescriptor().kernelMetadata.kernelName.c_str(), kernelNameSize);
ze_result_t KernelImp::getProperties(ze_kernel_properties_t *pKernelProperties) {
pKernelProperties->requiredGroupSizeX = this->groupSize[0];
pKernelProperties->requiredGroupSizeY = this->groupSize[1];

10
level_zero/core/source/kernel/kernel_imp.h
View File

@ -28,15 +28,13 @@ struct KernelImp : Kernel {
return ZE_RESULT_SUCCESS;
}
ze_result_t setAttribute(ze_kernel_attribute_t attr, uint32_t size, const void *pValue) override;
ze_result_t getAttribute(ze_kernel_attribute_t attr, uint32_t *pSize, void *pValue) override;
ze_result_t setIndirectAccess(ze_kernel_indirect_access_flags_t flags) override;
ze_result_t getIndirectAccess(ze_kernel_indirect_access_flags_t *flags) override;
ze_result_t getSourceAttributes(uint32_t *pSize, char **pString) override;
ze_result_t getProperties(ze_kernel_properties_t *pKernelProperties) override;
ze_result_t getPropertiesExt(ze_kernel_propertiesExt_t *pKernelProperties) override;
ze_result_t setIntermediateCacheConfig(ze_cache_config_t cacheConfig) override {
ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

8
level_zero/core/source/memory/memory.cpp
View File

@ -99,7 +99,7 @@ ze_result_t DriverHandleImp::getMemAddressRange(const void *ptr, void **pBase, s
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t DriverHandleImp::allocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment,
ze_result_t DriverHandleImp::allocHostMem(ze_host_mem_alloc_flags_t flags, size_t size, size_t alignment,
void **ptr) {
if (size > this->devices[0]->getDeviceInfo().maxMemAllocSize) {
*ptr = nullptr;
@ -120,7 +120,7 @@ ze_result_t DriverHandleImp::allocHostMem(ze_host_mem_alloc_flag_t flags, size_t
return ZE_RESULT_SUCCESS;
}
ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags,
ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t flags,
size_t size, size_t alignment, void **ptr) {
if (size > this->devices[0]->getNEODevice()->getHardwareCapabilities().maxMemAllocSize) {
*ptr = nullptr;
@ -141,8 +141,8 @@ ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, ze_devic
return ZE_RESULT_SUCCESS;
}
ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags, size_t size, size_t alignment,
ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
void **ptr) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY);
ze_device_handle_t device;

2
level_zero/core/source/memory/memory_operations_helper.h
View File

@ -9,7 +9,7 @@
#include "shared/source/memory_manager/memory_operations_status.h"
#include <level_zero/ze_common.h>
#include <level_zero/ze_api.h>
static ze_result_t changeMemoryOperationStatusToL0ResultType(NEO::MemoryOperationsStatus status) {
switch (status) {

2
level_zero/core/source/module/module_imp.cpp
View File

@ -83,7 +83,7 @@ bool ModuleTranslationUnit::buildFromSpirV(const char *input, uint32_t inputSize
for (uint32_t i = 0; i < pConstants->numConstants; i++) {
uint64_t specConstantValue = 0;
memcpy_s(&specConstantValue, sizeof(uint64_t),
reinterpret_cast<void *>(pConstants->pConstantValues[i]), sizeof(uint64_t));
const_cast<void *>(pConstants->pConstantValues[i]), sizeof(uint64_t));
uint32_t specConstantId = pConstants->pConstantIds[i];
specConstantsValues[specConstantId] = specConstantValue;
}

2
level_zero/core/source/sampler/sampler.h
View File

@ -8,7 +8,7 @@
#pragma once
#include "level_zero/core/source/device/device.h"
#include <level_zero/ze_sampler.h>
#include <level_zero/ze_api.h>
struct _ze_sampler_handle_t {};

141
level_zero/core/test/black_box_tests/zello_world.cpp
View File

@ -10,45 +10,45 @@
#include <cstring>
#include <iostream>
#include <limits>
#include <vector>
#define VALIDATECALL(myZeCall) \
do { \
if (myZeCall != ZE_RESULT_SUCCESS) { \
std::cout << "Error at " \
<< #myZeCall << ": " \
<< __FUNCTION__ << ": " \
<< __LINE__ << "\n"; \
std::terminate(); \
} \
} while (0);
int main(int argc, char *argv[]) {
// Initialize driver
ze_result_t res = zeInit(ZE_INIT_FLAG_NONE);
if (res) {
std::terminate();
}
VALIDATECALL(zeInit(ZE_INIT_FLAG_GPU_ONLY));
// Retrieve driver
uint32_t driverCount = 0;
res = zeDriverGet(&driverCount, nullptr);
if (res || driverCount == 0) {
std::terminate();
}
VALIDATECALL(zeDriverGet(&driverCount, nullptr));
ze_driver_handle_t driverHandle;
res = zeDriverGet(&driverCount, &driverHandle);
if (res) {
std::terminate();
}
VALIDATECALL(zeDriverGet(&driverCount, &driverHandle));
ze_context_desc_t contextDesc = {};
ze_context_handle_t context;
VALIDATECALL(zeContextCreate(driverHandle, &contextDesc, &context));
// Retrieve device
uint32_t deviceCount = 0;
res = zeDeviceGet(driverHandle, &deviceCount, nullptr);
if (res || deviceCount == 0) {
std::terminate();
}
VALIDATECALL(zeDeviceGet(driverHandle, &deviceCount, nullptr));
ze_device_handle_t device;
deviceCount = 1;
res = zeDeviceGet(driverHandle, &deviceCount, &device);
if (res) {
std::terminate();
}
VALIDATECALL(zeDeviceGet(driverHandle, &deviceCount, &device));
// Print some properties
ze_device_properties_t deviceProperties = {ZE_DEVICE_PROPERTIES_VERSION_CURRENT};
res = zeDeviceGetProperties(device, &deviceProperties);
if (res) {
std::terminate();
}
ze_device_properties_t deviceProperties = {};
VALIDATECALL(zeDeviceGetProperties(device, &deviceProperties));
std::cout << "Device : \n"
<< " * name : " << deviceProperties.name << "\n"
@ -56,45 +56,48 @@ int main(int argc, char *argv[]) {
<< " * vendorId : " << deviceProperties.vendorId << "\n";
// Create command queue
ze_command_queue_handle_t cmdQueue;
ze_command_queue_desc_t cmdQueueDesc = {ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT};
cmdQueueDesc.ordinal = 0;
cmdQueueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
res = zeCommandQueueCreate(device, &cmdQueueDesc, &cmdQueue);
if (res) {
uint32_t numQueueGroups = 0;
VALIDATECALL(zeDeviceGetCommandQueueGroupProperties(device, &numQueueGroups, nullptr));
if (numQueueGroups == 0) {
std::cout << "No queue groups found!\n";
std::terminate();
}
std::vector<ze_command_queue_group_properties_t> queueProperties(numQueueGroups);
VALIDATECALL(zeDeviceGetCommandQueueGroupProperties(device, &numQueueGroups,
queueProperties.data()));
ze_command_queue_handle_t cmdQueue;
ze_command_queue_desc_t cmdQueueDesc = {};
for (uint32_t i = 0; i < numQueueGroups; i++) {
if (queueProperties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
cmdQueueDesc.ordinal = i;
}
}
cmdQueueDesc.index = 0;
cmdQueueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
VALIDATECALL(zeCommandQueueCreate(context, device, &cmdQueueDesc, &cmdQueue));
// Create command list
ze_command_list_handle_t cmdList;
ze_command_list_desc_t cmdListDesc = {ZE_COMMAND_LIST_DESC_VERSION_CURRENT};
res = zeCommandListCreate(device, &cmdListDesc, &cmdList);
if (res) {
std::terminate();
}
ze_command_list_desc_t cmdListDesc = {};
cmdListDesc.commandQueueGroupOrdinal = cmdQueueDesc.ordinal;
VALIDATECALL(zeCommandListCreate(context, device, &cmdListDesc, &cmdList));
// Create two shared buffers
constexpr size_t allocSize = 4096;
ze_device_mem_alloc_desc_t deviceDesc;
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT;
deviceDesc.flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED;
deviceDesc.ordinal = 0;
deviceDesc.version = ZE_DEVICE_MEM_ALLOC_DESC_VERSION_CURRENT;
ze_host_mem_alloc_desc_t hostDesc;
hostDesc.flags = ZE_HOST_MEM_ALLOC_FLAG_DEFAULT;
hostDesc.version = ZE_HOST_MEM_ALLOC_DESC_VERSION_CURRENT;
hostDesc.flags = ZE_HOST_MEM_ALLOC_FLAG_BIAS_UNCACHED;
void *srcBuffer = nullptr;
res = zeDriverAllocSharedMem(driverHandle, &deviceDesc, &hostDesc, allocSize, 1, device, &srcBuffer);
if (res) {
std::terminate();
}
VALIDATECALL(zeMemAllocShared(context, &deviceDesc, &hostDesc, allocSize, 1, device, &srcBuffer));
void *dstBuffer = nullptr;
res = zeDriverAllocSharedMem(driverHandle, &deviceDesc, &hostDesc, allocSize, 1, device, &dstBuffer);
if (res) {
std::terminate();
}
VALIDATECALL(zeMemAllocShared(context, &deviceDesc, &hostDesc, allocSize, 1, device, &dstBuffer));
// Initialize memory
constexpr uint8_t val = 55;
@ -102,26 +105,13 @@ int main(int argc, char *argv[]) {
memset(dstBuffer, 0, allocSize);
// Perform a GPU copy
res = zeCommandListAppendMemoryCopy(cmdList, dstBuffer, srcBuffer, allocSize, nullptr);
if (res) {
std::terminate();
}
VALIDATECALL(zeCommandListAppendMemoryCopy(cmdList, dstBuffer, srcBuffer, allocSize, nullptr, 0, nullptr));
// Close list and submit for execution
res = zeCommandListClose(cmdList);
if (res) {
std::terminate();
}
res = zeCommandQueueExecuteCommandLists(cmdQueue, 1, &cmdList, nullptr);
if (res) {
std::terminate();
}
VALIDATECALL(zeCommandListClose(cmdList));
VALIDATECALL(zeCommandQueueExecuteCommandLists(cmdQueue, 1, &cmdList, nullptr));
// Wait for completion
res = zeCommandQueueSynchronize(cmdQueue, std::numeric_limits<uint32_t>::max());
if (res) {
std::terminate();
}
VALIDATECALL(zeCommandQueueSynchronize(cmdQueue, std::numeric_limits<uint32_t>::max()));
// Validate
bool outputValidationSuccessful = true;
@ -139,22 +129,11 @@ int main(int argc, char *argv[]) {
}
// Cleanup
res = zeDriverFreeMem(driverHandle, dstBuffer);
if (res) {
std::terminate();
}
res = zeDriverFreeMem(driverHandle, srcBuffer);
if (res) {
std::terminate();
}
res = zeCommandListDestroy(cmdList);
if (res) {
std::terminate();
}
res = zeCommandQueueDestroy(cmdQueue);
if (res) {
std::terminate();
}
VALIDATECALL(zeMemFree(context, dstBuffer));
VALIDATECALL(zeMemFree(context, srcBuffer));
VALIDATECALL(zeCommandListDestroy(cmdList));
VALIDATECALL(zeCommandQueueDestroy(cmdQueue));
VALIDATECALL(zeContextDestroy(context));
std::cout << "\nZello World Results validation " << (outputValidationSuccessful ? "PASSED" : "FAILED") << "\n";

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

@ -21,16 +21,14 @@ class CommandListFixture : public DeviceFixture {
DeviceFixture::SetUp();
commandList.reset(whitebox_cast(CommandList::create(productFamily, device, false)));
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
2};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
eventPoolDesc.count = 2;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.wait = 0;
eventDesc.signal = 0;
eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));

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

@ -35,7 +35,7 @@ struct ModuleFixture : public DeviceFixture {
ASSERT_NE(0u, size);
ASSERT_NE(nullptr, src);
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;
@ -46,7 +46,7 @@ struct ModuleFixture : public DeviceFixture {
}
void createKernel() {
ze_kernel_desc_t desc = {ZE_KERNEL_DESC_VERSION_CURRENT};
ze_kernel_desc_t desc = {};
desc.pKernelName = kernelName.c_str();
kernel = std::make_unique<WhiteBox<::L0::Kernel>>();
@ -81,7 +81,7 @@ struct MultiDeviceModuleFixture : public MultiDeviceFixture {
ASSERT_NE(0u, size);
ASSERT_NE(nullptr, src);
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;

10
level_zero/core/test/unit_tests/gen12lp/test_device_gen12lp.cpp
View File

@ -18,16 +18,6 @@ using ::testing::_;
using ::testing::AnyNumber;
using ::testing::Return;
using DevicePropertyTest = Test<DeviceFixture>;
HWTEST2_F(DevicePropertyTest, givenReturnedDevicePropertiesThenExpectedPageFaultSupportReturned, IsGen12LP) {
ze_device_properties_t deviceProps;
deviceProps.version = ZE_DEVICE_PROPERTIES_VERSION_CURRENT;
device->getProperties(&deviceProps);
EXPECT_FALSE(deviceProps.onDemandPageFaultsSupported);
}
using DeviceQueueGroupTest = Test<DeviceFixture>;
HWTEST2_F(DeviceQueueGroupTest,

8
level_zero/core/test/unit_tests/gen9/test_device_gen9.cpp
View File

@ -19,21 +19,19 @@ using ::testing::Return;
using KernelPropertyTest = Test<DeviceFixture>;
HWTEST2_F(KernelPropertyTest, givenReturnedKernelPropertiesThenExpectedDp4aSupportReturned, IsGen9) {
ze_device_kernel_properties_t kernelProps;
kernelProps.version = ZE_DEVICE_KERNEL_PROPERTIES_VERSION_CURRENT;
ze_device_module_properties_t kernelProps;
device->getKernelProperties(&kernelProps);
EXPECT_FALSE(kernelProps.dp4aSupported);
EXPECT_EQ(0u, kernelProps.flags & ZE_DEVICE_MODULE_FLAG_DP4A);
}
using DevicePropertyTest = Test<DeviceFixture>;
HWTEST2_F(DevicePropertyTest, givenReturnedDevicePropertiesThenExpectedPageFaultSupportReturned, IsGen9) {
ze_device_properties_t deviceProps;
deviceProps.version = ZE_DEVICE_PROPERTIES_VERSION_CURRENT;
device->getProperties(&deviceProps);
EXPECT_FALSE(deviceProps.onDemandPageFaultsSupported);
EXPECT_EQ(0u, deviceProps.flags & ZE_DEVICE_PROPERTY_FLAG_ONDEMANDPAGING);
}
using DeviceQueueGroupTest = Test<DeviceFixture>;

2
level_zero/core/test/unit_tests/mocks/CMakeLists.txt
View File

@ -21,8 +21,8 @@ set(L0_MOCKS_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver_handle.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_driver_handle.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_event.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_event.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_event.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info_l0.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_kernel.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_l0_debugger.h

4
level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
View File

@ -252,10 +252,6 @@ struct MockCommandList : public CommandList {
(zet_metric_streamer_handle_t hMetricStreamer,
uint32_t value));
ADDMETHOD_NOBASE(appendMetricTracerMarker, ze_result_t, ZE_RESULT_SUCCESS,
(zet_metric_tracer_handle_t hMetricTracer,
uint32_t value));
ADDMETHOD_NOBASE(appendMetricQueryBegin, ze_result_t, ZE_RESULT_SUCCESS,
(zet_metric_query_handle_t hMetricQuery));

4
level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h
View File

@ -61,7 +61,7 @@ struct Mock<CommandQueue> : public CommandQueue {
(override));
MOCK_METHOD(ze_result_t,
synchronize,
(uint32_t timeout),
(uint64_t timeout),
(override));
MOCK_METHOD(void,
dispatchTaskCountWrite,
@ -78,7 +78,7 @@ struct MockCommandQueueHw : public L0::CommandQueueHw<gfxCoreFamily> {
MockCommandQueueHw(L0::Device *device, NEO::CommandStreamReceiver *csr, const ze_command_queue_desc_t *desc) : L0::CommandQueueHw<gfxCoreFamily>(device, csr, desc) {
}
ze_result_t synchronize(uint32_t timeout) override {
ze_result_t synchronize(uint64_t timeout) override {
synchronizedCalled++;
return ZE_RESULT_SUCCESS;
}

36
level_zero/core/test/unit_tests/mocks/mock_context.h
View File

@ -22,8 +22,8 @@ using Context = WhiteBox<::L0::Context>;
template <>
struct Mock<Context> : public Context {
Mock();
~Mock() override;
Mock() = default;
~Mock() override = default;
MOCK_METHOD(ze_result_t,
destroy,
@ -39,7 +39,7 @@ struct Mock<Context> : public Context {
(override));
MOCK_METHOD(ze_result_t,
allocHostMem,
(ze_host_mem_alloc_flag_t flags,
(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr),
@ -47,7 +47,7 @@ struct Mock<Context> : public Context {
MOCK_METHOD(ze_result_t,
allocDeviceMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr),
@ -55,8 +55,8 @@ struct Mock<Context> : public Context {
MOCK_METHOD(ze_result_t,
allocSharedMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags,
size_t size,
size_t alignment,
void **ptr),
@ -124,6 +124,12 @@ struct Mock<Context> : public Context {
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *commandList),
(override));
MOCK_METHOD(ze_result_t,
activateMetricGroups,
(zet_device_handle_t hDevice,
uint32_t count,
zet_metric_group_handle_t *phMetricGroups),
(override));
MOCK_METHOD(ze_result_t,
reserveVirtualMem,
(const void *pStart,
@ -177,6 +183,24 @@ struct Mock<Context> : public Context {
ze_memory_access_attribute_t *access,
size_t *outSize),
(override));
MOCK_METHOD(ze_result_t,
openEventPoolIpcHandle,
(ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool),
(override));
MOCK_METHOD(ze_result_t,
createEventPool,
(const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool),
(override));
MOCK_METHOD(ze_result_t,
createImage,
(ze_device_handle_t hDevice,
const ze_image_desc_t *desc,
ze_image_handle_t *phImage),
(override));
};
} // namespace ult

10
level_zero/core/test/unit_tests/mocks/mock_device.h
View File

@ -94,7 +94,7 @@ struct Mock<Device> : public Device {
(override));
MOCK_METHOD(ze_result_t,
getKernelProperties,
(ze_device_kernel_properties_t * pKernelProperties),
(ze_device_module_properties_t * pKernelProperties),
(override));
MOCK_METHOD(ze_result_t,
getMemoryProperties,
@ -125,11 +125,11 @@ struct Mock<Device> : public Device {
(override));
MOCK_METHOD(ze_result_t,
setIntermediateCacheConfig,
(ze_cache_config_t CacheConfig),
(ze_cache_config_flags_t CacheConfig),
(override));
MOCK_METHOD(ze_result_t,
setLastLevelCacheConfig,
(ze_cache_config_t CacheConfig),
(ze_cache_config_flags_t CacheConfig),
(override));
MOCK_METHOD(ze_result_t,
getCacheProperties,
@ -153,26 +153,22 @@ struct Mock<Device> : public Device {
(override));
MOCK_METHOD(ze_result_t,
systemBarrier,
(),
(override));
MOCK_METHOD(ze_result_t,
registerCLMemory,
(cl_context context,
cl_mem mem,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
registerCLProgram,
(cl_context context,
cl_program program,
ze_module_handle_t *phModule),
(override));
MOCK_METHOD(ze_result_t,
registerCLCommandQueue,
(cl_context context,
cl_command_queue commandQueue,
ze_command_queue_handle_t *phCommandQueue),

4
level_zero/core/test/unit_tests/mocks/mock_driver.h
View File

@ -28,14 +28,14 @@ struct Mock<Driver> : public Driver {
MOCK_METHOD(ze_result_t,
driverInit,
(ze_init_flag_t),
(ze_init_flags_t),
(override));
MOCK_METHOD(void,
initialize,
(ze_result_t * result),
(override));
ze_result_t mockInit(ze_init_flag_t) { return this->DriverImp::driverInit(ZE_INIT_FLAG_NONE); }
ze_result_t mockInit(ze_init_flag_t) { return this->DriverImp::driverInit(ZE_INIT_FLAG_GPU_ONLY); }
void mockInitialize(ze_result_t *result) { *result = ZE_RESULT_SUCCESS; }
Driver *previousDriver = nullptr;

4
level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp
View File

@ -52,7 +52,7 @@ ze_result_t Mock<DriverHandle>::doGetDevice(uint32_t *pCount, ze_device_handle_t
return ZE_RESULT_SUCCESS;
}
ze_result_t Mock<DriverHandle>::doAllocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment,
ze_result_t Mock<DriverHandle>::doAllocHostMem(ze_host_mem_alloc_flags_t flags, size_t size, size_t alignment,
void **ptr) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY);
@ -67,7 +67,7 @@ ze_result_t Mock<DriverHandle>::doAllocHostMem(ze_host_mem_alloc_flag_t flags, s
return ZE_RESULT_SUCCESS;
}
ze_result_t Mock<DriverHandle>::doAllocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr) {
ze_result_t Mock<DriverHandle>::doAllocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t flags, size_t size, size_t alignment, void **ptr) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY);
auto allocation = svmAllocsManager->createUnifiedMemoryAllocation(0u, size, unifiedMemoryProperties);

12
level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
View File

@ -99,7 +99,7 @@ struct Mock<DriverHandle> : public DriverHandleImp {
(override));
MOCK_METHOD(ze_result_t,
allocHostMem,
(ze_host_mem_alloc_flag_t flags,
(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr),
@ -107,7 +107,7 @@ struct Mock<DriverHandle> : public DriverHandleImp {
MOCK_METHOD(ze_result_t,
allocDeviceMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr),
@ -115,8 +115,8 @@ struct Mock<DriverHandle> : public DriverHandleImp {
MOCK_METHOD(ze_result_t,
allocSharedMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t deviceFlags,
ze_host_mem_alloc_flag_t hostFlags,
ze_device_mem_alloc_flags_t deviceFlags,
ze_host_mem_alloc_flags_t hostFlags,
size_t size,
size_t alignment,
void **ptr),
@ -139,12 +139,12 @@ struct Mock<DriverHandle> : public DriverHandleImp {
ze_device_handle_t *phDevices);
NEO::MemoryManager *doGetMemoryManager();
NEO::SVMAllocsManager *doGetSvmAllocManager();
ze_result_t doAllocHostMem(ze_host_mem_alloc_flag_t flags,
ze_result_t doAllocHostMem(ze_host_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr);
ze_result_t doAllocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
ze_device_mem_alloc_flags_t flags,
size_t size,
size_t alignment,
void **ptr);

3
level_zero/core/test/unit_tests/mocks/mock_event.h
View File

@ -44,10 +44,9 @@ struct Mock<Event> : public Event {
MOCK_METHOD3(create, L0::Event *(::L0::EventPool *eventPool, const ze_event_desc_t *desc, ::L0::Device *device));
MOCK_METHOD0(destroy, ze_result_t());
MOCK_METHOD0(hostSignal, ze_result_t());
MOCK_METHOD1(hostSynchronize, ze_result_t(uint32_t timeout));
MOCK_METHOD1(hostSynchronize, ze_result_t(uint64_t timeout));
MOCK_METHOD0(queryStatus, ze_result_t());
MOCK_METHOD0(reset, ze_result_t());
MOCK_METHOD2(getTimestamp, ze_result_t(ze_event_timestamp_type_t timestampType, void *dstptr));
MOCK_METHOD1(queryKernelTimestamp, ze_result_t(ze_kernel_timestamp_result_t *dstptr));
// Fake an allocation for event memory

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

@ -21,6 +21,7 @@
#include "level_zero/core/source/module/module.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_context.h"
#include "level_zero/core/test/unit_tests/mocks/mock_event.h"
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
@ -53,8 +54,9 @@ TEST_F(ContextCommandListCreate, whenCreatingCommandListImmediateFromContextThen
using CommandListCreate = Test<DeviceFixture>;
TEST(zeCommandListCreateImmediate, redirectsToObject) {
TEST(zeCommandListCreateImmediate, DISABLED_redirectsToObject) {
Mock<Device> device;
Mock<Context> context;
ze_command_queue_desc_t desc = {};
ze_command_list_handle_t commandList = {};
@ -62,7 +64,7 @@ TEST(zeCommandListCreateImmediate, redirectsToObject) {
.Times(1)
.WillRepeatedly(::testing::Return(ZE_RESULT_SUCCESS));
auto result = zeCommandListCreateImmediate(device.toHandle(), &desc, &commandList);
auto result = zeCommandListCreateImmediate(context.toHandle(), device.toHandle(), &desc, &commandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@ -121,7 +123,7 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemAdviseReturnsSuccess) {
void *ptr = nullptr;
auto res = driverHandle->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, ptr);
@ -142,7 +144,7 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemoryPrefetchReturnsSuccess) {
void *ptr = nullptr;
auto res = driverHandle->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, ptr);
@ -158,12 +160,8 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemoryPrefetchReturnsSuccess) {
}
TEST_F(CommandListCreate, givenImmediateCommandListThenCustomNumIddPerBlockUsed) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_NONE,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, false));
ASSERT_NE(nullptr, commandList);
@ -172,12 +170,7 @@ TEST_F(CommandListCreate, givenImmediateCommandListThenCustomNumIddPerBlockUsed)
}
TEST_F(CommandListCreate, whenCreatingImmediateCommandListThenItHasImmediateCommandQueueCreated) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_NONE,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, false));
ASSERT_NE(nullptr, commandList);
@ -367,8 +360,8 @@ HWTEST_F(CommandListCreate, givenCommandListWithCopyOnlyWhenAppendSignalEventThe
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, true));
auto &commandContainer = commandList->commandContainer;
MockEvent event;
event.waitScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.signalScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
event.signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
commandList->appendSignalEvent(event.toHandle());
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
@ -383,8 +376,8 @@ HWTEST_F(CommandListCreate, givenCommandListWhenAppendSignalEventThePipeControlI
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, false));
auto &commandContainer = commandList->commandContainer;
MockEvent event;
event.waitScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.signalScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
event.signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
commandList->appendSignalEvent(event.toHandle());
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
@ -399,7 +392,7 @@ HWTEST_F(CommandListCreate, givenCommandListWithCopyOnlyWhenAppendWaitEventsWith
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, true));
auto &commandContainer = commandList->commandContainer;
MockEvent event;
event.signalScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.signalScope = 0;
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
auto eventHandle = event.toHandle();
commandList->appendWaitOnEvents(1, &eventHandle);
@ -416,7 +409,7 @@ HWTEST_F(CommandListCreate, givenCommandListyWhenAppendWaitEventsWithDcFlushTheP
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, false));
auto &commandContainer = commandList->commandContainer;
MockEvent event;
event.signalScope = ZE_EVENT_SCOPE_FLAG_NONE;
event.signalScope = 0;
event.waitScope = ZE_EVENT_SCOPE_FLAG_HOST;
auto eventHandle = event.toHandle();
commandList->appendWaitOnEvents(1, &eventHandle);
@ -630,7 +623,6 @@ HWTEST2_F(CommandListCreate, givenCopyOnlyCommandListWhenAppenBlitFillThenCopyBl
}
using ImageSupport = IsWithinProducts<IGFX_SKYLAKE, IGFX_TIGERLAKE_LP>;
HWTEST2_F(CommandListCreate, givenCopyCommandListWhenCopyFromImagBlitThenCommandAddedToStream, ImageSupport) {
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
using XY_COPY_BLT = typename GfxFamily::XY_COPY_BLT;
@ -654,15 +646,12 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenTimestampPassedToMemoryCopy
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
commandList->initialize(device, true);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
@ -716,15 +705,12 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenTimestampPassedToImageCopyB
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
commandList->initialize(device, true);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
@ -750,15 +736,12 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenProfilingBeforeCommandForCo
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
commandList->initialize(device, true);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
@ -786,15 +769,12 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenProfilingAfterCommandForCop
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
commandList->initialize(device, true);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));

35
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
View File

@ -329,15 +329,13 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenTimestampPassedToMemoryCopyThen
void *srcPtr = reinterpret_cast<void *>(0x1234);
void *dstPtr = reinterpret_cast<void *>(0x2345);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
@ -819,7 +817,6 @@ HWTEST2_F(CommandListCreate, givenPitchAndSlicePitchWhenMemoryCopyRegionCalledSi
EXPECT_EQ(cmdList.srcSize.x, pitch);
EXPECT_EQ(cmdList.srcSize.y, slicePitch / pitch);
}
template <GFXCORE_FAMILY gfxCoreFamily>
class MockCommandListForMemFill : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>> {
public:
@ -847,15 +844,15 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenTimestampPassedToMemoryCopy
commandList.initialize(device, true);
void *srcPtr = reinterpret_cast<void *>(0x1234);
void *dstPtr = reinterpret_cast<void *>(0x2345);
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
eventPoolDesc.count = 1;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = 0;
eventDesc.wait = 0;
auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));

12
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_api.cpp
View File

@ -9,9 +9,9 @@
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_context.h"
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
#include "third_party/level_zero/ze_api_ext.h"
#include <level_zero/ze_api.h>
namespace L0 {
namespace ult {
@ -41,7 +41,7 @@ TEST_F(zeCommandListAppendMemAdviseTest, whenCalledThenRedirectedToObject) {
TEST(zeCommandListAppendMemoryCopy, whenCalledThenRedirectedToObject) {
MockCommandList commandList;
auto res = zeCommandListAppendMemoryCopy(&commandList, reinterpret_cast<void *>(0x2000), reinterpret_cast<const void *>(0x1000), 0x1000, nullptr);
auto res = zeCommandListAppendMemoryCopy(&commandList, reinterpret_cast<void *>(0x2000), reinterpret_cast<const void *>(0x1000), 0x1000, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, res);
}
@ -51,7 +51,7 @@ TEST(zeCommandListAppendMemoryFill, whenCalledThenRedirectedToObject) {
int value = 0;
auto res = zeCommandListAppendMemoryFill(&commandList, reinterpret_cast<void *>(0x1000), reinterpret_cast<void *>(&value),
sizeof(value), bufferSize, nullptr);
sizeof(value), bufferSize, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, res);
}
@ -63,10 +63,10 @@ TEST(zeCommandListAppendWaitOnEvent, whenCalledThenRedirectedToObject) {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST(zeCommandListAppendWriteGlobalTimestampExt, whenCalledThenRedirectedToObject) {
TEST(zeCommandListAppendWriteGlobalTimestamp, whenCalledThenRedirectedToObject) {
MockCommandList commandList;
auto result = zeCommandListAppendWriteGlobalTimestampExt(commandList.toHandle(), nullptr, nullptr, 0, nullptr);
auto result = zeCommandListAppendWriteGlobalTimestamp(commandList.toHandle(), nullptr, nullptr, 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}

72
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
View File

@ -209,16 +209,12 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenEventsWhenAppend
Mock<::L0::Kernel> kernel;
std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, false));
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
eventPoolDesc.count = 1;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
@ -273,16 +269,12 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenTimestampEventsWhenAppendingKernel
Mock<::L0::Kernel> kernel;
std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, false));
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
@ -360,13 +352,13 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenKernelLaunchWithTSEventAndScopeFla
Mock<::L0::Kernel> kernel;
std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, false));
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
const ze_event_desc_t eventDesc = {
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
0,
ZE_EVENT_SCOPE_FLAG_HOST,
ZE_EVENT_SCOPE_FLAG_HOST};
@ -432,7 +424,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenIndirectDispatchWhenAppendingThenWo
std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, false));
void *alloc = nullptr;
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT, 16384u, 4096u, &alloc);
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), 0u, 16384u, 4096u, &alloc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandList->appendLaunchKernelIndirect(kernel.toHandle(),
@ -542,13 +534,12 @@ HWTEST_F(CommandListAppendLaunchKernel, givenSingleValidWaitEventsAddsSemaphoreT
ASSERT_NE(nullptr, commandList->commandContainer.getCommandStream());
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
eventPoolDesc.count = 1;
ze_event_desc_t eventDesc = {ZE_EVENT_DESC_VERSION_CURRENT, 0, ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
std::unique_ptr<EventPool> eventPool(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
std::unique_ptr<Event> event(Event::create(eventPool.get(), &eventDesc, device));
@ -585,16 +576,15 @@ HWTEST_F(CommandListAppendLaunchKernel, givenMultipleValidWaitEventsAddsSemaphor
ASSERT_NE(nullptr, commandList->commandContainer.getCommandStream());
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
2};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
eventPoolDesc.count = 2;
ze_event_desc_t eventDesc1 = {ZE_EVENT_DESC_VERSION_CURRENT, 0, ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc1 = {};
eventDesc1.index = 0;
ze_event_desc_t eventDesc2 = {ZE_EVENT_DESC_VERSION_CURRENT, 1, ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc2 = {};
eventDesc2.index = 1;
std::unique_ptr<EventPool> eventPool(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
std::unique_ptr<Event> event1(Event::create(eventPool.get(), &eventDesc1, device));
@ -630,7 +620,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenAppendLaunchMult
const ze_kernel_handle_t launchFn = kernel->toHandle();
uint32_t *numLaunchArgs;
auto result = device->getDriverHandle()->allocDeviceMem(
device->toHandle(), ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
device->toHandle(), 0u, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
result = commandList->appendLaunchMultipleKernelsIndirect(1, &launchFn, numLaunchArgs, nullptr, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
*numLaunchArgs = 0;
@ -657,7 +647,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenAppendLaunchMult
uint32_t *numLaunchArgs;
const uint32_t numKernels = 3;
auto result = device->getDriverHandle()->allocDeviceMem(
device->toHandle(), ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
device->toHandle(), 0u, 16384u, 4096u, reinterpret_cast<void **>(&numLaunchArgs));
result = commandList->appendLaunchMultipleKernelsIndirect(numKernels, launchFn, numLaunchArgs, nullptr, nullptr, 0, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
*numLaunchArgs = 2;

15
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp
View File

@ -99,16 +99,13 @@ HWTEST_F(CommandListAppendSignalEvent, givenEventWithScopeFlagDeviceWhenAppendin
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_DEVICE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
auto eventPoolHostVisible = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
auto eventHostVisible = std::unique_ptr<Event>(Event::create(eventPoolHostVisible.get(), &eventDesc, device));

8
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
View File

@ -103,8 +103,12 @@ HWTEST_F(CommandListAppendWaitOnEvent, givenEventWithWaitScopeFlagDeviceWhenAppe
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
ze_event_desc_t eventDesc = {ZE_EVENT_DESC_VERSION_CURRENT, 1, ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_DEVICE};
const ze_event_desc_t eventDesc = {
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
0,
0,
ZE_EVENT_SCOPE_FLAG_DEVICE};
auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
ze_event_handle_t hEventHandle = event->toHandle();

179
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp
View File

@ -28,13 +28,7 @@ namespace ult {
using CommandQueueCreate = Test<DeviceFixture>;
TEST_F(CommandQueueCreate, whenCreatingCommandQueueThenItIsInitialized) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_NONE,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
auto csr = std::unique_ptr<NEO::CommandStreamReceiver>(neoDevice->createCommandStreamReceiver());
L0::CommandQueue *commandQueue = CommandQueue::create(productFamily,
@ -53,144 +47,6 @@ TEST_F(CommandQueueCreate, whenCreatingCommandQueueThenItIsInitialized) {
commandQueue->destroy();
}
TEST_F(CommandQueueCreate, givenOrdinalThenQueueIsCreatedOnlyIfOrdinalIsLessThanNumOfAsyncComputeEngines) {
ze_device_properties_t deviceProperties;
ze_result_t res = device->getProperties(&deviceProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto expectedNumOfComputeEngines = NEO::HwHelper::getEnginesCount(device->getNEODevice()->getHardwareInfo());
EXPECT_EQ(expectedNumOfComputeEngines, deviceProperties.numAsyncComputeEngines);
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
desc.ordinal = deviceProperties.numAsyncComputeEngines;
ze_command_queue_handle_t commandQueue = {};
res = device->createCommandQueue(&desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, res);
EXPECT_EQ(nullptr, commandQueue);
std::vector<ze_command_queue_handle_t> commandQueueVector;
for (uint32_t i = 0; i < expectedNumOfComputeEngines; i++) {
desc.ordinal = i;
res = device->createCommandQueue(&desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, commandQueue);
commandQueueVector.push_back(commandQueue);
}
for (uint32_t i = 0; i < expectedNumOfComputeEngines; i++) {
for (uint32_t j = 0; j < expectedNumOfComputeEngines; j++) {
if (i == j) {
continue;
}
EXPECT_NE(static_cast<CommandQueue *>(commandQueueVector[i])->getCsr(),
static_cast<CommandQueue *>(commandQueueVector[j])->getCsr());
}
}
for (auto commandQueue : commandQueueVector) {
L0::CommandQueue::fromHandle(commandQueue)->destroy();
}
}
TEST_F(CommandQueueCreate, givenOrdinalWhenQueueIsCreatedThenCorrectEngineIsSelected) {
ze_device_properties_t deviceProperties;
ze_result_t res = device->getProperties(&deviceProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto numOfComputeEngines = NEO::HwHelper::getEnginesCount(device->getNEODevice()->getHardwareInfo());
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
ze_command_queue_handle_t commandQueue = {};
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
for (uint32_t i = 0; i < numOfComputeEngines; i++) {
desc.ordinal = i;
res = device->createCommandQueue(&desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandQueue);
EXPECT_EQ(device->getNEODevice()->getEngine(hwHelper.getComputeEngineIndexByOrdinal(*defaultHwInfo, i)).commandStreamReceiver,
static_cast<CommandQueue *>(commandQueue)->getCsr());
L0::CommandQueue::fromHandle(commandQueue)->destroy();
}
}
struct MultiDeviceCommandQueueCreateTest : public ::testing::Test {
void SetUp() override {
DebugManager.flags.CreateMultipleSubDevices.set(numSubDevices);
auto executionEnvironment = new NEO::ExecutionEnvironment;
auto devices = NEO::DeviceFactory::createDevices(*executionEnvironment);
driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
driverHandle->initialize(std::move(devices));
}
DebugManagerStateRestore restorer;
std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
const uint32_t numSubDevices = 2u;
void verifyCreationOfAllCommandQueuesAvailable(L0::Device *device) {
ze_device_properties_t deviceProperties;
ze_result_t res = device->getProperties(&deviceProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
uint32_t numOfComputeEngines = NEO::HwHelper::getEnginesCount(device->getNEODevice()->getHardwareInfo());
EXPECT_EQ(numOfComputeEngines, deviceProperties.numAsyncComputeEngines);
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
ze_command_queue_handle_t commandQueue = {};
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
for (uint32_t i = 0; i < numOfComputeEngines; i++) {
desc.ordinal = i;
res = device->createCommandQueue(&desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
ASSERT_NE(nullptr, commandQueue);
uint32_t engineIndex = hwHelper.getComputeEngineIndexByOrdinal(*defaultHwInfo,
desc.ordinal);
if (device->getNEODevice()->getNumAvailableDevices() > 1) {
EXPECT_EQ(device->getNEODevice()->getDeviceById(0)->getEngine(engineIndex).commandStreamReceiver,
static_cast<CommandQueue *>(commandQueue)->getCsr());
} else {
EXPECT_EQ(device->getNEODevice()->getEngine(engineIndex).commandStreamReceiver,
static_cast<CommandQueue *>(commandQueue)->getCsr());
}
L0::CommandQueue::fromHandle(commandQueue)->destroy();
}
}
};
TEST_F(MultiDeviceCommandQueueCreateTest, givenOrdinalWhenQueueIsCreatedThenCorrectEngineIsSelected) {
L0::Device *device = driverHandle->devices[0];
verifyCreationOfAllCommandQueuesAvailable(device);
uint32_t count = 0;
ze_result_t result = device->getSubDevices(&count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(numSubDevices, count);
std::vector<ze_device_handle_t> subDevices(count);
result = device->getSubDevices(&count, subDevices.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
for (auto subDevice : subDevices) {
verifyCreationOfAllCommandQueuesAvailable(Device::fromHandle(subDevice));
}
}
using CommandQueueSBASupport = IsWithinProducts<IGFX_SKYLAKE, IGFX_TIGERLAKE_LP>;
struct MockMemoryManagerCommandQueueSBA : public MemoryManagerMock {
@ -232,7 +88,6 @@ struct CommandQueueProgramSBATest : public ::testing::Test {
HWTEST2_F(CommandQueueProgramSBATest, whenCreatingCommandQueueThenItIsInitialized, CommandQueueSBASupport) {
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
auto csr = std::unique_ptr<NEO::CommandStreamReceiver>(neoDevice->createCommandStreamReceiver());
auto commandQueue = new MockCommandQueueHw<gfxCoreFamily>(device, csr.get(), &desc);
commandQueue->initialize(false);
@ -254,12 +109,7 @@ HWTEST2_F(CommandQueueProgramSBATest, whenCreatingCommandQueueThenItIsInitialize
}
TEST_F(CommandQueueCreate, givenCmdQueueWithBlitCopyWhenExecutingNonCopyBlitCommandListThenWrongCommandListStatusReturned) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_COPY_ONLY,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
auto csr = std::unique_ptr<NEO::CommandStreamReceiver>(neoDevice->createCommandStreamReceiver());
@ -280,12 +130,7 @@ TEST_F(CommandQueueCreate, givenCmdQueueWithBlitCopyWhenExecutingNonCopyBlitComm
}
TEST_F(CommandQueueCreate, givenCmdQueueWithBlitCopyWhenExecutingCopyBlitCommandListThenSuccessReturned) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_COPY_ONLY,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
auto defaultCsr = neoDevice->getDefaultEngine().commandStreamReceiver;
L0::CommandQueue *commandQueue = CommandQueue::create(productFamily,
@ -309,7 +154,6 @@ using CommandQueueDestroy = Test<DeviceFixture>;
HWTEST2_F(CommandQueueDestroy, whenCommandQueueDestroyIsCalledPrintPrintfOutputIsCalled, CommandQueueDestroySupport) {
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
auto csr = std::unique_ptr<NEO::CommandStreamReceiver>(neoDevice->createCommandStreamReceiver());
auto commandQueue = new MockCommandQueueHw<gfxCoreFamily>(device, csr.get(), &desc);
commandQueue->initialize(false);
@ -324,12 +168,7 @@ HWTEST2_F(CommandQueueDestroy, whenCommandQueueDestroyIsCalledPrintPrintfOutputI
using CommandQueueCommands = Test<DeviceFixture>;
HWTEST_F(CommandQueueCommands, givenCommandQueueWhenExecutingCommandListsThenHardwareContextIsProgrammedAndGlobalAllocationResident) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_NONE,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
MockCsrHw2<FamilyType> csr(*neoDevice->getExecutionEnvironment(), 0);
csr.initializeTagAllocation();
@ -364,12 +203,7 @@ HWTEST_F(CommandQueueCommands, givenCommandQueueWhenExecutingCommandListsThenHar
using CommandQueueIndirectAllocations = Test<ModuleFixture>;
HWTEST_F(CommandQueueIndirectAllocations, givenCommandQueueWhenExecutingCommandListsThenExpectedIndirectAllocationsAddedToResidencyContainer) {
const ze_command_queue_desc_t desc = {
ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT,
ZE_COMMAND_QUEUE_FLAG_NONE,
ZE_COMMAND_QUEUE_MODE_DEFAULT,
ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
0};
const ze_command_queue_desc_t desc = {};
MockCsrHw2<FamilyType> csr(*neoDevice->getExecutionEnvironment(), 0);
csr.initializeTagAllocation();
@ -385,7 +219,7 @@ HWTEST_F(CommandQueueIndirectAllocations, givenCommandQueueWhenExecutingCommandL
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, true));
void *deviceAlloc = nullptr;
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT, 16384u, 4096u, &deviceAlloc);
auto result = device->getDriverHandle()->allocDeviceMem(device->toHandle(), 0u, 16384u, 4096u, &deviceAlloc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(deviceAlloc)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
@ -425,7 +259,6 @@ using ContextCreateCommandQueueTest = Test<ContextFixture>;
TEST_F(ContextCreateCommandQueueTest, givenCallToContextCreateCommandQueueThenCallSucceeds) {
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
desc.ordinal = 0u;
ze_command_queue_handle_t commandQueue = {};

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

@ -26,7 +26,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, givenDebuggingEnabledWhenModuleIsCreatedTh
debugger->isOptDisabled = true;
uint8_t binary[10];
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = binary;
moduleDesc.inputSize = 10;
@ -47,7 +47,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, GivenDebuggeableKernelWhenModuleIsInitiali
device->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->compilerInterface.reset(cip);
uint8_t binary[10];
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = binary;
moduleDesc.inputSize = 10;
@ -79,7 +79,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, GivenNonDebuggeableKernelWhenModuleIsIniti
device->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->compilerInterface.reset(cip);
uint8_t binary[10];
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = binary;
moduleDesc.inputSize = 10;

111
level_zero/core/test/unit_tests/sources/device/test_device.cpp
View File

@ -71,40 +71,25 @@ TEST_F(DeviceTest, givenEmptySVmAllocStorageWhenAllocateMemoryFromHostPtrThenVal
}
TEST_F(DeviceTest, givenKernelPropertiesStructureWhenKernelPropertiesCalledThenAllPropertiesAreAssigned) {
ze_device_kernel_properties_t kernelProperties, kernelPropertiesBefore;
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_kernel_properties_t));
const auto &hardwareInfo = this->neoDevice->getHardwareInfo();
ze_device_module_properties_t kernelProperties, kernelPropertiesBefore;
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_module_properties_t));
kernelPropertiesBefore = kernelProperties;
device->getKernelProperties(&kernelProperties);
EXPECT_NE(kernelPropertiesBefore.spirvVersionSupported, kernelProperties.spirvVersionSupported);
EXPECT_NE(kernelPropertiesBefore.nativeKernelSupported.id, kernelProperties.nativeKernelSupported.id);
EXPECT_NE(kernelPropertiesBefore.fp16Supported, kernelProperties.fp16Supported);
EXPECT_NE(kernelPropertiesBefore.fp64Supported, kernelProperties.fp64Supported);
EXPECT_NE(kernelPropertiesBefore.int64AtomicsSupported, kernelProperties.int64AtomicsSupported);
EXPECT_TRUE(kernelPropertiesBefore.flags & ZE_DEVICE_MODULE_FLAG_FP16);
if (hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
EXPECT_TRUE(kernelPropertiesBefore.flags & ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS);
}
EXPECT_NE(kernelPropertiesBefore.maxArgumentsSize, kernelProperties.maxArgumentsSize);
EXPECT_NE(kernelPropertiesBefore.printfBufferSize, kernelProperties.printfBufferSize);
}
TEST_F(DeviceTest, givenDeviceWithCopyEngineThenNumAsyncCopyEnginesDevicePropertyIsCorrectlyReturned) {
ze_device_properties_t deviceProperties;
deviceProperties.version = ZE_DEVICE_PROPERTIES_VERSION_CURRENT;
deviceProperties.numAsyncCopyEngines = std::numeric_limits<int>::max();
device->getProperties(&deviceProperties);
auto expecteNumOfCopyEngines = NEO::HwHelper::getCopyEnginesCount(device->getNEODevice()->getHardwareInfo());
EXPECT_EQ(expecteNumOfCopyEngines, deviceProperties.numAsyncCopyEngines);
}
TEST_F(DeviceTest, givenDeviceWithComputeEngineThenNumAsyncComputeEnginesDevicePropertyIsCorrectlyReturned) {
ze_device_properties_t deviceProperties;
deviceProperties.version = ZE_DEVICE_PROPERTIES_VERSION_CURRENT;
deviceProperties.numAsyncComputeEngines = std::numeric_limits<int>::max();
device->getProperties(&deviceProperties);
auto expectedNumOfComputeEngines = NEO::HwHelper::getEnginesCount(device->getNEODevice()->getHardwareInfo());
EXPECT_EQ(expectedNumOfComputeEngines, deviceProperties.numAsyncComputeEngines);
}
TEST_F(DeviceTest, givenDevicePropertiesStructureWhenDevicePropertiesCalledThenAllPropertiesAreAssigned) {
ze_device_properties_t deviceProperties, devicePropertiesBefore;
@ -112,15 +97,8 @@ TEST_F(DeviceTest, givenDevicePropertiesStructureWhenDevicePropertiesCalledThenA
memset(&deviceProperties.vendorId, std::numeric_limits<int>::max(), sizeof(deviceProperties.vendorId));
memset(&deviceProperties.deviceId, std::numeric_limits<int>::max(), sizeof(deviceProperties.deviceId));
memset(&deviceProperties.uuid, std::numeric_limits<int>::max(), sizeof(deviceProperties.uuid));
memset(&deviceProperties.isSubdevice, std::numeric_limits<int>::max(), sizeof(deviceProperties.isSubdevice));
memset(&deviceProperties.subdeviceId, std::numeric_limits<int>::max(), sizeof(deviceProperties.subdeviceId));
memset(&deviceProperties.coreClockRate, std::numeric_limits<int>::max(), sizeof(deviceProperties.coreClockRate));
memset(&deviceProperties.unifiedMemorySupported, std::numeric_limits<int>::max(), sizeof(deviceProperties.unifiedMemorySupported));
memset(&deviceProperties.eccMemorySupported, std::numeric_limits<int>::max(), sizeof(deviceProperties.eccMemorySupported));
memset(&deviceProperties.onDemandPageFaultsSupported, std::numeric_limits<int>::max(), sizeof(deviceProperties.onDemandPageFaultsSupported));
memset(&deviceProperties.maxCommandQueues, std::numeric_limits<int>::max(), sizeof(deviceProperties.maxCommandQueues));
memset(&deviceProperties.numAsyncComputeEngines, std::numeric_limits<int>::max(), sizeof(deviceProperties.numAsyncComputeEngines));
memset(&deviceProperties.numAsyncCopyEngines, std::numeric_limits<int>::max(), sizeof(deviceProperties.numAsyncCopyEngines));
memset(&deviceProperties.maxCommandQueuePriority, std::numeric_limits<int>::max(), sizeof(deviceProperties.maxCommandQueuePriority));
memset(&deviceProperties.numThreadsPerEU, std::numeric_limits<int>::max(), sizeof(deviceProperties.numThreadsPerEU));
memset(&deviceProperties.physicalEUSimdWidth, std::numeric_limits<int>::max(), sizeof(deviceProperties.physicalEUSimdWidth));
@ -137,15 +115,8 @@ TEST_F(DeviceTest, givenDevicePropertiesStructureWhenDevicePropertiesCalledThenA
EXPECT_NE(deviceProperties.vendorId, devicePropertiesBefore.vendorId);
EXPECT_NE(deviceProperties.deviceId, devicePropertiesBefore.deviceId);
EXPECT_NE(0, memcmp(&deviceProperties.uuid, &devicePropertiesBefore.uuid, sizeof(devicePropertiesBefore.uuid)));
EXPECT_NE(deviceProperties.isSubdevice, devicePropertiesBefore.isSubdevice);
EXPECT_NE(deviceProperties.subdeviceId, devicePropertiesBefore.subdeviceId);
EXPECT_NE(deviceProperties.coreClockRate, devicePropertiesBefore.coreClockRate);
EXPECT_NE(deviceProperties.unifiedMemorySupported, devicePropertiesBefore.unifiedMemorySupported);
EXPECT_NE(deviceProperties.eccMemorySupported, devicePropertiesBefore.eccMemorySupported);
EXPECT_NE(deviceProperties.onDemandPageFaultsSupported, devicePropertiesBefore.onDemandPageFaultsSupported);
EXPECT_NE(deviceProperties.maxCommandQueues, devicePropertiesBefore.maxCommandQueues);
EXPECT_NE(deviceProperties.numAsyncComputeEngines, devicePropertiesBefore.numAsyncComputeEngines);
EXPECT_NE(deviceProperties.numAsyncCopyEngines, devicePropertiesBefore.numAsyncCopyEngines);
EXPECT_NE(deviceProperties.maxCommandQueuePriority, devicePropertiesBefore.maxCommandQueuePriority);
EXPECT_NE(deviceProperties.numThreadsPerEU, devicePropertiesBefore.numThreadsPerEU);
EXPECT_NE(deviceProperties.physicalEUSimdWidth, devicePropertiesBefore.physicalEUSimdWidth);
@ -190,20 +161,22 @@ struct DeviceHasNoDoubleFp64Test : public ::testing::Test {
};
TEST_F(DeviceHasNoDoubleFp64Test, givenDeviceThatDoesntHaveFp64WhenDbgFlagEnablesFp64ThenReportFp64Flags) {
ze_device_kernel_properties_t kernelProperties;
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_kernel_properties_t));
ze_device_module_properties_t kernelProperties;
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_module_properties_t));
device->getKernelProperties(&kernelProperties);
EXPECT_EQ(ZE_FP_CAPS_NONE, kernelProperties.doubleFpCapabilities);
EXPECT_EQ(ZE_FP_CAPS_NONE, kernelProperties.singleFpCapabilities);
EXPECT_EQ(0u, kernelProperties.fp64flags);
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.OverrideDefaultFP64Settings.set(1);
device->getKernelProperties(&kernelProperties);
EXPECT_EQ(true, kernelProperties.fp64Supported);
EXPECT_NE(ZE_FP_CAPS_NONE, kernelProperties.doubleFpCapabilities);
EXPECT_EQ(ZE_FP_CAPS_ROUNDED_DIVIDE_SQRT, kernelProperties.singleFpCapabilities);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_ROUND_TO_INF);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_INF_NAN);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_DENORM);
EXPECT_TRUE(kernelProperties.fp64flags & ZE_DEVICE_FP_FLAG_FMA);
}
struct MockMemoryManagerMultiDevice : public MemoryManagerMock {
@ -453,52 +426,6 @@ TEST_F(MultipleDevicesSameFamilyAndLocalMemorySupportTest, givenTwoDevicesFromSa
EXPECT_FALSE(canAccess);
}
TEST_F(DeviceTest, givenBlitterSupportAndCopyOnlyFlagWhenCopyOnlyDebugFlagIsDefaultThenUseBliterIsTrueAndSuccessIsReturned) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.blitterOperationsSupported = true;
auto *neoMockDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, rootDeviceIndex);
Mock<L0::DeviceImp> l0Device(neoMockDevice, neoDevice->getExecutionEnvironment());
ze_command_list_desc_t desc = {};
desc.flags = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
auto flag = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
bool useBliter = false;
ze_result_t res = l0Device.isCreatedCommandListCopyOnly(&desc, &useBliter, flag);
EXPECT_TRUE(useBliter);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
TEST_F(DeviceTest, givenBlitterSupportAndCopyOnlyFlagWhenCopyOnlyDebugFlagIsSetToZeroThenUseBliterIsFalseAndSuccessIsReturned) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableCopyOnlyCommandListsAndCommandQueues.set(0);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.blitterOperationsSupported = true;
auto *neoMockDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, rootDeviceIndex);
Mock<L0::DeviceImp> l0Device(neoMockDevice, neoDevice->getExecutionEnvironment());
ze_command_list_desc_t desc = {};
desc.flags = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
auto flag = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
bool useBliter = true;
ze_result_t res = l0Device.isCreatedCommandListCopyOnly(&desc, &useBliter, flag);
EXPECT_FALSE(useBliter);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
TEST_F(DeviceTest, givenBlitterSupportAndCopyOnlyFlagWhenCopyOnlyDebugFlagIsSetToOneThenUseBliterIsTrueAndSuccessIsReturned) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableCopyOnlyCommandListsAndCommandQueues.set(1);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.blitterOperationsSupported = true;
auto *neoMockDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, rootDeviceIndex);
Mock<L0::DeviceImp> l0Device(neoMockDevice, neoDevice->getExecutionEnvironment());
ze_command_list_desc_t desc = {};
desc.flags = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
auto flag = ZE_COMMAND_LIST_FLAG_COPY_ONLY;
bool useBliter = false;
ze_result_t res = l0Device.isCreatedCommandListCopyOnly(&desc, &useBliter, flag);
EXPECT_TRUE(useBliter);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
TEST_F(DeviceTest, givenNoActiveSourceLevelDebuggerWhenGetIsCalledThenNullptrIsReturned) {
EXPECT_EQ(nullptr, device->getSourceLevelDebugger());
}

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

@ -14,13 +14,13 @@
namespace L0 {
namespace ult {
using EventPoolCreate = Test<DeviceFixture>;
using EventCreate = Test<DeviceFixture>;
TEST_F(EventPoolCreate, allocationContainsAtLeast16Bytes) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
@ -35,10 +35,9 @@ TEST_F(EventPoolCreate, allocationContainsAtLeast16Bytes) {
}
TEST_F(EventPoolCreate, givenTimestampEventsThenEventSizeSufficientForAllKernelTimestamps) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
ASSERT_NE(nullptr, eventPool);
@ -49,15 +48,14 @@ TEST_F(EventPoolCreate, givenTimestampEventsThenEventSizeSufficientForAllKernelT
}
TEST_F(EventPoolCreate, givenAnEventIsCreatedFromThisEventPoolThenEventContainsDeviceCommandStreamReceiver) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
const ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_HOST,
ZE_EVENT_SCOPE_FLAG_HOST};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
ze_event_handle_t event = nullptr;
@ -73,11 +71,13 @@ TEST_F(EventPoolCreate, givenAnEventIsCreatedFromThisEventPoolThenEventContainsD
TEST_F(EventCreate, givenAnEventCreatedThenTheEventHasTheDeviceCommandStreamReceiverSet) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
const ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
0,
ZE_EVENT_SCOPE_FLAG_DEVICE,
ZE_EVENT_SCOPE_FLAG_DEVICE};
@ -93,12 +93,14 @@ TEST_F(EventCreate, givenAnEventCreatedThenTheEventHasTheDeviceCommandStreamRece
TEST_F(EventCreate, givenAnEventCreateWithInvalidIndexUsingThisEventPoolThenErrorIsReturned) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
const ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
1,
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
2,
ZE_EVENT_SCOPE_FLAG_DEVICE,
ZE_EVENT_SCOPE_FLAG_DEVICE};
@ -115,7 +117,8 @@ TEST_F(EventCreate, givenAnEventCreateWithInvalidIndexUsingThisEventPoolThenErro
TEST_F(EventPoolCreate, returnsSuccessFromCreateEventPoolWithNoDevice) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
4};
@ -127,7 +130,8 @@ TEST_F(EventPoolCreate, returnsSuccessFromCreateEventPoolWithNoDevice) {
TEST_F(EventPoolCreate, returnsSuccessFromCreateEventPoolWithDevice) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
4};
@ -163,7 +167,8 @@ struct EventCreateAllocationResidencyTest : public ::testing::Test {
TEST_F(EventCreateAllocationResidencyTest,
givenEventCreateAndEventDestroyCallsThenMakeResidentAndEvictAreCalled) {
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
1};
@ -171,11 +176,12 @@ TEST_F(EventCreateAllocationResidencyTest,
auto eventPool = EventPool::create(driverHandle.get(), 1, &deviceHandle, &eventPoolDesc);
ASSERT_NE(nullptr, eventPool);
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
const ze_event_desc_t eventDesc = {
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ZE_EVENT_SCOPE_FLAG_DEVICE,
ZE_EVENT_SCOPE_FLAG_DEVICE};
EXPECT_CALL(*mockMemoryOperationsHandler, makeResident).Times(1);
auto event = L0::Event::create(eventPool, &eventDesc, device);
@ -195,16 +201,14 @@ class TimestampEventCreate : public Test<DeviceFixture> {
public:
void SetUp() override {
DeviceFixture::SetUp();
ze_event_pool_desc_t eventPoolDesc = {
ZE_EVENT_POOL_DESC_VERSION_CURRENT,
ZE_EVENT_POOL_FLAG_TIMESTAMP,
1};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {
ZE_EVENT_DESC_VERSION_CURRENT,
0,
ZE_EVENT_SCOPE_FLAG_NONE,
ZE_EVENT_SCOPE_FLAG_NONE};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = 0;
eventDesc.wait = 0;
eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
ASSERT_NE(nullptr, eventPool);
@ -224,20 +228,6 @@ TEST_F(TimestampEventCreate, givenEventCreatedWithTimestampThenIsTimestampEventF
EXPECT_TRUE(event->isTimestampEvent);
}
TEST_F(TimestampEventCreate, givenEventTimestampsNotTriggeredThenValuesInInitialState) {
uint64_t globalStart, globalEnd, contextStart, contextEnd;
event->getTimestamp(ZE_EVENT_TIMESTAMP_GLOBAL_START, &globalStart);
event->getTimestamp(ZE_EVENT_TIMESTAMP_GLOBAL_END, &globalEnd);
event->getTimestamp(ZE_EVENT_TIMESTAMP_CONTEXT_START, &contextStart);
event->getTimestamp(ZE_EVENT_TIMESTAMP_CONTEXT_END, &contextEnd);
EXPECT_EQ(static_cast<uint64_t>(Event::STATE_CLEARED), globalStart);
EXPECT_EQ(static_cast<uint64_t>(Event::STATE_CLEARED), globalEnd);
EXPECT_EQ(static_cast<uint64_t>(Event::STATE_CLEARED), contextStart);
EXPECT_EQ(static_cast<uint64_t>(Event::STATE_CLEARED), contextEnd);
}
TEST_F(TimestampEventCreate, givenSingleTimestampEventThenAllocationSizeCreatedForAllTimestamps) {
auto allocation = &eventPool->getAllocation();
ASSERT_NE(nullptr, allocation);

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

@ -81,8 +81,7 @@ HWTEST2_F(ImageCreate, givenValidImageDescriptionWhenImageCreateThenImageIsCreat
zeDesc.width = 1u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
zeDesc.version = ZE_IMAGE_DESC_VERSION_CURRENT;
zeDesc.flags = ZE_IMAGE_FLAG_PROGRAM_READ;
zeDesc.flags = ZE_IMAGE_FLAG_BIAS_UNCACHED;
zeDesc.format = {ZE_IMAGE_FORMAT_LAYOUT_32,
ZE_IMAGE_FORMAT_TYPE_UINT,
@ -174,15 +173,15 @@ HWTEST2_P(TestImageFormats, givenValidLayoutAndTypeWhenCreateImageCoreFamilyThen
zeDesc.width = 10u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2D;
zeDesc.version = ZE_IMAGE_DESC_VERSION_CURRENT;
zeDesc.flags = ZE_IMAGE_FLAG_PROGRAM_READ;
zeDesc.flags = ZE_IMAGE_FLAG_KERNEL_WRITE;
zeDesc.format = {params.first,
params.second,
ZE_IMAGE_FORMAT_SWIZZLE_R,
ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_A};
zeDesc.format = {};
zeDesc.format.layout = params.first;
zeDesc.format.type = params.second;
zeDesc.format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
zeDesc.format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
zeDesc.format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
zeDesc.format.w = ZE_IMAGE_FORMAT_SWIZZLE_A;
auto imageHW = std::make_unique<WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>>>();
@ -394,7 +393,7 @@ TEST(ImageFormatDescHelperTest, givenSwizzlesThenEqualityIsProperlyDetermined) {
}
TEST(ImageFormatDescHelperTest, givenSupportedSwizzlesThenProperClEnumIsReturned) {
ze_image_format_desc_t format{};
ze_image_format_t format{};
format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
format.y = ZE_IMAGE_FORMAT_SWIZZLE_0;

26
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -208,8 +208,6 @@ class KernelPropertiesTests : public ModuleFixture, public ::testing::Test {
ModuleFixture::SetUp();
ze_kernel_desc_t kernelDesc = {};
kernelDesc.version = ZE_KERNEL_DESC_VERSION_CURRENT;
kernelDesc.flags = ZE_KERNEL_FLAG_NONE;
kernelDesc.pKernelName = kernelName.c_str();
ze_result_t res = module->createKernel(&kernelDesc, &kernelHandle);
@ -248,14 +246,14 @@ HWTEST_F(KernelPropertiesTests, givenKernelThenCorrectNameIsRetrieved) {
}
HWTEST_F(KernelPropertiesTests, givenInvalidKernelThenUnitializedIsReturned) {
ze_kernel_propertiesExt_t kernelProperties = {};
ze_kernel_properties_t kernelProperties = {};
std::vector<KernelInfo *> prevKernelInfos;
L0::ModuleImp *moduleImp = reinterpret_cast<L0::ModuleImp *>(module.get());
moduleImp->getTranslationUnit()->programInfo.kernelInfos.swap(prevKernelInfos);
EXPECT_EQ(0u, moduleImp->getTranslationUnit()->programInfo.kernelInfos.size());
ze_result_t res = kernel->getPropertiesExt(&kernelProperties);
ze_result_t res = kernel->getProperties(&kernelProperties);
EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, res);
prevKernelInfos.swap(moduleImp->getTranslationUnit()->programInfo.kernelInfos);
@ -263,7 +261,7 @@ HWTEST_F(KernelPropertiesTests, givenInvalidKernelThenUnitializedIsReturned) {
}
HWTEST_F(KernelPropertiesTests, givenValidKernelThenPropertiesAreRetrieved) {
ze_kernel_propertiesExt_t kernelProperties = {};
ze_kernel_properties_t kernelProperties = {};
kernelProperties.requiredNumSubGroups = std::numeric_limits<uint32_t>::max();
kernelProperties.requiredSubgroupSize = std::numeric_limits<uint32_t>::max();
@ -278,14 +276,12 @@ HWTEST_F(KernelPropertiesTests, givenValidKernelThenPropertiesAreRetrieved) {
memset(&kernelProperties.uuid.mid, std::numeric_limits<int>::max(),
sizeof(kernelProperties.uuid.mid));
ze_kernel_propertiesExt_t kernelPropertiesBefore = {};
ze_kernel_properties_t kernelPropertiesBefore = {};
kernelPropertiesBefore = kernelProperties;
ze_result_t res = kernel->getPropertiesExt(&kernelProperties);
ze_result_t res = kernel->getProperties(&kernelProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(0, strncmp(kernelName.c_str(), kernelProperties.name,
sizeof(kernelProperties.name)));
EXPECT_EQ(numKernelArguments, kernelProperties.numKernelArgs);
L0::ModuleImp *moduleImp = reinterpret_cast<L0::ModuleImp *>(module.get());
@ -334,14 +330,14 @@ HWTEST_F(KernelPropertiesTests, givenValidKernelThenPropertiesAreRetrieved) {
}
HWTEST_F(KernelPropertiesTests, givenValidKernelAndNoMediavfestateThenSpillMemSizeIsZero) {
ze_kernel_propertiesExt_t kernelProperties = {};
ze_kernel_properties_t kernelProperties = {};
kernelProperties.spillMemSize = std::numeric_limits<uint32_t>::max();
ze_kernel_propertiesExt_t kernelPropertiesBefore = {};
ze_kernel_properties_t kernelPropertiesBefore = {};
kernelPropertiesBefore = kernelProperties;
ze_result_t res = kernel->getPropertiesExt(&kernelProperties);
ze_result_t res = kernel->getProperties(&kernelProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
L0::ModuleImp *moduleImp = reinterpret_cast<L0::ModuleImp *>(module.get());
@ -358,14 +354,14 @@ HWTEST_F(KernelPropertiesTests, givenValidKernelAndNoMediavfestateThenSpillMemSi
}
HWTEST_F(KernelPropertiesTests, givenValidKernelAndNollocateStatelessPrivateSurfaceThenPrivateMemSizeIsZero) {
ze_kernel_propertiesExt_t kernelProperties = {};
ze_kernel_properties_t kernelProperties = {};
kernelProperties.spillMemSize = std::numeric_limits<uint32_t>::max();
ze_kernel_propertiesExt_t kernelPropertiesBefore = {};
ze_kernel_properties_t kernelPropertiesBefore = {};
kernelPropertiesBefore = kernelProperties;
ze_result_t res = kernel->getPropertiesExt(&kernelProperties);
ze_result_t res = kernel->getProperties(&kernelProperties);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
L0::ModuleImp *moduleImp = reinterpret_cast<L0::ModuleImp *>(module.get());

50
level_zero/core/test/unit_tests/sources/memory/test_memory.cpp
View File

@ -23,13 +23,12 @@ TEST_F(MemoryTest, givenDevicePointerThenDriverGetAllocPropertiesReturnsDeviceHa
void *ptr = nullptr;
ze_result_t result = driverHandle->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
result = driverHandle->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);
@ -50,7 +49,7 @@ TEST_F(DeviceMemorySizeTest, givenSizeGreaterThanLimitThenDeviceAllocationFails)
void *ptr = nullptr;
ze_result_t result = driverHandle->allocDeviceMem(nullptr,
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_SIZE, result);
}
@ -61,14 +60,13 @@ TEST_F(MemoryTest, givenSharedPointerThenDriverGetAllocPropertiesReturnsDeviceHa
void *ptr = nullptr;
ze_result_t result = driverHandle->allocSharedMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
0u,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
result = driverHandle->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);
@ -86,13 +84,12 @@ TEST_F(MemoryTest, givenHostPointerThenDriverGetAllocPropertiesReturnsNullDevice
size_t alignment = 1u;
void *ptr = nullptr;
ze_result_t result = driverHandle->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ze_result_t result = driverHandle->allocHostMem(0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
result = driverHandle->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);
@ -110,7 +107,6 @@ TEST_F(MemoryTest, givenSystemAllocatedPointerThenDriverGetAllocPropertiesReturn
int *ptr = new int[size];
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
ze_result_t result = driverHandle->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);
@ -127,8 +123,8 @@ TEST_F(MemoryTest, givenSharedPointerAndDeviceHandleAsNullThenDriverReturnsSucce
ASSERT_NE(nullptr, device->toHandle());
ze_result_t result = driverHandle->allocSharedMem(nullptr,
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
0u,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -144,8 +140,8 @@ TEST_F(MemoryTest, givenNoDeviceWhenAllocatingSharedMemoryThenDeviceInAllocation
ASSERT_NE(nullptr, device->toHandle());
ze_result_t result = driverHandle->allocSharedMem(nullptr,
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
0u,
0u,
size, alignment, &ptr);
auto alloc = driverHandle->svmAllocsManager->getSVMAlloc(ptr);
EXPECT_EQ(alloc->device, nullptr);
@ -193,14 +189,13 @@ struct MemoryBitfieldTest : testing::Test {
TEST_F(MemoryBitfieldTest, givenDeviceWithValidBitfieldWhenAllocatingDeviceMemoryThenPassProperBitfield) {
auto result = driverHandle->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(neoDevice->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
}
TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemoryThenPassProperBitfield) {
DebugManagerStateRestore restorer;
size_t size = 10;
@ -229,8 +224,8 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
EXPECT_NE(neoDevice0->getDeviceBitfield(), neoDevice1->getDeviceBitfield());
EXPECT_NE(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
auto result = driverHandle->allocSharedMem(nullptr,
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD,
0u,
size, alignment, &ptr);
EXPECT_EQ(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
@ -242,8 +237,8 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
memoryManager->recentlyPassedDeviceBitfield = {};
EXPECT_NE(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
result = driverHandle->allocSharedMem(driverHandle->devices[1]->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD,
0u,
size, alignment, &ptr);
EXPECT_EQ(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
@ -310,7 +305,7 @@ TEST_F(AllocHostMemoryTest,
whenCallingAllocHostMemThenAllocateGraphicsMemoryWithPropertiesIsCalledTheNumberOfTimesOfRootDevices) {
void *ptr = nullptr;
ze_result_t result = driverHandle->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ze_result_t result = driverHandle->allocHostMem(0u,
4096u, 0u, &ptr);
EXPECT_EQ(memoryManager->allocateGraphicsMemoryWithPropertiesCount, numRootDevices);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@ -326,7 +321,7 @@ TEST_F(AllocHostMemoryTest,
void *ptr = nullptr;
ze_result_t result = driverHandle->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ze_result_t result = driverHandle->allocHostMem(0u,
4096u, 0u, &ptr);
EXPECT_EQ(memoryManager->allocateGraphicsMemoryWithPropertiesCount, 1u);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
@ -340,7 +335,7 @@ TEST_F(AllocHostMemoryTest,
void *ptr = nullptr;
ze_result_t result = driverHandle->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ze_result_t result = driverHandle->allocHostMem(0u,
4096u, 0u, &ptr);
EXPECT_EQ(memoryManager->allocateGraphicsMemoryWithPropertiesCount, numRootDevices);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
@ -355,8 +350,8 @@ TEST_F(ContextMemoryTest, whenAllocatingSharedAllocationFromContextThenAllocatio
void *ptr = nullptr;
ze_result_t result = context->allocSharedMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
0u,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -370,7 +365,7 @@ TEST_F(ContextMemoryTest, whenAllocatingHostAllocationFromContextThenAllocationS
size_t alignment = 1u;
void *ptr = nullptr;
ze_result_t result = context->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT,
ze_result_t result = context->allocHostMem(0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -385,7 +380,7 @@ TEST_F(ContextMemoryTest, whenAllocatingDeviceAllocationFromContextThenAllocatio
void *ptr = nullptr;
ze_result_t result = context->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
@ -400,7 +395,7 @@ TEST_F(ContextMemoryTest, whenRetrievingAddressRangeForDeviceAllocationThenRange
void *allocPtr = nullptr;
ze_result_t result = context->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
allocSize, alignment, &allocPtr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, allocPtr);
@ -422,7 +417,6 @@ TEST_F(ContextMemoryTest, givenSystemAllocatedPointerThenGetAllocPropertiesRetur
int *ptr = new int[size];
ze_memory_allocation_properties_t memoryProperties = {};
memoryProperties.version = ZE_MEMORY_ALLOCATION_PROPERTIES_VERSION_CURRENT;
ze_device_handle_t deviceHandle;
ze_result_t result = context->getMemAllocProperties(ptr, &memoryProperties, &deviceHandle);

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

@ -37,8 +37,6 @@ HWTEST_F(ModuleTest, givenKernelCreateReturnsSuccess) {
ze_kernel_handle_t kernelHandle;
ze_kernel_desc_t kernelDesc = {};
kernelDesc.version = ZE_KERNEL_DESC_VERSION_CURRENT;
kernelDesc.flags = ZE_KERNEL_FLAG_NONE;
kernelDesc.pKernelName = kernelName.c_str();
ze_result_t res = module->createKernel(&kernelDesc, &kernelHandle);
@ -55,8 +53,6 @@ HWTEST2_F(ModuleTest, givenNonPatchedTokenThenSurfaceBaseAddressIsCorrectlySet,
ze_kernel_handle_t kernelHandle;
ze_kernel_desc_t kernelDesc = {};
kernelDesc.version = ZE_KERNEL_DESC_VERSION_CURRENT;
kernelDesc.flags = ZE_KERNEL_FLAG_NONE;
kernelDesc.pKernelName = kernelName.c_str();
ze_result_t res = module->createKernel(&kernelDesc, &kernelHandle);
@ -67,7 +63,7 @@ HWTEST2_F(ModuleTest, givenNonPatchedTokenThenSurfaceBaseAddressIsCorrectlySet,
void *devicePtr = nullptr;
res = device->getDriverHandle()->allocDeviceMem(device->toHandle(),
ZE_DEVICE_MEM_ALLOC_FLAG_DEFAULT,
0u,
16384u,
0u,
&devicePtr);
@ -93,8 +89,6 @@ HWTEST_F(ModuleTest, givenKernelCreateWithIncorrectKernelNameReturnsFailure) {
ze_kernel_handle_t kernelHandle;
ze_kernel_desc_t kernelDesc = {};
kernelDesc.version = ZE_KERNEL_DESC_VERSION_CURRENT;
kernelDesc.flags = ZE_KERNEL_FLAG_NONE;
kernelDesc.pKernelName = "nonexistent_function";
ze_result_t res = module->createKernel(&kernelDesc, &kernelHandle);
@ -120,7 +114,7 @@ struct ModuleSpecConstantsTests : public DeviceFixture,
const uint32_t moduleNumSpecConstants = 4;
ze_module_constants_t specConstants;
std::vector<uint64_t> specConstantsPointerValues;
std::vector<const void *> specConstantsPointerValues;
const std::string binaryFilename = "test_kernel";
const std::string kernelName = "test";
@ -138,14 +132,14 @@ HWTEST_F(ModuleSpecConstantsTests, givenSpecializationConstantsSetInDescriptorTh
ASSERT_NE(0u, size);
ASSERT_NE(nullptr, src);
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;
specConstants.numConstants = mockCompiler->moduleNumSpecConstants;
for (uint32_t i = 0; i < mockCompiler->moduleNumSpecConstants; i++) {
specConstantsPointerValues.push_back(reinterpret_cast<uint64_t>(&mockCompiler->moduleSpecConstantsValues[i]));
specConstantsPointerValues.push_back(&mockCompiler->moduleSpecConstantsValues[i]);
}
specConstants.pConstantIds = mockCompiler->moduleSpecConstantsIds.data();
@ -175,7 +169,7 @@ HWTEST_F(ModuleLinkingTest, givenFailureDuringLinkingWhenCreatingModuleThenModul
mockTranslationUnit->programInfo.linkerInput = std::move(linkerInput);
uint8_t spirvData{};
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = &spirvData;
moduleDesc.inputSize = sizeof(spirvData);
@ -204,7 +198,7 @@ HWTEST_F(ModuleLinkingTest, givenRemainingUnresolvedSymbolsDuringLinkingWhenCrea
mockTranslationUnit->programInfo.linkerInput = std::move(linkerInput);
uint8_t spirvData{};
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = &spirvData;
moduleDesc.inputSize = sizeof(spirvData);
@ -237,7 +231,6 @@ HWTEST_F(ModuleDynamicLinkTests, givenCallToDynamicLinkThenUnsupportedFeatureIsR
delete module0;
delete module1;
}
class MultiDeviceModuleSetArgBufferTest : public MultiDeviceModuleFixture, public ::testing::Test {
public:
void SetUp() override {
@ -250,13 +243,11 @@ class MultiDeviceModuleSetArgBufferTest : public MultiDeviceModuleFixture, publi
void createKernelAndAllocMemory(uint32_t rootDeviceIndex, void **ptr, ze_kernel_handle_t *kernelHandle) {
ze_kernel_desc_t kernelDesc = {};
kernelDesc.version = ZE_KERNEL_DESC_VERSION_CURRENT;
kernelDesc.flags = ZE_KERNEL_FLAG_NONE;
kernelDesc.pKernelName = kernelName.c_str();
ze_result_t res = modules[rootDeviceIndex].get()->createKernel(&kernelDesc, kernelHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
res = driverHandle->allocHostMem(ZE_HOST_MEM_ALLOC_FLAG_DEFAULT, 4096u, rootDeviceIndex, ptr);
res = driverHandle->allocHostMem(0u, 4096u, rootDeviceIndex, ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
};
@ -297,7 +288,7 @@ HWTEST_F(ContextModuleCreateTest, givenCallToCreateModuleThenModuleIsReturned) {
ASSERT_NE(0u, size);
ASSERT_NE(nullptr, src);
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
ze_module_desc_t moduleDesc = {};
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;

2
level_zero/core/test/unit_tests/sources/sampler/test_sampler.cpp
View File

@ -55,7 +55,6 @@ HWTEST2_P(SamplerCreateTest, givenDifferentDescriptorValuesThenSamplerIsCorrectl
ze_bool_t isNormalized = std::get<2>(GetParam());
ze_sampler_desc_t desc = {};
desc.version = ZE_SAMPLER_DESC_VERSION_CURRENT;
desc.addressMode = addressMode;
desc.filterMode = filterMode;
desc.isNormalized = isNormalized;
@ -159,7 +158,6 @@ HWTEST2_F(ContextCreateSamplerTest, givenDifferentDescriptorValuesThenSamplerIsC
ze_bool_t isNormalized = false;
ze_sampler_desc_t desc = {};
desc.version = ZE_SAMPLER_DESC_VERSION_CURRENT;
desc.addressMode = addressMode;
desc.filterMode = filterMode;
desc.isNormalized = isNormalized;

4
level_zero/ddi/ze_ddi_tables.h
View File

@ -7,6 +7,9 @@
#pragma once
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include <level_zero/zes_api.h>
#include <level_zero/zes_ddi.h>
#include <level_zero/zet_api.h>
#include <level_zero/zet_ddi.h>
@ -18,6 +21,7 @@ typedef struct _ze_gpu_driver_dditable_t {
ze_dditable_t core_ddiTable;
ze_dditable_t tracing_ddiTable;
zet_dditable_t tools_ddiTable;
zes_dditable_t sysman_ddiTable;
ze_api_version_t version = ZE_API_VERSION_1_0;

64
level_zero/experimental/source/tracing/CMakeLists.txt
View File

@ -5,39 +5,37 @@
#
set(L0_SRCS_EXPERIMENTAL_TRACING
${CMAKE_CURRENT_SOURCE_DIR}/tracing.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cl_interop_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cl_interop_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_barrier_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdlist_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_cmdqueue_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_copy_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_device_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_driver_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_event_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_fence_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_global_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_sampler_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_residency_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_image_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_memory_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tracing_module_imp.h
)
target_sources(${L0_STATIC_LIB_NAME}

16
level_zero/experimental/source/tracing/tracing.h
View File

@ -6,25 +6,25 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zet_tracing.h>
struct _zet_tracer_handle_t {};
#include <level_zero/zet_api.h>
struct _zet_tracer_exp_handle_t {};
namespace L0 {
struct APITracer : _zet_tracer_handle_t {
struct APITracer : _zet_tracer_exp_handle_t {
static APITracer *create();
virtual ~APITracer() = default;
static APITracer *fromHandle(zet_tracer_handle_t handle) { return static_cast<APITracer *>(handle); }
inline zet_tracer_handle_t toHandle() { return this; }
virtual ze_result_t destroyTracer(zet_tracer_handle_t phTracer) = 0;
static APITracer *fromHandle(zet_tracer_exp_handle_t handle) { return static_cast<APITracer *>(handle); }
inline zet_tracer_exp_handle_t toHandle() { return this; }
virtual ze_result_t destroyTracer(zet_tracer_exp_handle_t phTracer) = 0;
virtual ze_result_t setPrologues(zet_core_callbacks_t *pCoreCbs) = 0;
virtual ze_result_t setEpilogues(zet_core_callbacks_t *pCoreCbs) = 0;
virtual ze_result_t enableTracer(ze_bool_t enable) = 0;
};
ze_result_t createAPITracer(zet_driver_handle_t hDriver, const zet_tracer_desc_t *desc, zet_tracer_handle_t *phTracer);
ze_result_t createAPITracer(zet_context_handle_t hContext, const zet_tracer_exp_desc_t *desc, zet_tracer_exp_handle_t *phTracer);
struct APITracerContext {
virtual ~APITracerContext() = default;

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

@ -84,24 +84,3 @@ zeCommandListAppendMemoryRangesBarrier_Tracing(ze_command_list_handle_t hCommand
*tracerParams.pnumWaitEvents,
*tracerParams.pphWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceSystemBarrier_Tracing(ze_device_handle_t hDevice) {
ZE_HANDLE_TRACER_RECURSION(driver_ddiTable.core_ddiTable.Device.pfnSystemBarrier,
hDevice);
ze_device_system_barrier_params_t tracerParams;
tracerParams.phDevice = &hDevice;
L0::APITracerCallbackDataImp<ze_pfnDeviceSystemBarrierCb_t> apiCallbackData;
ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnDeviceSystemBarrierCb_t, Device, pfnSystemBarrierCb);
return L0::APITracerWrapperImp(driver_ddiTable.core_ddiTable.Device.pfnSystemBarrier,
&tracerParams,
apiCallbackData.apiOrdinal,
apiCallbackData.prologCallbacks,
apiCallbackData.epilogCallbacks,
*tracerParams.phDevice);
}

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

@ -7,8 +7,6 @@
#pragma once
#include "third_party/level_zero/ze_api_ext.h"
extern "C" {
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -16,6 +14,7 @@ zeCommandListAppendBarrier_Tracing(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,
@ -24,6 +23,4 @@ zeCommandListAppendMemoryRangesBarrier_Tracing(ze_command_list_handle_t hCommand
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeDeviceSystemBarrier_Tracing(ze_device_handle_t hDevice);
}

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