intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 14:02:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: don't return gtpin init error from L0 API call

Browse Source 
gtpin should be transparent for application

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-08-29 09:20:20 +00:00
committed by Compute-Runtime-Automation
parent e6c920cc62
commit c0cec096a5
5 changed files with 28 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -91,8 +91,8 @@ void DriverImp::initialize(ze_result_t *result) {
globalDriver = nullptr;
driverCount = 0;
} else if (envVariables.pin) {
std::unique_lock<std::recursive_mutex> mtx{this->gtpinInitMtx};
this->gtPinInitializationStatus = GtPinInitializationStatus::pending;
std::unique_lock<std::mutex> mtx{this->gtpinInitMtx};
this->gtPinInitializationNeeded = true;
}
}
}
@@ -110,10 +110,7 @@ ze_result_t DriverImp::driverInit(ze_init_flags_t flags) {
}
ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) {
auto retVal = Driver::get()->initGtpin();
if (retVal != ZE_RESULT_SUCCESS) {
return retVal;
}
Driver::get()->tryInitGtpin();
if (*pCount == 0) {
*pCount = driverCount;
return ZE_RESULT_SUCCESS;
@@ -134,26 +131,16 @@ ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandle
return ZE_RESULT_SUCCESS;
}
ze_result_t DriverImp::initGtpin() {
auto retVal = ZE_RESULT_SUCCESS;
if (this->gtPinInitializationStatus == GtPinInitializationStatus::notNeeded) {
return retVal;
void DriverImp::tryInitGtpin() {
if (!this->gtPinInitializationNeeded) {
return;
}
std::unique_lock<std::recursive_mutex> mtx{this->gtpinInitMtx};
if (this->gtPinInitializationStatus == GtPinInitializationStatus::inProgress) {
return retVal;
}
if (this->gtPinInitializationStatus == GtPinInitializationStatus::pending) {
this->gtPinInitializationStatus = GtPinInitializationStatus::inProgress;
std::unique_lock<std::mutex> mtx{this->gtpinInitMtx};
if (this->gtPinInitializationNeeded) {
this->gtPinInitializationNeeded = false;
std::string gtpinFuncName{"OpenGTPin"};
if (false == NEO::PinContext::init(gtpinFuncName)) {
this->gtPinInitializationStatus = GtPinInitializationStatus::error;
}
NEO::PinContext::init(gtpinFuncName);
}
if (this->gtPinInitializationStatus == GtPinInitializationStatus::error) {
retVal = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
return retVal;
}
static DriverImp driverImp;

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

@@ -15,7 +15,7 @@ struct Driver {
virtual void initialize(ze_result_t *result) = 0;
static Driver *get() { return driver; }
virtual ~Driver() = default;
virtual ze_result_t initGtpin() = 0;
virtual void tryInitGtpin() = 0;
virtual unsigned int getPid() const = 0;

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

@@ -23,21 +23,14 @@ class DriverImp : public Driver {
unsigned int getPid() const override {
return pid;
}
ze_result_t initGtpin() override;
enum class GtPinInitializationStatus {
notNeeded,
pending,
inProgress,
error
};
void tryInitGtpin() override;
protected:
uint32_t pid = 0;
std::once_flag initDriverOnce;
static ze_result_t initStatus;
std::atomic<GtPinInitializationStatus> gtPinInitializationStatus{GtPinInitializationStatus::notNeeded};
std::recursive_mutex gtpinInitMtx;
std::atomic<bool> gtPinInitializationNeeded{false};
std::mutex gtpinInitMtx;
};
struct L0EnvVariables {

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

@@ -19,7 +19,7 @@ namespace ult {
template <>
struct WhiteBox<::L0::DriverImp> : public ::L0::DriverImp {
using ::L0::DriverImp::gtPinInitializationStatus;
using ::L0::DriverImp::gtPinInitializationNeeded;
using ::L0::DriverImp::pid;
};

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

@@ -1445,20 +1445,20 @@ struct GtPinInitTest : public ::testing::Test {
uint32_t GtPinInitTest::gtpinInitTimesCalled = 0u;
TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitMultipleTimesThenGtPinIsNotInitialized) {
EXPECT_EQ(Mock<Driver>::GtPinInitializationStatus::notNeeded, driver.gtPinInitializationStatus.load());
EXPECT_FALSE(driver.gtPinInitializationNeeded.load());
auto result = zeInit(ZE_INIT_FLAG_GPU_ONLY);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1u, driver.initCalledCount);
EXPECT_EQ(1u, driver.initializeCalledCount);
EXPECT_EQ(0u, gtpinInitTimesCalled);
EXPECT_EQ(Mock<Driver>::GtPinInitializationStatus::pending, driver.gtPinInitializationStatus.load());
driver.gtPinInitializationStatus = Mock<Driver>::GtPinInitializationStatus::notNeeded;
EXPECT_TRUE(driver.gtPinInitializationNeeded.load());
driver.gtPinInitializationNeeded = false;
result = zeInit(ZE_INIT_FLAG_GPU_ONLY);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(2u, driver.initCalledCount);
EXPECT_EQ(1u, driver.initializeCalledCount);
EXPECT_EQ(0u, gtpinInitTimesCalled);
EXPECT_EQ(Mock<Driver>::GtPinInitializationStatus::notNeeded, driver.gtPinInitializationStatus.load());
EXPECT_FALSE(driver.gtPinInitializationNeeded.load());
}
TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeDriverGetMultipleTimesThenGtPinIsInitializedOnlyOnce) {
@@ -1482,10 +1482,10 @@ TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeDriverGetMultipleTime
EXPECT_EQ(1u, gtpinInitTimesCalled);
}
TEST_F(GtPinInitTest, givenGtPinInitializationFailureWhenCallingZeDriverGetThenDependencyErrorIsReturnedEveryTime) {
TEST_F(GtPinInitTest, givenFailureWhenInitializingGtpinThenTheErrorIsNotExposedInZeDriverGetFunction) {
uint32_t (*gtPinInit)(void *) = [](void *arg) -> uint32_t {
return 1;
return 1; // failure
};
auto osLibrary = static_cast<MockOsLibraryCustom *>(MockOsLibrary::loadLibraryNewObject);
@@ -1494,13 +1494,15 @@ TEST_F(GtPinInitTest, givenGtPinInitializationFailureWhenCallingZeDriverGetThenD
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1u, driver.initCalledCount);
EXPECT_EQ(1u, driver.initializeCalledCount);
EXPECT_EQ(0u, gtpinInitTimesCalled);
uint32_t driverCount = 0;
ze_driver_handle_t driverHandle{};
result = zeDriverGet(&driverCount, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, result);
result = zeDriverGet(&driverCount, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, result);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
result = zeDriverGet(&driverCount, &driverHandle);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
EXPECT_EQ(globalDriverHandle, driverHandle);
}
} // namespace ult