Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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 <neil.r.spruit@intel.com>
This commit is contained in:
Neil R. Spruit 2024-11-04 18:49:10 +00:00 committed by Compute-Runtime-Automation
parent 68a815c2b6
commit 84cd8226e3
14 changed files with 333 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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;
}

15
level_zero/api/core/ze_driver_api_entrypoints.h
View File

@ -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) {

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

@ -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<std::mutex> 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<std::mutex> 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

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

@ -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;

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

@ -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;

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

@ -30,13 +30,13 @@ struct Mock<Driver> : 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<Driver> : 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<ze_driver_handle_t>(&mockDriverhandle);
return ZE_RESULT_SUCCESS;
}
void initialize(ze_result_t *result) override {
initializeCalledCount++;
if (initializeCallBase) {
@ -63,7 +78,9 @@ struct Mock<Driver> : public Driver {
uint32_t initializeCalledCount = 0;
bool failInitDriver = false;
bool driverInitCallBase = false;
bool driverGetCallBase = true;
bool initializeCallBase = false;
uint64_t mockDriverhandle = 0xffff;
};
} // namespace ult

182
level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
View File

@ -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<MockOsLibraryCustom *>(MockOsLibrary::loadLibraryNewObject);
osLibrary->procMap["OpenGTPin"] = reinterpret_cast<void *>(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> 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;
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;
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<TestCase> 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;
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

6
level_zero/sysman/source/driver/sysman_driver.cpp
View File

@ -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();
}
}

4
level_zero/sysman/source/driver/sysman_driver.h
View File

@ -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;

4
level_zero/sysman/source/driver/sysman_driver_imp.h
View File

@ -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;

23
level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h
View File

@ -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

13
level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp
View File

@ -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<SysmanDriverImp> pSysmanDriverImp = std::make_unique<SysmanDriverImp>();
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;
}

23
level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h
View File

@ -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 {

11
level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp
View File

@ -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;