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

Metric Api: Moved the initialization to zeInit

Browse Source 
Change-Id: Ia390389e514facb3d81cc28d97bf017367e9f728
Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
This commit is contained in:
Robert Krzemien
2020-07-16 14:01:25 +02:00
committed by sys_ocldev
parent 70babc4b69
commit d76515a18d
15 changed files with 482 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,8 +13,9 @@
#include "shared/source/os_interface/device_factory.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/driver/driver_imp.h"
#include "level_zero/tools/source/metrics/metric.h"
#include <memory>
#include <thread>
@@ -24,8 +25,8 @@ namespace L0 {
_ze_driver_handle_t *GlobalDriverHandle;
uint32_t driverCount = 1;
void DriverImp::initialize(bool *result) {
*result = false;
void DriverImp::initialize(ze_result_t *result) {
*result = ZE_RESULT_ERROR_UNINITIALIZED;
NEO::EnvironmentVariableReader envReader;
L0EnvVariables envVariables = {};
@@ -33,6 +34,8 @@ void DriverImp::initialize(bool *result) {
envReader.getSetting("ZE_AFFINITY_MASK", std::string(""));
envVariables.programDebugging =
envReader.getSetting("ZET_ENABLE_PROGRAM_DEBUGGING", false);
envVariables.metrics =
envReader.getSetting("ZE_ENABLE_METRICS", false);
auto executionEnvironment = new NEO::ExecutionEnvironment();
UNRECOVERABLE_IF(nullptr == executionEnvironment);
@@ -47,20 +50,29 @@ void DriverImp::initialize(bool *result) {
if (!neoDevices.empty()) {
GlobalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables);
if (GlobalDriverHandle != nullptr) {
*result = true;
*result = ZE_RESULT_SUCCESS;
if (envVariables.metrics) {
*result = MetricContext::enableMetricApi();
if (*result != ZE_RESULT_SUCCESS) {
delete GlobalDriver;
GlobalDriverHandle = nullptr;
GlobalDriver = nullptr;
}
}
}
}
}
bool DriverImp::initStatus(false);
ze_result_t DriverImp::initStatus(ZE_RESULT_ERROR_UNINITIALIZED);
ze_result_t DriverImp::driverInit(ze_init_flag_t flag) {
std::call_once(initDriverOnce, [this]() {
bool result;
ze_result_t result;
this->initialize(&result);
initStatus = result;
});
return ((initStatus) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNINITIALIZED);
return initStatus;
}
ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) {

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

@@ -14,7 +14,7 @@
namespace L0 {
struct Driver {
virtual ze_result_t driverInit(_ze_init_flag_t) = 0;
virtual void initialize(bool *result) = 0;
virtual void initialize(ze_result_t *result) = 0;
static Driver *get() { return driver; }
virtual ~Driver() = default;

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

@@ -18,16 +18,17 @@ class DriverImp : public Driver {
public:
ze_result_t driverInit(_ze_init_flag_t) override;
void initialize(bool *result) override;
void initialize(ze_result_t *result) override;
protected:
std::once_flag initDriverOnce;
static bool initStatus;
static ze_result_t initStatus;
};
struct L0EnvVariables {
std::string affinityMask;
bool programDebugging;
bool metrics;
};
} // namespace L0

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

@@ -32,11 +32,11 @@ struct Mock<Driver> : public Driver {
(override));
MOCK_METHOD(void,
initialize,
(bool *result),
(ze_result_t * result),
(override));
ze_result_t mockInit(ze_init_flag_t) { return this->DriverImp::driverInit(ZE_INIT_FLAG_NONE); }
void mockInitialize(bool *result) { *result = true; }
void mockInitialize(ze_result_t *result) { *result = ZE_RESULT_SUCCESS; }
Driver *previousDriver = nullptr;
};

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

@@ -95,26 +95,43 @@ TEST(DriverImpTest, givenDriverImpWhenInitializedThenEnvVariablesAreRead) {
VariableBackup<bool> mockDeviceFlagBackup(&IoFunctions::returnMockEnvValue, true);
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
VariableBackup<std::set<std::string>> notMockableEnvValuesBackup(&IoFunctions::notMockableEnvValues, {"ZE_ENABLE_METRICS"});
bool result = false;
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
EXPECT_TRUE(result);
EXPECT_LE(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_LE(3u, IoFunctions::mockGetenvCalled);
delete L0::GlobalDriver;
L0::GlobalDriverHandle = nullptr;
L0::GlobalDriver = nullptr;
}
TEST(DriverImpTest, givenMissingMetricApiDependenciesWhenInitializingDriverImpThenGlobalDriverHandleIsNull) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.levelZeroSupported = true;
VariableBackup<bool> mockDeviceFlagBackup(&IoFunctions::returnMockEnvValue, true);
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(nullptr, L0::GlobalDriverHandle);
EXPECT_EQ(nullptr, L0::GlobalDriver);
}
TEST(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironmentThenPerContextMemorySpaceIsTrue) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.capabilityTable.levelZeroSupported = true;
VariableBackup<bool> mockDeviceFlagBackup(&IoFunctions::returnMockEnvValue, true);
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
VariableBackup<std::set<std::string>> notMockableEnvValuesBackup(&IoFunctions::notMockableEnvValues, {"ZE_ENABLE_METRICS"});
bool result = false;
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
@@ -133,7 +150,7 @@ TEST(DriverImpTest, givenNoProgramDebuggingEnvVarWhenCreatingExecutionEnvironmen
VariableBackup<bool> mockDeviceFlagBackup(&IoFunctions::returnMockEnvValue, false);
bool result = false;
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);