Have Process Address Tables in the driver fail on mismatched versions

Signed-off-by: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
2021-02-11 01:21:12 -08:00 · 2021-02-11 01:21:12 -08:00 · 62c61c67b4
parent 2a44fa1121
commit 62c61c67b4
3 changed files with 420 additions and 35 deletions
--- a/level_zero/api/core/ze_core_loader.cpp
+++ b/level_zero/api/core/ze_core_loader.cpp
@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 Intel Corporation
+ * Copyright (C) 2019-2021 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@ -22,8 +22,9 @@ zeGetDriverProcAddrTable(
    ze_driver_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
    ze_result_t result = ZE_RESULT_SUCCESS;
    pDdiTable->pfnGet = zeDriverGet;
@ -48,8 +49,9 @@ zeGetMemProcAddrTable(
    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 (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -83,8 +85,9 @@ zeGetContextProcAddrTable(
    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 (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;

    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

@ -118,8 +121,9 @@ zeGetPhysicalMemProcAddrTable(
    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 (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;

    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

@ -141,8 +145,9 @@ zeGetVirtualMemProcAddrTable(
    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 (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -173,8 +178,9 @@ zeGetGlobalProcAddrTable(
    ze_global_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -192,8 +198,9 @@ zeGetDeviceProcAddrTable(
    ze_device_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -237,8 +244,9 @@ zeGetCommandQueueProcAddrTable(
    ze_command_queue_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -262,8 +270,9 @@ zeGetCommandListProcAddrTable(
    ze_command_list_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -331,8 +340,9 @@ zeGetFenceProcAddrTable(
    ze_fence_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -358,8 +368,9 @@ zeGetEventPoolProcAddrTable(
    ze_event_pool_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -385,8 +396,9 @@ zeGetEventProcAddrTable(
    ze_event_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -416,8 +428,9 @@ zeGetImageProcAddrTable(
    ze_image_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -439,8 +452,9 @@ zeGetModuleProcAddrTable(
    ze_module_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -472,8 +486,9 @@ zeGetModuleBuildLogProcAddrTable(
    ze_module_build_log_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -493,8 +508,9 @@ zeGetKernelProcAddrTable(
    ze_kernel_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
@ -534,8 +550,9 @@ zeGetSamplerProcAddrTable(
    ze_sampler_dditable_t *pDdiTable) {
    if (nullptr == pDdiTable)
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
    driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");

    ze_result_t result = ZE_RESULT_SUCCESS;
--- a/level_zero/core/test/unit_tests/sources/loader/CMakeLists.txt
+++ b/level_zero/core/test/unit_tests/sources/loader/CMakeLists.txt
@ -0,0 +1,10 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_loader.cpp
+)
--- a/level_zero/core/test/unit_tests/sources/loader/test_loader.cpp
+++ b/level_zero/core/test/unit_tests/sources/loader/test_loader.cpp
@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+#include <level_zero/ze_api.h>
+
+#include "ze_ddi_tables.h"
+
+namespace L0 {
+namespace ult {
+
+TEST(zeGetDriverProcAddrTableTest,
+     whenCallingZeGetDriverProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_driver_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDriverProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetMemProcAddrTableTest,
+     whenCallingZeGetMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetContextProcAddrTableTest,
+     whenCallingZeGetContextProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_context_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetContextProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetPhysicalMemProcAddrTableTest,
+     whenCallingZeGetPhysicalMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_physical_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetPhysicalMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetVirtualMemProcAddrTableTest,
+     whenCallingZeGetVirtualMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_virtual_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetVirtualMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetGlobalProcAddrTableTest,
+     whenCallingZeGetGlobalProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_global_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetGlobalProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetDeviceProcAddrTableTest,
+     whenCallingZeGetDeviceProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_device_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDeviceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetCommandQueueProcAddrTableTest,
+     whenCallingZeGetCommandQueueProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_command_queue_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandQueueProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetCommandListProcAddrTableTest,
+     whenCallingZeGetCommandListProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_command_list_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandListProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetFenceProcAddrTableTest,
+     whenCallingZeGetFenceProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_fence_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetFenceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetEventPoolProcAddrTableTest,
+     whenCallingZeGetEventPoolProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_event_pool_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventPoolProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetEventProcAddrTableTest,
+     whenCallingZeGetEventProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_event_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetImageProcAddrTableTest,
+     whenCallingZeGetImageProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_image_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetImageProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetModuleProcAddrTableTest,
+     whenCallingZeGetModuleProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_module_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetModuleBuildLogProcAddrTableTest,
+     whenCallingZeGetModuleBuildLogProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_module_build_log_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleBuildLogProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetKernelProcAddrTableTest,
+     whenCallingZeGetKernelProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_kernel_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetKernelProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetSamplerProcAddrTableTest,
+     whenCallingZeGetSamplerProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_sampler_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetSamplerProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetDriverProcAddrTableTest,
+     whenCallingZeGetDriverProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_driver_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDriverProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetMemProcAddrTableTest,
+     whenCallingZeGetMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetContextProcAddrTableTest,
+     whenCallingZeGetContextProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_context_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetContextProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetPhysicalMemProcAddrTableTest,
+     whenCallingZeGetPhysicalMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_physical_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetPhysicalMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetVirtualMemProcAddrTableTest,
+     whenCallingZeGetVirtualMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_virtual_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetVirtualMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetGlobalProcAddrTableTest,
+     whenCallingZeGetGlobalProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_global_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetGlobalProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetDeviceProcAddrTableTest,
+     whenCallingZeGetDeviceProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_device_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDeviceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetCommandQueueProcAddrTableTest,
+     whenCallingZeGetCommandQueueProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_command_queue_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandQueueProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetCommandListProcAddrTableTest,
+     whenCallingZeGetCommandListProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_command_list_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandListProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetFenceProcAddrTableTest,
+     whenCallingZeGetFenceProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_fence_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetFenceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetEventPoolProcAddrTableTest,
+     whenCallingZeGetEventPoolProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_event_pool_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventPoolProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetEventProcAddrTableTest,
+     whenCallingZeGetEventProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_event_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetImageProcAddrTableTest,
+     whenCallingZeGetImageProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_image_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetImageProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetModuleProcAddrTableTest,
+     whenCallingZeGetModuleProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_module_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetModuleBuildLogProcAddrTableTest,
+     whenCallingZeGetModuleBuildLogProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_module_build_log_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleBuildLogProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetKernelProcAddrTableTest,
+     whenCallingZeGetKernelProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_kernel_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetKernelProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetSamplerProcAddrTableTest,
+     whenCallingZeGetSamplerProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_sampler_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetSamplerProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+} // namespace ult
+} // namespace L0