Skip to content

Commit 2c01616

Browse files
vishnu-khanthvishnu-khanth
committed
test: Add tests for zer API's
Signed-off-by: Vishnu Khanth <vishnu.khanth.b@intel.com>
1 parent b8ab77b commit 2c01616

4 files changed

Lines changed: 194 additions & 15 deletions

File tree

‎source/drivers/null/ze_null.cpp‎

Lines changed: 39 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,13 @@ namespace driver
2222
//////////////////////////////////////////////////////////////////////////
2323
context_t::context_t()
2424
{
25+
auto ddi_test_disable = getenv_string( "ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT" );
26+
#ifndef ZEL_NULL_DRIVER_ID
27+
#define ZEL_NULL_DRIVER_ID 1
28+
#endif
29+
std::string null_driver_id_str = std::to_string(ZEL_NULL_DRIVER_ID);
30+
ddiExtensionSupported = (ddi_test_disable != null_driver_id_str && ddi_test_disable != "3");
31+
2532
zesDdiTable.Driver.pfnGet = [](
2633
uint32_t* pCount,
2734
ze_driver_handle_t* phDrivers )
@@ -69,15 +76,9 @@ namespace driver
6976
{
7077
auto pNext = reinterpret_cast<ze_base_properties_t *>(pDriverProperties->pNext);
7178
while (pNext) {
72-
auto ddi_test_disable = getenv_string( "ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT" );
73-
#ifndef ZEL_NULL_DRIVER_ID
74-
#define ZEL_NULL_DRIVER_ID 1
75-
#endif
76-
std::string null_driver_id_str = std::to_string(ZEL_NULL_DRIVER_ID);
77-
if (pNext->stype == ZE_STRUCTURE_TYPE_DRIVER_DDI_HANDLES_EXT_PROPERTIES && (ddi_test_disable != null_driver_id_str && ddi_test_disable != "3")) {
79+
if (pNext->stype == ZE_STRUCTURE_TYPE_DRIVER_DDI_HANDLES_EXT_PROPERTIES && context.ddiExtensionSupported) {
7880
ze_driver_ddi_handles_ext_properties_t *pDdiHandlesExtProperties = reinterpret_cast<ze_driver_ddi_handles_ext_properties_t *>(pNext);
7981
pDdiHandlesExtProperties->flags = ze_driver_ddi_handle_ext_flag_t::ZE_DRIVER_DDI_HANDLE_EXT_FLAG_DDI_HANDLE_EXT_SUPPORTED;
80-
context.ddiExtensionRequested = true;
8182
}
8283
pNext = reinterpret_cast<ze_base_properties_t *>(pNext->pNext);
8384
}
@@ -487,17 +488,32 @@ namespace driver
487488
{
488489
if( nullptr != pExtensionProperties )
489490
{
490-
ze_driver_extension_properties_t driverExtensionProperties = {};
491+
ze_driver_extension_properties_t tracingExtension = {};
492+
#if defined(_WIN32)
493+
strcpy_s( tracingExtension.name, ZET_API_TRACING_EXP_NAME );
494+
#else
495+
strcpy( tracingExtension.name, ZET_API_TRACING_EXP_NAME );
496+
#endif
497+
tracingExtension.version = ZET_API_TRACING_EXP_VERSION_1_0;
498+
pExtensionProperties[0] = tracingExtension;
499+
500+
ze_driver_extension_properties_t ddiHandlesExtension = {};
491501
#if defined(_WIN32)
492-
strcpy_s( driverExtensionProperties.name, ZET_API_TRACING_EXP_NAME );
502+
strcpy_s( ddiHandlesExtension.name, ZE_DRIVER_DDI_HANDLES_EXT_NAME );
493503
#else
494-
strcpy( driverExtensionProperties.name, ZET_API_TRACING_EXP_NAME );
504+
strcpy( ddiHandlesExtension.name, ZE_DRIVER_DDI_HANDLES_EXT_NAME );
495505
#endif
496-
driverExtensionProperties.version = ZET_API_TRACING_EXP_VERSION_1_0;
497506

498-
*pExtensionProperties = driverExtensionProperties;
507+
auto ddi_version_env = getenv_string("ZEL_TEST_DDI_HANDLES_EXT_VERSION");
508+
if (!ddi_version_env.empty() && ddi_version_env == "1_0") {
509+
ddiHandlesExtension.version = ZE_DRIVER_DDI_HANDLES_EXT_VERSION_1_0;
510+
} else {
511+
ddiHandlesExtension.version = ZE_DRIVER_DDI_HANDLES_EXT_VERSION_1_1;
512+
}
513+
514+
pExtensionProperties[1] = ddiHandlesExtension;
499515
}
500-
*pCount = 1;
516+
*pCount = 2;
501517

502518
return ZE_RESULT_SUCCESS;
503519
};
@@ -629,6 +645,16 @@ namespace driver
629645
pSysman.Driver = &zesDdiTable.Driver;
630646
pSysman.isValidFlag = 1;
631647
pSysman.version = ZE_API_VERSION_CURRENT;
648+
649+
static zer_global_dditable_t runtimeDdiTable;
650+
runtimeDdiTable.pfnGetLastErrorDescription = driver::zerGetLastErrorDescription;
651+
runtimeDdiTable.pfnTranslateDeviceHandleToIdentifier = driver::zerTranslateDeviceHandleToIdentifier;
652+
runtimeDdiTable.pfnTranslateIdentifierToDeviceHandle = driver::zerTranslateIdentifierToDeviceHandle;
653+
runtimeDdiTable.pfnGetDefaultContext = driver::zerGetDefaultContext;
654+
655+
pRuntime.Global = &runtimeDdiTable;
656+
pRuntime.isValidFlag = 1;
657+
pRuntime.version = ZE_API_VERSION_CURRENT;
632658
}
633659

634660
char *context_t::setenv_var_with_driver_id(const std::string &key, uint32_t driverId)

‎source/drivers/null/ze_null.h‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,15 +45,15 @@ namespace driver
4545
zes_dditable_t zesDdiTable = {};
4646
zer_dditable_t zerDdiTable = {};
4747
std::vector<BaseNullHandle*> globalBaseNullHandle;
48-
bool ddiExtensionRequested = false;
48+
bool ddiExtensionSupported = false;
4949
std::vector<char *> env_vars{};
5050
context_t();
5151
~context_t();
5252

5353
void* get( void )
5454
{
5555
static uint64_t count = 0x80800000 >> ZEL_NULL_DRIVER_ID;
56-
if (ddiExtensionRequested) {
56+
if (ddiExtensionSupported) {
5757
globalBaseNullHandle.push_back(new BaseNullHandle());
5858
return reinterpret_cast<void*>(globalBaseNullHandle.back());
5959
} else {
@@ -64,6 +64,11 @@ namespace driver
6464
char *setenv_var_with_driver_id(const std::string &key, uint32_t driverId);
6565
};
6666

67+
ze_result_t ZE_APICALL zerGetLastErrorDescription(const char **ppString);
68+
uint32_t ZE_APICALL zerTranslateDeviceHandleToIdentifier(ze_device_handle_t hDevice);
69+
ze_device_handle_t ZE_APICALL zerTranslateIdentifierToDeviceHandle(uint32_t identifier);
70+
ze_context_handle_t ZE_APICALL zerGetDefaultContext(void);
71+
6772
extern context_t context;
6873
} // namespace driver
6974

‎test/CMakeLists.txt‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -596,7 +596,35 @@ set_property(TEST driver_ordering_trim_function PROPERTY ENVIRONMENT "ZE_ENABLE_
596596
add_test(NAME driver_ordering_parse_driver_order COMMAND tests --gtest_filter=DriverOrderingHelperFunctionsTest.ParseDriverOrder_*)
597597
set_property(TEST driver_ordering_parse_driver_order PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
598598

599+
add_test(NAME tests_sigle_driver_runtime_api_ddi_ext_v1_1 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
600+
set_property(TEST tests_sigle_driver_runtime_api_ddi_ext_v1_1 PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
599601

602+
add_test(NAME tests_multi_driver_runtime_api_ddi_ext_v1_1 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
603+
if (MSVC)
604+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_1 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
605+
else()
606+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_1 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
607+
endif()
608+
609+
add_test(NAME tests_single_driver_runtime_api_ddi_ext_unsupported COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtNotSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
610+
set_property(TEST tests_single_driver_runtime_api_ddi_ext_unsupported PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
611+
612+
add_test(NAME tests_multi_driver_runtime_api_ddi_ext_unsupported COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtNotSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
613+
if (MSVC)
614+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_unsupported APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
615+
else()
616+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_unsupported APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
617+
endif()
618+
619+
add_test(NAME tests_sigle_driver_runtime_api_ddi_ext_v1_0 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
620+
set_property(TEST tests_sigle_driver_runtime_api_ddi_ext_v1_0 PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
621+
622+
add_test(NAME tests_multi_driver_runtime_api_ddi_ext_v1_0 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
623+
if (MSVC)
624+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_0 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
625+
else()
626+
set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_0 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
627+
endif()
600628

601629
# These tests are currently not supported on Windows. The reason is that the std::cerr is not being redirected to a pipe in Windows to be then checked against the expected output.
602630
if(NOT MSVC)

‎test/loader_api.cpp‎

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
#include "loader/ze_loader.h"
1212
#include "ze_api.h"
1313
#include "zes_api.h"
14+
#include "zer_api.h"
1415

1516
#include <fstream>
1617

@@ -2287,4 +2288,123 @@ TEST_F(DriverOrderingTest,
22872288
}
22882289
}
22892290

2291+
TEST(
2292+
RuntimeApiLoaderDriverInteraction,
2293+
GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
2294+
{
2295+
uint32_t pInitDriversCount = 0;
2296+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
2297+
desc.flags = UINT32_MAX;
2298+
desc.pNext = nullptr;
2299+
putenv_safe(const_cast<char *>("ZE_ENABLE_LOADER_INTERCEPT=1"));
2300+
putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT=0"));
2301+
std::vector<ze_driver_handle_t> drivers;
2302+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
2303+
drivers.resize(pInitDriversCount);
2304+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, drivers.data(), &desc));
2305+
EXPECT_GT(pInitDriversCount, 0);
2306+
2307+
const char *errorString = nullptr;
2308+
uint32_t deviceId = 0;
2309+
2310+
ze_result_t result = zerGetLastErrorDescription(&errorString);
2311+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2312+
EXPECT_TRUE(compare_env("zerGetLastErrorDescription", "1"));
2313+
2314+
deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
2315+
EXPECT_TRUE(compare_env("zerTranslateDeviceHandleToIdentifier", "1"));
2316+
2317+
ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
2318+
EXPECT_TRUE(compare_env("zerTranslateIdentifierToDeviceHandle", "1"));
2319+
(void)translatedDevice;
2320+
2321+
ze_context_handle_t defaultContext = zerGetDefaultContext();
2322+
EXPECT_TRUE(compare_env("zerGetDefaultContext", "1"));
2323+
(void)defaultContext;
2324+
}
2325+
2326+
TEST(
2327+
RuntimeApiLoaderDriverInteraction,
2328+
GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtNotSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
2329+
{
2330+
uint32_t pInitDriversCount = 0;
2331+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
2332+
desc.flags = UINT32_MAX;
2333+
desc.pNext = nullptr;
2334+
putenv_safe(const_cast<char *>("ZE_ENABLE_LOADER_INTERCEPT=1"));
2335+
putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT=1"));
2336+
std::vector<ze_driver_handle_t> drivers;
2337+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
2338+
drivers.resize(pInitDriversCount);
2339+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, drivers.data(), &desc));
2340+
EXPECT_GT(pInitDriversCount, 0);
2341+
2342+
const char *errorString = nullptr;
2343+
uint32_t deviceId = 0;
2344+
2345+
ze_result_t result = zerGetLastErrorDescription(&errorString);
2346+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2347+
EXPECT_TRUE(compare_env("zerGetLastErrorDescription", "1"));
2348+
2349+
deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
2350+
EXPECT_TRUE(compare_env("zerTranslateDeviceHandleToIdentifier", "1"));
2351+
2352+
ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
2353+
EXPECT_TRUE(compare_env("zerTranslateIdentifierToDeviceHandle", "1"));
2354+
(void)translatedDevice;
2355+
2356+
ze_context_handle_t defaultContext = zerGetDefaultContext();
2357+
EXPECT_TRUE(compare_env("zerGetDefaultContext", "1"));
2358+
(void)defaultContext;
2359+
}
2360+
2361+
2362+
TEST(
2363+
RuntimeApiLoaderDriverInteraction,
2364+
GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
2365+
{
2366+
uint32_t pInitDriversCount = 0;
2367+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
2368+
desc.flags = UINT32_MAX;
2369+
desc.pNext = nullptr;
2370+
putenv_safe(const_cast<char *>("ZE_ENABLE_LOADER_INTERCEPT=1"));
2371+
putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT=0"));
2372+
putenv_safe(const_cast<char *>("ZEL_TEST_DDI_HANDLES_EXT_VERSION=1_0"));
2373+
std::vector<ze_driver_handle_t> drivers;
2374+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
2375+
drivers.resize(pInitDriversCount);
2376+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, drivers.data(), &desc));
2377+
EXPECT_GT(pInitDriversCount, 0);
2378+
2379+
uint32_t deviceId = 0;
2380+
2381+
const char *errorDesc = nullptr;
2382+
ze_result_t errorDescResult{};
2383+
2384+
deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
2385+
EXPECT_EQ(UINT32_MAX, deviceId);
2386+
2387+
errorDescResult = zerGetLastErrorDescription(&errorDesc);
2388+
EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
2389+
EXPECT_NE(errorDesc, nullptr);
2390+
EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
2391+
2392+
ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
2393+
EXPECT_EQ(nullptr, translatedDevice);
2394+
2395+
errorDescResult = zerGetLastErrorDescription(&errorDesc);
2396+
EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
2397+
EXPECT_NE(errorDesc, nullptr);
2398+
EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
2399+
2400+
ze_context_handle_t defaultContext = zerGetDefaultContext();
2401+
EXPECT_EQ(nullptr, defaultContext);
2402+
2403+
errorDescResult = zerGetLastErrorDescription(&errorDesc);
2404+
EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
2405+
EXPECT_NE(errorDesc, nullptr);
2406+
EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
2407+
}
2408+
2409+
22902410
} // namespace

0 commit comments

Comments
 (0)