1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/source/driver/driver.h"
#include "shared/source/device/device.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/os_interface/debug_env_reader.h"
#include "shared/source/os_interface/device_factory.h"
#include "level_zero/core/source/device/device.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 "level_zero/tools/source/pin/pin.h"
#include <memory>
#include <thread>
namespace L0 {
_ze_driver_handle_t *GlobalDriverHandle;
uint32_t driverCount = 1;
void DriverImp::initialize(ze_result_t *result) {
*result = ZE_RESULT_ERROR_UNINITIALIZED;
NEO::EnvironmentVariableReader envReader;
L0EnvVariables envVariables = {};
envVariables.affinityMask =
envReader.getSetting("ZE_AFFINITY_MASK", std::string(""));
envVariables.programDebugging =
envReader.getSetting("ZET_ENABLE_PROGRAM_DEBUGGING", false);
envVariables.metrics =
envReader.getSetting("ZET_ENABLE_METRICS", false);
envVariables.pin =
envReader.getSetting("ZET_ENABLE_PROGRAM_INSTRUMENTATION", false);
envVariables.sysman =
envReader.getSetting("ZES_ENABLE_SYSMAN", false);
envVariables.pciIdDeviceOrder =
envReader.getSetting("ZE_ENABLE_PCI_ID_DEVICE_ORDER", false);
auto executionEnvironment = new NEO::ExecutionEnvironment();
UNRECOVERABLE_IF(nullptr == executionEnvironment);
if (envVariables.programDebugging) {
executionEnvironment->setDebuggingEnabled();
}
executionEnvironment->incRefInternal();
auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment);
executionEnvironment->decRefInternal();
if (!neoDevices.empty()) {
GlobalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
if (GlobalDriverHandle != nullptr) {
*result = ZE_RESULT_SUCCESS;
if (envVariables.metrics) {
*result = MetricDeviceContext::enableMetricApi();
if (*result != ZE_RESULT_SUCCESS) {
delete GlobalDriver;
GlobalDriverHandle = nullptr;
GlobalDriver = nullptr;
}
}
if ((*result == ZE_RESULT_SUCCESS) && envVariables.pin) {
*result = PinContext::init();
if (*result != ZE_RESULT_SUCCESS) {
delete GlobalDriver;
GlobalDriverHandle = nullptr;
GlobalDriver = nullptr;
}
}
}
}
}
ze_result_t DriverImp::initStatus(ZE_RESULT_ERROR_UNINITIALIZED);
ze_result_t DriverImp::driverInit(ze_init_flags_t flags) {
std::call_once(initDriverOnce, [this]() {
ze_result_t result;
this->initialize(&result);
initStatus = result;
});
return initStatus;
}
ze_result_t driverHandleGet(uint32_t *pCount, ze_driver_handle_t *phDriverHandles) {
if (*pCount == 0) {
*pCount = driverCount;
return ZE_RESULT_SUCCESS;
}
if (*pCount > driverCount) {
*pCount = driverCount;
}
if (phDriverHandles == nullptr) {
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
}
for (uint32_t i = 0; i < *pCount; i++) {
phDriverHandles[i] = GlobalDriverHandle;
}
return ZE_RESULT_SUCCESS;
}
static DriverImp driverImp;
Driver *Driver::driver = &driverImp;
ze_result_t init(ze_init_flags_t flags) {
if (flags && !(flags & ZE_INIT_FLAG_GPU_ONLY))
return ZE_RESULT_ERROR_UNINITIALIZED;
else
return Driver::get()->driverInit(flags);
}
} // namespace L0
|
