From 84cd8226e3756cf91c30d1d6edd669a7c29ea712 Mon Sep 17 00:00:00 2001 From: "Neil R. Spruit" Date: Mon, 4 Nov 2024 18:49:10 +0000 Subject: [PATCH] feature: Support for zeInitDrivers - Enabled support for zeInitDrivers which combines init and driver get support. - Moved driverHandleGet to be part of Driver class to allow for unit testing of the functionality. - Updated GTPIN init conditions such that init only occurs when pCount > 0 and the driver handle pointer is not null. This ensures that the gtPin init does not trigger during the loader init calling zeInitDrivers and only is called before the first handle is retrieved. - Removed ze_init_flags_t flag from all driverInit functions since this flag is unused in all functions. Related-To: NEO-12905 Signed-off-by: Neil R. Spruit --- level_zero/api/core/ze_core_loader.cpp | 1 + .../api/core/ze_driver_api_entrypoints.h | 15 +- level_zero/core/source/driver/driver.cpp | 63 +++--- level_zero/core/source/driver/driver.h | 6 +- level_zero/core/source/driver/driver_imp.h | 3 +- .../core/test/unit_tests/mocks/mock_driver.h | 21 +- .../unit_tests/sources/driver/test_driver.cpp | 182 ++++++++++++++++++ .../sysman/source/driver/sysman_driver.cpp | 6 +- .../sysman/source/driver/sysman_driver.h | 4 +- .../sysman/source/driver/sysman_driver_imp.h | 4 +- .../sources/linux/mock_sysman_driver.h | 23 ++- .../sources/linux/test_sysman_driver.cpp | 13 +- .../sources/windows/mock_sysman_driver.h | 23 ++- .../sources/windows/test_sysman_driver.cpp | 11 ++ 14 files changed, 333 insertions(+), 42 deletions(-) diff --git a/level_zero/api/core/ze_core_loader.cpp b/level_zero/api/core/ze_core_loader.cpp index 0f18bd2482..f5a63e4b29 100644 --- a/level_zero/api/core/ze_core_loader.cpp +++ b/level_zero/api/core/ze_core_loader.cpp @@ -206,6 +206,7 @@ zeGetGlobalProcAddrTable( if (driverDdiTable.enableTracing) { fillDdiEntry(pDdiTable->pfnInit, zeInitTracing, version, ZE_API_VERSION_1_0); } + fillDdiEntry(pDdiTable->pfnInitDrivers, L0::zeInitDrivers, version, ZE_API_VERSION_1_10); return result; } diff --git a/level_zero/api/core/ze_driver_api_entrypoints.h b/level_zero/api/core/ze_driver_api_entrypoints.h index 59a6eb4aaa..e3dcefa75f 100644 --- a/level_zero/api/core/ze_driver_api_entrypoints.h +++ b/level_zero/api/core/ze_driver_api_entrypoints.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -17,10 +17,15 @@ ze_result_t zeInit( return L0::init(flags); } +ze_result_t zeInitDrivers( + uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init_driver_type_desc_t *desc) { + return L0::initDrivers(pCount, phDrivers, desc); +} + ze_result_t zeDriverGet( uint32_t *pCount, ze_driver_handle_t *phDrivers) { - return L0::driverHandleGet(pCount, phDrivers); + return L0::Driver::get()->driverHandleGet(pCount, phDrivers); } ze_result_t zeDriverGetProperties( @@ -70,6 +75,12 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zeInit( flags); } +ZE_APIEXPORT ze_result_t ZE_APICALL zeInitDrivers( + uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init_driver_type_desc_t *desc) { + return L0::initDrivers( + pCount, phDrivers, desc); +} + ZE_APIEXPORT ze_result_t ZE_APICALL zeDriverGet( uint32_t *pCount, ze_driver_handle_t *phDrivers) { diff --git a/level_zero/core/source/driver/driver.cpp b/level_zero/core/source/driver/driver.cpp index 36f0814c36..41d99c7838 100644 --- a/level_zero/core/source/driver/driver.cpp +++ b/level_zero/core/source/driver/driver.cpp @@ -100,7 +100,7 @@ void DriverImp::initialize(ze_result_t *result) { ze_result_t DriverImp::initStatus(ZE_RESULT_ERROR_UNINITIALIZED); -ze_result_t DriverImp::driverInit(ze_init_flags_t flags) { +ze_result_t DriverImp::driverInit() { std::call_once(initDriverOnce, [this]() { ze_result_t result; this->initialize(&result); @@ -109,8 +109,11 @@ ze_result_t DriverImp::driverInit(ze_init_flags_t flags) { return initStatus; } -ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) { - Driver::get()->tryInitGtpin(); +ze_result_t DriverImp::driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) { + // Only attempt to Init GtPin when driverHandleGet is called requesting handles. + if (phDriverHandles != nullptr && *pCount > 0) { + Driver::get()->tryInitGtpin(); + } if (*pCount == 0) { *pCount = driverCount; return ZE_RESULT_SUCCESS; @@ -147,30 +150,46 @@ static DriverImp driverImp; Driver *Driver::driver = &driverImp; std::mutex driverInitMutex; +ze_result_t initDriver() { + auto pid = NEO::SysCalls::getCurrentProcessId(); + + ze_result_t result = Driver::get()->driverInit(); + + if (Driver::get()->getPid() != pid) { + std::lock_guard lock(driverInitMutex); + + if (Driver::get()->getPid() != pid) { + ze_result_t result; + Driver::get()->initialize(&result); + } + } + + if (result == ZE_RESULT_SUCCESS) { + L0::levelZeroDriverInitialized = true; + } else { + L0::levelZeroDriverInitialized = false; + } + return result; +} + ze_result_t init(ze_init_flags_t flags) { if (flags && !(flags & ZE_INIT_FLAG_GPU_ONLY)) { L0::levelZeroDriverInitialized = false; return ZE_RESULT_ERROR_UNINITIALIZED; } else { - auto pid = NEO::SysCalls::getCurrentProcessId(); - - ze_result_t result = Driver::get()->driverInit(flags); - - if (Driver::get()->getPid() != pid) { - std::lock_guard lock(driverInitMutex); - - if (Driver::get()->getPid() != pid) { - ze_result_t result; - Driver::get()->initialize(&result); - } - } - - if (result == ZE_RESULT_SUCCESS) { - L0::levelZeroDriverInitialized = true; - } else { - L0::levelZeroDriverInitialized = false; - } - return result; + return initDriver(); } } + +ze_result_t initDrivers(uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init_driver_type_desc_t *desc) { + ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED; + if (desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_GPU) { + result = initDriver(); + if (result == ZE_RESULT_SUCCESS) { + result = Driver::get()->driverHandleGet(pCount, phDrivers); + } + } + return result; +} + } // namespace L0 diff --git a/level_zero/core/source/driver/driver.h b/level_zero/core/source/driver/driver.h index e8327dabc4..8088497a8e 100644 --- a/level_zero/core/source/driver/driver.h +++ b/level_zero/core/source/driver/driver.h @@ -11,12 +11,12 @@ namespace L0 { struct Driver { - virtual ze_result_t driverInit(ze_init_flags_t flags) = 0; + virtual ze_result_t driverInit() = 0; virtual void initialize(ze_result_t *result) = 0; static Driver *get() { return driver; } virtual ~Driver() = default; virtual void tryInitGtpin() = 0; - + virtual ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDrivers) = 0; virtual unsigned int getPid() const = 0; protected: @@ -24,7 +24,7 @@ struct Driver { }; ze_result_t init(ze_init_flags_t); -ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDrivers); +ze_result_t initDrivers(uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init_driver_type_desc_t *desc); extern bool sysmanInitFromCore; extern uint32_t driverCount; diff --git a/level_zero/core/source/driver/driver_imp.h b/level_zero/core/source/driver/driver_imp.h index 68b8eb87d0..3f97abc563 100644 --- a/level_zero/core/source/driver/driver_imp.h +++ b/level_zero/core/source/driver/driver_imp.h @@ -17,13 +17,14 @@ namespace L0 { class DriverImp : public Driver { public: - ze_result_t driverInit(ze_init_flags_t flags) override; + ze_result_t driverInit() override; void initialize(ze_result_t *result) override; unsigned int getPid() const override { return pid; } void tryInitGtpin() override; + ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDrivers) override; protected: uint32_t pid = 0; diff --git a/level_zero/core/test/unit_tests/mocks/mock_driver.h b/level_zero/core/test/unit_tests/mocks/mock_driver.h index 181daeb14d..878827e728 100644 --- a/level_zero/core/test/unit_tests/mocks/mock_driver.h +++ b/level_zero/core/test/unit_tests/mocks/mock_driver.h @@ -30,13 +30,13 @@ struct Mock : public Driver { Mock(); ~Mock() override; - ze_result_t driverInit(ze_init_flags_t flag) override { + ze_result_t driverInit() override { initCalledCount++; if (initCalledCount == 1) { pid = NEO::SysCalls::getCurrentProcessId(); } if (driverInitCallBase) { - return DriverImp::driverInit(flag); + return DriverImp::driverInit(); } if (failInitDriver) { return ZE_RESULT_ERROR_UNINITIALIZED; @@ -44,6 +44,21 @@ struct Mock : public Driver { return ZE_RESULT_SUCCESS; } + ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) override { + if (driverGetCallBase) { + return DriverImp::driverHandleGet(pCount, phDriverHandles); + } + if (*pCount == 0) { + *pCount = 1; + return ZE_RESULT_SUCCESS; + } + if (phDriverHandles == nullptr) { + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + } + *phDriverHandles = reinterpret_cast(&mockDriverhandle); + return ZE_RESULT_SUCCESS; + } + void initialize(ze_result_t *result) override { initializeCalledCount++; if (initializeCallBase) { @@ -63,7 +78,9 @@ struct Mock : public Driver { uint32_t initializeCalledCount = 0; bool failInitDriver = false; bool driverInitCallBase = false; + bool driverGetCallBase = true; bool initializeCallBase = false; + uint64_t mockDriverhandle = 0xffff; }; } // namespace ult diff --git a/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp b/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp index 19afba2ec6..52a46ef5d0 100644 --- a/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp +++ b/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp @@ -1504,5 +1504,187 @@ TEST_F(GtPinInitTest, givenFailureWhenInitializingGtpinThenTheErrorIsNotExposedI EXPECT_EQ(globalDriverHandle, driverHandle); } +TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitDriversWithoutDriverHandlesRequestedMultipleTimesThenGtPinIsNotInitialized) { + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + EXPECT_FALSE(driver.gtPinInitializationNeeded.load()); + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(0u, gtpinInitTimesCalled); + EXPECT_TRUE(driver.gtPinInitializationNeeded.load()); + driver.gtPinInitializationNeeded = false; + driverCount = 0; + result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(2u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(0u, gtpinInitTimesCalled); + EXPECT_FALSE(driver.gtPinInitializationNeeded.load()); +} + +TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitDriversWithoutDriverHandlesRequestedAndCountZeroMultipleTimesThenGtPinIsNotInitialized) { + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + EXPECT_FALSE(driver.gtPinInitializationNeeded.load()); + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(0u, gtpinInitTimesCalled); + EXPECT_TRUE(driver.gtPinInitializationNeeded.load()); + driver.gtPinInitializationNeeded = false; + driverCount = 0; + ze_driver_handle_t driverHandle{}; + result = zeInitDrivers(&driverCount, &driverHandle, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(2u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(0u, gtpinInitTimesCalled); + EXPECT_FALSE(driver.gtPinInitializationNeeded.load()); +} + +TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitDriversMultipleTimesThenGtPinIsInitializedOnlyOnce) { + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + ze_driver_handle_t driverHandle{}; + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(0u, gtpinInitTimesCalled); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + ASSERT_EQ(1u, driverCount); + result = zeInitDrivers(&driverCount, &driverHandle, &desc); + ASSERT_EQ(ZE_RESULT_SUCCESS, result); + ASSERT_EQ(1u, driverCount); + EXPECT_EQ(globalDriverHandle, driverHandle); + + EXPECT_EQ(2u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + EXPECT_EQ(1u, gtpinInitTimesCalled); +} + +TEST_F(GtPinInitTest, givenFailureWhenInitializingGtpinThenTheErrorIsNotExposedInZeInitDriversFunction) { + + uint32_t (*gtPinInit)(void *) = [](void *arg) -> uint32_t { + return 1; // failure + }; + + auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); + osLibrary->procMap["OpenGTPin"] = reinterpret_cast(gtPinInit); + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + ze_driver_handle_t driverHandle{}; + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, driver.initCalledCount); + EXPECT_EQ(1u, driver.initializeCalledCount); + ASSERT_EQ(1u, driverCount); + result = zeInitDrivers(&driverCount, &driverHandle, &desc); + ASSERT_EQ(ZE_RESULT_SUCCESS, result); + ASSERT_EQ(1u, driverCount); + EXPECT_EQ(globalDriverHandle, driverHandle); +} + +TEST(InitDriversTest, givenZeInitDriversCalledWhenCallingZeInitDriversInForkedProcessThenNewDriverIsInitialized) { + Mock driver; + uint32_t driverCount = 0; + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + driver.pid = NEO::SysCalls::getCurrentProcessId(); + + ze_result_t result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + // change pid in driver + driver.pid = NEO::SysCalls::getCurrentProcessId() - 1; + + result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + EXPECT_TRUE(levelZeroDriverInitialized); + EXPECT_EQ(2u, driver.initCalledCount); + + // pid updated to current pid + auto expectedPid = NEO::SysCalls::getCurrentProcessId(); + EXPECT_EQ(expectedPid, driver.pid); +} + +TEST(InitDriversTest, givenNullDriverHandlePointerWhenInitDriversIsCalledWithACountThenErrorInvalidNullPointerIsReturned) { + Mock driver; + driver.driverGetCallBase = false; + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, driver.initCalledCount); + ASSERT_EQ(1u, driverCount); + result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER, result); +} + +TEST(InitDriversTest, givennInitDriversIsCalledWhenDriverinitFailsThenUninitializedDriverIsReturned) { + Mock driver; + driver.failInitDriver = true; + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; + desc.pNext = nullptr; + uint32_t driverCount = 0; + auto result = zeInitDrivers(&driverCount, nullptr, &desc); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); +} + +TEST(InitDriversTest, givenAllPossibleFlagCombinationsWhenInitDriversIsCalledThenCorrectResultsAreReturned) { + struct TestCase { + uint32_t flags; + ze_result_t expectedResult; + bool expectDriverHandle; + }; + + std::vector testCases = { + {0, ZE_RESULT_ERROR_UNINITIALIZED, false}, + {ZE_INIT_DRIVER_TYPE_FLAG_GPU, ZE_RESULT_SUCCESS, true}, + {ZE_INIT_DRIVER_TYPE_FLAG_GPU | ZE_INIT_DRIVER_TYPE_FLAG_NPU, ZE_RESULT_SUCCESS, true}, + {UINT32_MAX, ZE_RESULT_SUCCESS, true}, + {ZE_INIT_DRIVER_TYPE_FLAG_NPU, ZE_RESULT_ERROR_UNINITIALIZED, false}, + {UINT32_MAX & !ZE_INIT_DRIVER_TYPE_FLAG_GPU, ZE_RESULT_ERROR_UNINITIALIZED, false}}; + + for (const auto &testCase : testCases) { + Mock driver; + driver.driverGetCallBase = false; + uint32_t count = 0; + ze_driver_handle_t driverHandle = nullptr; + ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; + desc.flags = testCase.flags; + desc.pNext = nullptr; + + ze_result_t result = zeInitDrivers(&count, nullptr, &desc); + EXPECT_EQ(testCase.expectedResult, result); + if (testCase.expectDriverHandle) { + EXPECT_GT(count, 0u); + result = zeInitDrivers(&count, &driverHandle, &desc); + EXPECT_EQ(testCase.expectedResult, result); + EXPECT_NE(nullptr, driverHandle); + EXPECT_TRUE(levelZeroDriverInitialized); + } else { + EXPECT_EQ(0U, count); + EXPECT_EQ(nullptr, driverHandle); + } + } +} + } // namespace ult } // namespace L0 diff --git a/level_zero/sysman/source/driver/sysman_driver.cpp b/level_zero/sysman/source/driver/sysman_driver.cpp index 48766c033d..eb69490127 100644 --- a/level_zero/sysman/source/driver/sysman_driver.cpp +++ b/level_zero/sysman/source/driver/sysman_driver.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -72,7 +72,7 @@ void SysmanDriverImp::initialize(ze_result_t *result) { ze_result_t SysmanDriverImp::initStatus(ZE_RESULT_ERROR_UNINITIALIZED); -ze_result_t SysmanDriverImp::driverInit(zes_init_flags_t flags) { +ze_result_t SysmanDriverImp::driverInit() { std::call_once(initDriverOnce, [this]() { ze_result_t result; this->initialize(&result); @@ -116,7 +116,7 @@ ze_result_t init(zes_init_flags_t flags) { if (flags && !(flags & ZE_INIT_FLAG_GPU_ONLY)) { return ZE_RESULT_ERROR_UNINITIALIZED; } else { - return SysmanDriver::get()->driverInit(flags); + return SysmanDriver::get()->driverInit(); } } diff --git a/level_zero/sysman/source/driver/sysman_driver.h b/level_zero/sysman/source/driver/sysman_driver.h index df155eb81f..d9b47cdaa3 100644 --- a/level_zero/sysman/source/driver/sysman_driver.h +++ b/level_zero/sysman/source/driver/sysman_driver.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -13,7 +13,7 @@ namespace L0 { namespace Sysman { struct SysmanDriver { - virtual ze_result_t driverInit(zes_init_flags_t flags) = 0; + virtual ze_result_t driverInit() = 0; virtual void initialize(ze_result_t *result) = 0; static SysmanDriver *get() { return driver; } virtual ~SysmanDriver() = default; diff --git a/level_zero/sysman/source/driver/sysman_driver_imp.h b/level_zero/sysman/source/driver/sysman_driver_imp.h index 969c85356b..71f001832b 100644 --- a/level_zero/sysman/source/driver/sysman_driver_imp.h +++ b/level_zero/sysman/source/driver/sysman_driver_imp.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -15,7 +15,7 @@ namespace Sysman { class SysmanDriverImp : public SysmanDriver { public: - ze_result_t driverInit(zes_init_flags_t flags) override; + ze_result_t driverInit() override; void initialize(ze_result_t *result) override; diff --git a/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h b/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h index 0f64f0b032..358d9b4385 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h +++ b/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -22,13 +22,32 @@ struct MockSysmanDriver : public ::L0::Sysman::SysmanDriverImp { driver = previousDriver; } - ze_result_t driverInit(ze_init_flags_t flag) override { + ze_result_t driverInit() override { initCalledCount++; + if (useBaseDriverInit) { + return SysmanDriverImp::driverInit(); + } return ZE_RESULT_SUCCESS; } + void initialize(ze_result_t *result) override { + if (useBaseInit) { + SysmanDriverImp::initialize(result); + return; + } + if (sysmanInitFail) { + *result = ZE_RESULT_ERROR_UNINITIALIZED; + return; + } + *result = ZE_RESULT_SUCCESS; + return; + } + ::L0::Sysman::SysmanDriver *previousDriver = nullptr; uint32_t initCalledCount = 0; + bool useBaseDriverInit = false; + bool sysmanInitFail = false; + bool useBaseInit = true; }; } // namespace ult diff --git a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp index b81f37d727..e648f036ab 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp +++ b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp @@ -52,6 +52,17 @@ TEST(zesInit, whenCallingZesInitWithoutGpuOnlyFlagThenInitializeOnDriverIsNotCal EXPECT_EQ(0u, driver.initCalledCount); } +TEST(zesInit, whenCallingZesInitWhenDriverInitFailsThenUninitializedIsReturned) { + MockSysmanDriver driver; + driver.useBaseInit = false; + driver.useBaseDriverInit = true; + driver.sysmanInitFail = true; + + auto result = zesInit(0); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); + EXPECT_EQ(1u, driver.initCalledCount); +} + TEST(zesInit, whenCallingZesDriverGetWithoutZesInitThenZesDriverGetCallNotSucceed) { uint32_t count = 0; EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zesDriverGet(&count, nullptr)); @@ -335,7 +346,7 @@ TEST_F(SysmanDriverHandleTest, TEST(SysmanDriverInit, GivenValidSysmanImpObjectWhenCallingInitWithSysmanInitFromCoreSetAsTrueThenSysmanInitFails) { L0::sysmanInitFromCore = true; std::unique_ptr pSysmanDriverImp = std::make_unique(); - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pSysmanDriverImp->driverInit(0)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, pSysmanDriverImp->driverInit()); EXPECT_FALSE(L0::Sysman::sysmanOnlyInit); L0::sysmanInitFromCore = false; } diff --git a/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h b/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h index 1e3702d13c..0ca11d9fb2 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h +++ b/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -29,13 +29,32 @@ struct MockSysmanDriver : public ::L0::Sysman::SysmanDriverImp { driver = previousDriver; } - ze_result_t driverInit(ze_init_flags_t flag) override { + ze_result_t driverInit() override { initCalledCount++; + if (useBaseDriverInit) { + return SysmanDriverImp::driverInit(); + } return ZE_RESULT_SUCCESS; } + void initialize(ze_result_t *result) override { + if (useBaseInit) { + SysmanDriverImp::initialize(result); + return; + } + if (sysmanInitFail) { + *result = ZE_RESULT_ERROR_UNINITIALIZED; + return; + } + *result = ZE_RESULT_SUCCESS; + return; + } + ::L0::Sysman::SysmanDriver *previousDriver = nullptr; uint32_t initCalledCount = 0; + bool useBaseDriverInit = false; + bool sysmanInitFail = false; + bool useBaseInit = true; }; class SysmanDriverHandleTest : public ::testing::Test { diff --git a/level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp b/level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp index 444f91c24c..14000bcf8a 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp +++ b/level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp @@ -40,6 +40,17 @@ TEST(zesInit, whenCallingZesInitWithoutGpuOnlyFlagThenInitializeOnDriverIsNotCal EXPECT_EQ(0u, driver.initCalledCount); } +TEST(zesInit, whenCallingZesInitWhenDriverInitFailsThenUninitializedIsReturned) { + MockSysmanDriver driver; + driver.useBaseInit = false; + driver.useBaseDriverInit = true; + driver.sysmanInitFail = true; + + auto result = zesInit(0); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); + EXPECT_EQ(1u, driver.initCalledCount); +} + TEST_F(SysmanDriverHandleTest, givenInitializedDriverWhenZesDriverGetPropertiesIsCalledThenUnsupportedIsReturned) { uint32_t pCount = 0;