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;