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

refactor: store global L0 driver handle in vector 

Related-To: NEO-14062
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2025-02-13 14:32:55 +00:00 committed by Compute-Runtime-Automation
parent 4ed25da5fa
commit 7c4708be08
15 changed files with 158 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,9 +29,8 @@
namespace L0 {
_ze_driver_handle_t *globalDriverHandle;
std::vector<_ze_driver_handle_t *> *globalDriverHandles;
bool levelZeroDriverInitialized = false;
uint32_t driverCount = 0;
void DriverImp::initialize(ze_result_t *result) {
*result = ZE_RESULT_ERROR_UNINITIALIZED;
@ -75,19 +74,22 @@ void DriverImp::initialize(ze_result_t *result) {
auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment);
executionEnvironment->decRefInternal();
if (!neoDevices.empty()) {
globalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
if (globalDriverHandle != nullptr) {
driverCount = 1;
auto driverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
if (driverHandle) {
globalDriverHandles->push_back(driverHandle);
}
if (globalDriverHandles->size() > 0) {
*result = ZE_RESULT_SUCCESS;
if (envVariables.metrics) {
*result = MetricDeviceContext::enableMetricApi();
}
if (*result != ZE_RESULT_SUCCESS) {
delete globalDriver;
globalDriverHandle = nullptr;
globalDriver = nullptr;
driverCount = 0;
for (auto &driverHandle : *globalDriverHandles) {
delete driverHandle;
}
globalDriverHandles->clear();
} else if (envVariables.pin) {
std::unique_lock<std::mutex> mtx{this->gtpinInitMtx};
this->gtPinInitializationNeeded = true;
@ -112,6 +114,7 @@ ze_result_t DriverImp::driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phD
if (phDriverHandles != nullptr && *pCount > 0) {
Driver::get()->tryInitGtpin();
}
auto driverCount = static_cast<uint32_t>(globalDriverHandles->size());
if (*pCount == 0) {
*pCount = driverCount;
return ZE_RESULT_SUCCESS;
@ -126,7 +129,7 @@ ze_result_t DriverImp::driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phD
}
for (uint32_t i = 0; i < *pCount; i++) {
phDriverHandles[i] = globalDriverHandle;
phDriverHandles[i] = (*globalDriverHandles)[i];
}
return ZE_RESULT_SUCCESS;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -9,6 +9,8 @@
#include <level_zero/ze_api.h>
#include <vector>
namespace L0 {
struct Driver {
virtual ze_result_t driverInit() = 0;
@ -28,6 +30,6 @@ ze_result_t initDrivers(uint32_t *pCount, ze_driver_handle_t *phDrivers, ze_init
extern bool sysmanInitFromCore;
extern uint32_t driverCount;
extern _ze_driver_handle_t *globalDriverHandle;
extern std::vector<_ze_driver_handle_t *> *globalDriverHandles;
extern bool levelZeroDriverInitialized;
} // namespace L0

4
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@ -47,8 +47,6 @@
namespace L0 {
struct DriverHandleImp *globalDriver;
DriverHandleImp::DriverHandleImp() = default;
ze_result_t DriverHandleImp::createContext(const ze_context_desc_t *desc,
@ -304,8 +302,6 @@ DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> dev
return nullptr;
}
globalDriver = driverHandle;
driverHandle->getMemoryManager()->setForceNonSvmForExternalHostPtr(true);
return driverHandle;

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

@ -185,6 +185,4 @@ struct DriverHandleImp : public DriverHandle {
NEO::SvmAllocationData **peerAllocData);
};
extern struct DriverHandleImp *globalDriver;
} // namespace L0

20
level_zero/core/source/global_teardown.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2023-2024 Intel Corporation
* Copyright (C) 2023-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,6 +19,9 @@ decltype(&zelLoaderTranslateHandle) loaderTranslateHandleFunc = nullptr;
decltype(&zelSetDriverTeardown) setDriverTeardownFunc = nullptr;
void globalDriverSetup() {
if (!globalDriverHandles) {
globalDriverHandles = new std::vector<_ze_driver_handle_t *>;
}
NEO::OsLibraryCreateProperties loaderLibraryProperties("ze_loader.dll");
loaderLibraryProperties.performSelfLoad = true;
std::unique_ptr<NEO::OsLibrary> loaderLibrary = std::unique_ptr<NEO::OsLibrary>{NEO::OsLibrary::loadFunc(loaderLibraryProperties)};
@ -43,12 +46,19 @@ void globalDriverTeardown() {
}
}
if (globalDriver != nullptr) {
if (globalDriverHandles) {
for (auto &globalDriverHandle : *globalDriverHandles) {
auto globalDriver = static_cast<L0::DriverHandleImp *>(DriverHandle::fromHandle(globalDriverHandle));
if (globalDriver != nullptr) {
if (globalDriver->pid == NEO::SysCalls::getCurrentProcessId()) {
delete globalDriver;
if (globalDriver->pid == NEO::SysCalls::getCurrentProcessId()) {
delete globalDriver;
}
globalDriver = nullptr;
}
}
globalDriver = nullptr;
delete globalDriverHandles;
globalDriverHandles = nullptr;
}
if (Sysman::globalSysmanDriver != nullptr) {
delete Sysman::globalSysmanDriver;

10
level_zero/core/test/common/ult_config_listener_l0.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2023-2024 Intel Corporation
* Copyright (C) 2023-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,16 +14,12 @@
void L0::UltConfigListenerL0::OnTestStart(const ::testing::TestInfo &testInfo) {
BaseUltConfigListener::OnTestStart(testInfo);
globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
driverCount = 0;
globalDriverHandles->clear();
}
void L0::UltConfigListenerL0::OnTestEnd(const ::testing::TestInfo &testInfo) {
EXPECT_EQ(nullptr, globalDriverHandle);
EXPECT_EQ(0u, driverCount);
EXPECT_EQ(nullptr, L0::globalDriver);
EXPECT_TRUE(globalDriverHandles->empty());
EXPECT_EQ(nullptr, L0::Sysman::globalSysmanDriver);
BaseUltConfigListener::OnTestEnd(testInfo);

10
level_zero/core/test/common/ult_specific_config_l0.cpp
View File

@ -11,8 +11,14 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/test/common/ult_config_listener_l0.h"
namespace L0 {
extern std::vector<_ze_driver_handle_t *> *globalDriverHandles;
}
using namespace NEO;
void cleanTestHelpers() {}
void cleanTestHelpers() {
delete L0::globalDriverHandles;
L0::globalDriverHandles = nullptr;
}
bool sysmanUltsEnable = false;
@ -22,6 +28,8 @@ void applyWorkarounds() {
if (sysmanUltsEnableEnv != nullptr) {
sysmanUltsEnable = (strcmp(sysmanUltsEnableEnv, "1") == 0);
}
L0::globalDriverHandles = new std::vector<_ze_driver_handle_t *>;
L0::globalDriverHandles->reserve(1);
}
void setupTestFiles(std::string testBinaryFiles, int32_t revId) {

1
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp
View File

@ -614,7 +614,6 @@ void CommandQueueThreadArbitrationPolicyFixture::setUp() {
void CommandQueueThreadArbitrationPolicyFixture::tearDown() {
commandList->destroy();
commandQueue->destroy();
L0::globalDriver = nullptr;
}
void CommandListScratchPatchFixtureInit::setUpParams(int32_t globalStatelessMode, int32_t heaplessStateInitEnabled, bool scratchAddressPatchingEnabled) {

7
level_zero/core/test/unit_tests/fixtures/device_fixture.h
View File

@ -31,8 +31,6 @@ struct Context;
struct Device;
struct ContextImp;
extern uint32_t driverCount;
extern _ze_driver_handle_t *globalDriverHandle;
namespace ult {
class MockBuiltins;
@ -54,8 +52,6 @@ struct DeviceFixture {
const uint32_t rootDeviceIndex = 0u;
template <typename HelperType>
HelperType &getHelper() const;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
template <typename T>
@ -131,9 +127,6 @@ struct MultiDeviceFixture {
uint32_t numSubDevices = 2u;
L0::ContextImp *context = nullptr;
NEO::DeviceHierarchyMode deviceHierarchyMode = NEO::DeviceHierarchyMode::composite;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
struct MultiDeviceFixtureHierarchy : public MultiDeviceFixture {

41
level_zero/core/test/unit_tests/os_interface/global_teardown_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2023-2024 Intel Corporation
* Copyright (C) 2023-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -21,8 +21,10 @@
namespace L0 {
namespace ult {
TEST(GlobalTearDownTests, whenCallingGlobalDriverSetupThenLoaderFunctionForTranslateHandleIsLoadedIfAvailable) {
struct GlobalTearDownTests : public ::testing::Test {
VariableBackup<decltype(globalDriverHandles)> globalDriverHandlesBackup{&globalDriverHandles, nullptr};
};
TEST_F(GlobalTearDownTests, whenCallingGlobalDriverSetupThenLoaderFunctionForTranslateHandleIsLoadedIfAvailable) {
void *mockSetDriverTeardownPtr = reinterpret_cast<void *>(static_cast<uintptr_t>(0x1234ABC8));
void *mockLoaderTranslateHandlePtr = reinterpret_cast<void *>(static_cast<uintptr_t>(0x5678EF08));
@ -67,6 +69,7 @@ TEST(GlobalTearDownTests, whenCallingGlobalDriverSetupThenLoaderFunctionForTrans
EXPECT_EQ(nullptr, setDriverTeardownFunc);
EXPECT_EQ(mockLoaderTranslateHandlePtr, reinterpret_cast<void *>(loaderTranslateHandleFunc));
globalDriverTeardown();
}
uint32_t loaderTearDownCalled = 0;
@ -76,7 +79,7 @@ ze_result_t loaderTearDown() {
return ZE_RESULT_ERROR_UNKNOWN;
};
TEST(GlobalTearDownTests, givenInitializedDriverWhenCallingGlobalDriverTeardownThenLoaderFunctionForTeardownIsLoadedAndCalledIfAvailable) {
TEST_F(GlobalTearDownTests, givenInitializedDriverWhenCallingGlobalDriverTeardownThenLoaderFunctionForTeardownIsLoadedAndCalledIfAvailable) {
void *mockLoaderTranslateHandlePtr = reinterpret_cast<void *>(static_cast<uintptr_t>(0x5678EF08));
@ -130,7 +133,7 @@ TEST(GlobalTearDownTests, givenInitializedDriverWhenCallingGlobalDriverTeardownT
EXPECT_EQ(nullptr, loaderTranslateHandleFunc);
}
TEST(GlobalTearDownTests, givenInitializedDriverAndNoTeardownFunctionIsAvailableWhenCallGlobalTeardownThenDontCrash) {
TEST_F(GlobalTearDownTests, givenInitializedDriverAndNoTeardownFunctionIsAvailableWhenCallGlobalTeardownThenDontCrash) {
VariableBackup<bool> initializedBackup{&levelZeroDriverInitialized};
VariableBackup<decltype(setDriverTeardownFunc)> teardownFuncBackup{&setDriverTeardownFunc};
@ -139,7 +142,7 @@ TEST(GlobalTearDownTests, givenInitializedDriverAndNoTeardownFunctionIsAvailable
EXPECT_NO_THROW(globalDriverTeardown());
}
TEST(GlobalTearDownTests, givenNotInitializedDriverAndTeardownFunctionIsAvailableWhenCallGlobalTeardownThenDontCallTeardownFunc) {
TEST_F(GlobalTearDownTests, givenNotInitializedDriverAndTeardownFunctionIsAvailableWhenCallGlobalTeardownThenDontCallTeardownFunc) {
VariableBackup<bool> initializedBackup{&levelZeroDriverInitialized};
VariableBackup<decltype(setDriverTeardownFunc)> teardownFuncBackup{&setDriverTeardownFunc};
@ -151,36 +154,38 @@ TEST(GlobalTearDownTests, givenNotInitializedDriverAndTeardownFunctionIsAvailabl
EXPECT_NO_THROW(globalDriverTeardown());
}
TEST(GlobalTearDownTests, givenCallToGlobalTearDownFunctionThenGlobalDriversAreNull) {
TEST_F(GlobalTearDownTests, givenCallToGlobalTearDownFunctionThenGlobalDriversAreNull) {
globalDriverTeardown();
EXPECT_EQ(globalDriver, nullptr);
EXPECT_EQ(globalDriverHandles, nullptr);
EXPECT_EQ(Sysman::globalSysmanDriver, nullptr);
}
TEST(GlobalTearDownTests, givenCallToGlobalTearDownFunctionWithNullSysManDriverThenGlobalDriverIsNull) {
TEST_F(GlobalTearDownTests, givenCallToGlobalTearDownFunctionWithNullSysManDriverThenGlobalDriverIsNull) {
delete Sysman::globalSysmanDriver;
Sysman::globalSysmanDriver = nullptr;
globalDriverTeardown();
EXPECT_EQ(globalDriver, nullptr);
EXPECT_EQ(globalDriverHandles, nullptr);
EXPECT_EQ(Sysman::globalSysmanDriver, nullptr);
}
TEST(GlobalTearDownTests, givenForkedProcessWhenGlobalTearDownFunctionCalledThenGlobalDriverIsNotDeleted) {
VariableBackup<uint32_t> driverCountBackup{&L0::driverCount};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&L0::globalDriverHandle};
TEST_F(GlobalTearDownTests, givenForkedProcessWhenGlobalTearDownFunctionCalledThenGlobalDriverIsNotDeleted) {
VariableBackup<decltype(globalDriverHandles)> globalDriverHandlesBackup{&globalDriverHandles, nullptr};
globalDriverHandles = new std::vector<_ze_driver_handle_t *>;
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(L0::globalDriver, nullptr);
EXPECT_EQ(1u, globalDriverHandles->size());
auto tempDriver = static_cast<L0::DriverHandleImp *>(DriverHandle::fromHandle((*globalDriverHandles)[0]));
EXPECT_NE(tempDriver, nullptr);
// change pid in driver
L0::globalDriver->pid = L0::globalDriver->pid + 5;
auto tempDriver = L0::globalDriver;
tempDriver->pid = tempDriver->pid + 5;
globalDriverTeardown();
EXPECT_EQ(L0::globalDriver, nullptr);
EXPECT_EQ(globalDriverHandles, nullptr);
EXPECT_EQ(Sysman::globalSysmanDriver, nullptr);
delete tempDriver;

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

@ -228,7 +228,6 @@ TEST_F(DriverVersionTest, givenExternalAllocatorWhenCallingGetExtensionPropertie
delete[] extensionProperties;
delete driverHandle;
L0::globalDriver = nullptr;
}
TEST_F(DriverVersionTest, WhenGettingDriverVersionThenExpectedDriverVersionIsReturned) {
@ -473,7 +472,6 @@ TEST(DriverTestFamilySupport, whenInitializingDriverOnSupportedFamilyThenDriverI
auto driverHandle = DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue);
EXPECT_NE(nullptr, driverHandle);
delete driverHandle;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenNullEnvVariableWhenCreatingDriverThenEnableProgramDebuggingIsFalse) {
@ -493,13 +491,9 @@ TEST(DriverTest, givenNullEnvVariableWhenCreatingDriverThenEnableProgramDebuggin
EXPECT_EQ(NEO::DebuggingMode::disabled, driverHandle->enableProgramDebugging);
delete driverHandle;
L0::globalDriver = nullptr;
}
struct DriverImpTest : public ::testing::Test {
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
};
using DriverImpTest = ::testing::Test;
TEST_F(DriverImpTest, givenDriverImpWhenInitializedThenEnvVariablesAreRead) {
@ -511,9 +505,10 @@ TEST_F(DriverImpTest, givenDriverImpWhenInitializedThenEnvVariablesAreRead) {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_LE(3u, IoFunctions::mockGetenvCalled);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenMissingMetricApiDependenciesWhenInitializingDriverImpThenGlobalDriverHandleIsNull) {
@ -535,8 +530,7 @@ TEST_F(DriverImpTest, givenMissingMetricApiDependenciesWhenInitializingDriverImp
DriverImp driverImp;
driverImp.initialize(&result);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(nullptr, L0::globalDriverHandle);
EXPECT_EQ(nullptr, L0::globalDriver);
EXPECT_TRUE(globalDriverHandles->empty());
}
TEST_F(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) {
@ -549,13 +543,12 @@ TEST_F(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironme
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_TRUE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) {
@ -568,13 +561,12 @@ TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecution
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_TRUE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenEnabledFP64EmulationWhenCreatingExecutionEnvironmentThenFP64EmulationIsEnabled) {
@ -587,37 +579,32 @@ TEST_F(DriverImpTest, givenEnabledFP64EmulationWhenCreatingExecutionEnvironmentT
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_TRUE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isFP64EmulationEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_TRUE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isFP64EmulationEnabled());
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenEnabledProgramDebuggingAndEnabledExperimentalOpenCLWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
DebugManagerStateRestore restorer;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
NEO::debugManager.flags.ExperimentalEnableL0DebuggerForOpenCL.set(true);
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZET_ENABLE_PROGRAM_DEBUGGING", "1"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(L0::globalDriverHandle)> mockableDriverHandle(&L0::globalDriverHandle);
VariableBackup<decltype(L0::globalDriver)> mockableDriver(&L0::globalDriver);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_FALSE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::globalDriver;
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2AndEnabledExperimentalOpenCLWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
@ -627,18 +614,17 @@ TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2AndEnabledExperimenta
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZET_ENABLE_PROGRAM_DEBUGGING", "2"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(L0::globalDriverHandle)> mockableDriverHandle(&L0::globalDriverHandle);
VariableBackup<decltype(L0::globalDriver)> mockableDriver(&L0::globalDriver);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_FALSE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete L0::globalDriver;
delete driverHandle;
globalDriverHandles->clear();
}
TEST_F(DriverImpTest, givenNoProgramDebuggingEnvVarWhenCreatingExecutionEnvironmentThenDebuggingEnabledIsFalse) {
@ -646,13 +632,13 @@ TEST_F(DriverImpTest, givenNoProgramDebuggingEnvVarWhenCreatingExecutionEnvironm
DriverImp driverImp;
driverImp.initialize(&result);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
EXPECT_FALSE(L0::globalDriver->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
ASSERT_FALSE(globalDriverHandles->empty());
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
auto driverHandle = static_cast<L0::DriverHandleImp *>((*globalDriverHandles)[0]);
EXPECT_FALSE(driverHandle->devices[0]->getNEODevice()->getExecutionEnvironment()->isDebuggingEnabled());
delete driverHandle;
globalDriverHandles->clear();
}
TEST(DriverTest, givenProgramDebuggingEnvVarValue1WhenCreatingDriverThenEnableProgramDebuggingIsSetToTrue) {
@ -673,7 +659,6 @@ TEST(DriverTest, givenProgramDebuggingEnvVarValue1WhenCreatingDriverThenEnablePr
EXPECT_TRUE(driverHandle->enableProgramDebugging == NEO::DebuggingMode::online);
delete driverHandle;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenProgramDebuggingEnvVarValue2WhenCreatingDriverThenEnableProgramDebuggingIsSetToTrue) {
@ -694,7 +679,6 @@ TEST(DriverTest, givenProgramDebuggingEnvVarValue2WhenCreatingDriverThenEnablePr
EXPECT_TRUE(driverHandle->enableProgramDebugging == NEO::DebuggingMode::offline);
delete driverHandle;
L0::globalDriver = nullptr;
}
TEST(DriverTest, givenBuiltinsAsyncInitEnabledWhenCreatingDriverThenMakeSureBuiltinsInitIsCompletedOnExitOfDriverHandleInitialization) {
@ -723,7 +707,6 @@ TEST(DriverTest, givenBuiltinsAsyncInitEnabledWhenCreatingDriverThenMakeSureBuil
}
delete driverHandle;
L0::globalDriver = nullptr;
/* std::async may create a detached thread - completion of the scheduled task can be ensured,
but there is no way to ensure that actual OS thread exited and its resources are freed */
@ -747,7 +730,7 @@ TEST(DriverTest, givenInvalidCompilerEnvironmentThenDependencyUnavailableErrorIs
Os::frontEndDllName = oldFclDllName;
ASSERT_EQ(nullptr, L0::globalDriver);
ASSERT_TRUE(globalDriverHandles->empty());
}
TEST(DriverTest, givenInvalidCompilerEnvironmentAndEnableProgramDebuggingWithValue2ThenDependencyUnavailableErrorIsReturned) {
@ -767,7 +750,7 @@ TEST(DriverTest, givenInvalidCompilerEnvironmentAndEnableProgramDebuggingWithVal
Os::frontEndDllName = oldFclDllName;
ASSERT_EQ(nullptr, L0::globalDriver);
ASSERT_TRUE(globalDriverHandles->empty());
}
TEST(MultiRootDeviceDriverTest, whenInitializingDriverHandleWithMultipleDevicesThenOrderInRootDeviceIndicesMatchesOrderInDeviceVector) {
@ -817,6 +800,7 @@ struct MaskArray {
struct DriverHandleTest : public ::testing::Test {
void SetUp() override {
globalDriverHandles = new std::vector<_ze_driver_handle_t *>;
ze_result_t returnValue;
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
@ -829,17 +813,14 @@ struct DriverHandleTest : public ::testing::Test {
envVariables.programDebugging = true;
driverHandle = whiteboxCast(DriverHandle::create(std::move(devices), envVariables, &returnValue));
L0::globalDriverHandle = driverHandle;
L0::driverCount = 1;
globalDriverHandles->push_back(driverHandle);
}
void TearDown() override {
delete driverHandle;
L0::globalDriver = nullptr;
L0::globalDriverHandle = nullptr;
delete globalDriverHandles;
}
L0::DriverHandle *driverHandle;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
VariableBackup<decltype(globalDriverHandles)> globalDriverHandleBackup{&globalDriverHandles, nullptr};
};
TEST(DriverHandleNegativeTest, givenNotInitializedDriverWhenZeDriverGetIsCalledThenReturnZeroCount) {
@ -906,7 +887,8 @@ TEST_F(DriverHandleTest, givenInitializedDriverWhenZeDriverGetIsCalledThenGlobal
result = zeDriverGet(&count, &hDriverHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, hDriverHandle);
EXPECT_EQ(hDriverHandle, globalDriver);
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(hDriverHandle, expectedDriverHandle);
}
TEST_F(DriverHandleTest, givenInitializedDriverWhenGetDeviceIsCalledThenOneDeviceIsObtained) {
@ -1164,6 +1146,7 @@ TEST_F(DriverExperimentalApiTest, givenGetVersionStringAPIExistsThenGetCurrentVe
struct GtPinInitTest : public ::testing::Test {
void SetUp() override {
globalDriverHandles = new std::vector<_ze_driver_handle_t *>;
gtpinInitTimesCalled = 0u;
driver.driverInitCallBase = true;
driver.initializeCallBase = true;
@ -1183,8 +1166,9 @@ struct GtPinInitTest : public ::testing::Test {
if (result != ZE_RESULT_SUCCESS || driverCount != 1) {
return 1;
}
EXPECT_EQ(globalDriverHandle, driverHandle);
if (globalDriverHandle != driverHandle) {
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(expectedDriverHandle, driverHandle);
if (expectedDriverHandle != driverHandle) {
return 1;
}
@ -1198,7 +1182,11 @@ struct GtPinInitTest : public ::testing::Test {
}
void TearDown() override {
delete MockOsLibrary::loadLibraryNewObject;
delete globalDriverHandle;
for (auto &driverHandle : *globalDriverHandles) {
delete driverHandle;
}
delete globalDriverHandles;
globalDriverHandles = nullptr;
gtpinInitTimesCalled = 0u;
}
@ -1210,9 +1198,7 @@ struct GtPinInitTest : public ::testing::Test {
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup{&IoFunctions::mockableEnvValues, &mockableEnvs};
VariableBackup<decltype(NEO::OsLibrary::loadFunc)> funcBackup{&NEO::OsLibrary::loadFunc, MockOsLibrary::load};
VariableBackup<NEO::OsLibrary *> osLibraryBackup{&MockOsLibrary::loadLibraryNewObject, nullptr};
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle, nullptr};
VariableBackup<decltype(L0::globalDriver)> globalDriverBackup{&L0::globalDriver, nullptr};
VariableBackup<uint32_t> driverCountBackup{&driverCount};
VariableBackup<decltype(globalDriverHandles)> globalDriverHandleBackup{&globalDriverHandles, nullptr};
};
uint32_t GtPinInitTest::gtpinInitTimesCalled = 0u;
@ -1247,7 +1233,8 @@ TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeDriverGetMultipleTime
result = zeDriverGet(&driverCount, &driverHandle);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
EXPECT_EQ(globalDriverHandle, driverHandle);
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(expectedDriverHandle, driverHandle);
EXPECT_EQ(1u, driver.initCalledCount);
EXPECT_EQ(1u, driver.initializeCalledCount);
@ -1274,7 +1261,8 @@ TEST_F(GtPinInitTest, givenFailureWhenInitializingGtpinThenTheErrorIsNotExposedI
result = zeDriverGet(&driverCount, &driverHandle);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
EXPECT_EQ(globalDriverHandle, driverHandle);
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(expectedDriverHandle, driverHandle);
}
TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitDriversWithoutDriverHandlesRequestedMultipleTimesThenGtPinIsNotInitialized) {
@ -1338,7 +1326,8 @@ TEST_F(GtPinInitTest, givenRequirementForGtpinWhenCallingZeInitDriversMultipleTi
result = zeInitDrivers(&driverCount, &driverHandle, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
EXPECT_EQ(globalDriverHandle, driverHandle);
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(expectedDriverHandle, driverHandle);
EXPECT_EQ(2u, driver.initCalledCount);
EXPECT_EQ(1u, driver.initializeCalledCount);
@ -1366,7 +1355,8 @@ TEST_F(GtPinInitTest, givenFailureWhenInitializingGtpinThenTheErrorIsNotExposedI
result = zeInitDrivers(&driverCount, &driverHandle, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_EQ(1u, driverCount);
EXPECT_EQ(globalDriverHandle, driverHandle);
auto expectedDriverHandle = (*globalDriverHandles)[0];
EXPECT_EQ(expectedDriverHandle, driverHandle);
}
TEST(InitDriversTest, givenZeInitDriversCalledWhenCallingZeInitDriversInForkedProcessThenNewDriverIsInitialized) {

35
level_zero/tools/source/metrics/metric.cpp
View File

@ -182,29 +182,30 @@ ze_result_t MetricDeviceContext::enableMetricApi() {
bool failed = false;
auto driverHandle = L0::DriverHandle::fromHandle(globalDriverHandle);
auto rootDevices = std::vector<ze_device_handle_t>();
auto subDevices = std::vector<ze_device_handle_t>();
for (auto &globalDriverHandle : *globalDriverHandles) {
auto driverHandle = L0::DriverHandle::fromHandle(globalDriverHandle);
auto rootDevices = std::vector<ze_device_handle_t>();
auto subDevices = std::vector<ze_device_handle_t>();
// Obtain root devices.
uint32_t rootDeviceCount = 0;
driverHandle->getDevice(&rootDeviceCount, nullptr);
rootDevices.resize(rootDeviceCount);
driverHandle->getDevice(&rootDeviceCount, rootDevices.data());
// Obtain root devices.
uint32_t rootDeviceCount = 0;
driverHandle->getDevice(&rootDeviceCount, nullptr);
rootDevices.resize(rootDeviceCount);
driverHandle->getDevice(&rootDeviceCount, rootDevices.data());
for (auto rootDeviceHandle : rootDevices) {
auto rootDevice = static_cast<DeviceImp *>(L0::Device::fromHandle(rootDeviceHandle));
// Initialize root device.
failed |= !rootDevice->metricContext->enable();
for (auto rootDeviceHandle : rootDevices) {
auto rootDevice = static_cast<DeviceImp *>(L0::Device::fromHandle(rootDeviceHandle));
// Initialize root device.
failed |= !rootDevice->metricContext->enable();
// Initialize sub devices.
for (uint32_t i = 0; i < rootDevice->numSubDevices; ++i) {
failed |= !rootDevice->subDevices[i]->getMetricDeviceContext().enable();
}
}
if (failed) {
break;
}
// Initialize sub devices.
for (uint32_t i = 0; i < rootDevice->numSubDevices; ++i) {
failed |= !rootDevice->subDevices[i]->getMetricDeviceContext().enable();
}
}
return failed

10
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,7 +14,7 @@
#include <level_zero/zet_api.h>
namespace L0 {
extern _ze_driver_handle_t *globalDriverHandle;
extern std::vector<_ze_driver_handle_t *> *globalDriverHandles;
namespace ult {
@ -48,11 +48,12 @@ void MetricIpSamplingFixture::SetUp() {
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricOaSource.setInitializationState(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
globalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
globalDriverHandles->push_back(driverHandle.get());
}
void MetricIpSamplingFixture::TearDown() {
MultiDeviceFixture::tearDown();
globalDriverHandles->clear();
}
void MetricIpSamplingTimestampFixture::SetUp() {
@ -67,11 +68,12 @@ void MetricIpSamplingTimestampFixture::SetUp() {
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricOaSource.setInitializationState(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
globalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
globalDriverHandles->push_back(driverHandle.get());
}
void MetricIpSamplingTimestampFixture::TearDown() {
DeviceFixture::tearDown();
globalDriverHandles->clear();
}
} // namespace ult

4
level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -23,7 +23,6 @@ void MetricQueryPoolTest::SetUp() {
void MetricQueryPoolTest::TearDown() {
MetricContextFixture::tearDown();
driverHandle.reset();
globalDriver = nullptr;
}
void MultiDeviceMetricQueryPoolTest::SetUp() {
@ -36,7 +35,6 @@ void MultiDeviceMetricQueryPoolTest::SetUp() {
void MultiDeviceMetricQueryPoolTest::TearDown() {
MetricMultiDeviceFixture::tearDown();
driverHandle.reset();
globalDriver = nullptr;
}
} // namespace ult

6
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,6 @@
namespace L0 {
extern _ze_driver_handle_t *globalDriverHandle;
namespace ult {
class MockOsLibrary : public NEO::OsLibrary {
@ -48,9 +47,10 @@ using MetricInitializationTest = Test<MetricContextFixture>;
TEST_F(MetricInitializationTest, GivenOaDependenciesAreAvailableThenMetricInitializationIsSuccess) {
globalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
globalDriverHandles->push_back(driverHandle.get());
VariableBackup<decltype(NEO::OsLibrary::loadFunc)> funcBackup{&NEO::OsLibrary::loadFunc, MockOsLibrary::load};
EXPECT_EQ(device->getMetricDeviceContext().enableMetricApi(), ZE_RESULT_SUCCESS);
globalDriverHandles->clear();
}
} // namespace ult