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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
|
/*
*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
* @file ze_loader_api.cpp
*
*/
#include "ze_loader_internal.h"
#if defined(__cplusplus)
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////
/// @brief Exported function for initializing loader
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
ZE_DLLEXPORT ze_result_t ZE_APICALL
zeLoaderInit()
{
return loader::context->init();
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Exported function for verifying usable L0 Drivers for Loader to report
/// @deprecated This function is deprecated and will be removed in a future release.
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderDriverCheck(ze_init_flags_t flags, ze_init_driver_type_desc_t* desc, ze_global_dditable_t *globalInitStored, zes_global_dditable_t *sysmanGlobalInitStored, bool *requireDdiReinit, bool sysmanOnly)
{
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Exported function for getting tracing lib handle
///
/// @returns
/// - ::handle to tracing library
ZE_DLLEXPORT HMODULE ZE_APICALL
zeLoaderGetTracingHandle()
{
return loader::context->tracingLayer;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Get pointer to Loader Context
///
/// @returns
/// - ::Pointer to the Loader's Context
ZE_DLLEXPORT loader::context_t *ZE_APICALL
zelLoaderGetContext() {
return loader::context;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Internal function for Setting the ZE ddi table for the Tracing Layer.
///
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderTracingLayerInit(std::atomic<ze_dditable_t *> &zeDdiTable) {
zeDdiTable.store(&loader::context->tracing_dditable.ze);
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Internal function for Setting the ZER ddi table for the Tracing Layer.
///
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderZerTracingLayerInit(std::atomic<zer_dditable_t *> &zerDdiTable) {
zerDdiTable.store(&loader::context->tracing_dditable.zer);
return ZE_RESULT_SUCCESS;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderGetVersionsInternal(
size_t *num_elems, //Pointer to num versions to get.
zel_component_version_t *versions) //Pointer to array of versions. If set to NULL, num_elems is returned
{
if(nullptr == versions){
*num_elems = loader::context->compVersions.size();
return ZE_RESULT_SUCCESS;
}
auto size = *num_elems > loader::context->compVersions.size() ? loader::context->compVersions.size() : *num_elems;
memcpy(versions, loader::context->compVersions.data(), size * sizeof(zel_component_version_t));
return ZE_RESULT_SUCCESS;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderGetVersion(zel_component_version_t *version)
{
if(version == nullptr)
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
string_copy_s(version->component_name, "loader", ZEL_COMPONENT_STRING_SIZE);
version->spec_version = ZE_API_VERSION_CURRENT;
version->component_lib_version.major = LOADER_VERSION_MAJOR;
version->component_lib_version.minor = LOADER_VERSION_MINOR;
version->component_lib_version.patch = LOADER_VERSION_PATCH;
return ZE_RESULT_SUCCESS;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zelLoaderTranslateHandleInternal(
zel_handle_type_t handleType,
void *handleIn,
void **handleOut)
{
if (!handleIn || !handleOut) {
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
}
if(!loader::context->intercept_enabled) {
*handleOut = handleIn;
return ZE_RESULT_SUCCESS;
}
*handleOut = handleIn;
switch(handleType){
case ZEL_HANDLE_DRIVER:
{
// Determine if legacy loader intercept is enabled
// i.e., loader object exists for that handle by checking two conditions:
// 1. DDI Ext is disabled in loader by default OR
// 2. The input handle's function pointer matches the loader's dispatch table pointer,
// indicating that the handle was created through the legacy loader intercept layer
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Driver->pfnGet ==
loader::loaderDispatch->pCore->Driver->pfnGet);
if (legacy_ldr_intercept_enabled && loader::context->ze_driver_factory.hasInstance(reinterpret_cast<loader::ze_driver_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_driver_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_DEVICE:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Device->pfnGet ==
loader::loaderDispatch->pCore->Device->pfnGet);
if (legacy_ldr_intercept_enabled && loader::context->ze_device_factory.hasInstance(reinterpret_cast<loader::ze_device_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_device_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_CONTEXT:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Context->pfnCreate ==
loader::loaderDispatch->pCore->Context->pfnCreate);
if (legacy_ldr_intercept_enabled &&
loader::context->ze_context_factory.hasInstance(reinterpret_cast<loader::ze_context_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_context_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_COMMAND_QUEUE:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->CommandQueue->pfnCreate ==
loader::loaderDispatch->pCore->CommandQueue->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_command_queue_factory.hasInstance(reinterpret_cast<loader::ze_command_queue_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_command_queue_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_COMMAND_LIST:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->CommandList->pfnCreate ==
loader::loaderDispatch->pCore->CommandList->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_command_list_factory.hasInstance(reinterpret_cast<loader::ze_command_list_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_command_list_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_FENCE:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Fence->pfnCreate ==
loader::loaderDispatch->pCore->Fence->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_fence_factory.hasInstance(reinterpret_cast<loader::ze_fence_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_fence_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_EVENT_POOL:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->EventPool->pfnCreate ==
loader::loaderDispatch->pCore->EventPool->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_event_pool_factory.hasInstance(reinterpret_cast<loader::ze_event_pool_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_event_pool_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_EVENT:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Event->pfnCreate ==
loader::loaderDispatch->pCore->Event->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_event_factory.hasInstance(reinterpret_cast<loader::ze_event_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_event_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_IMAGE:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Image->pfnCreate ==
loader::loaderDispatch->pCore->Image->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_image_factory.hasInstance(reinterpret_cast<loader::ze_image_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_image_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_MODULE:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Module->pfnCreate ==
loader::loaderDispatch->pCore->Module->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_module_factory.hasInstance(reinterpret_cast<loader::ze_module_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_module_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_MODULE_BUILD_LOG:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->ModuleBuildLog->pfnGetString ==
loader::loaderDispatch->pCore->ModuleBuildLog->pfnGetString);
if (legacy_ldr_intercept_enabled && loader::context->ze_module_build_log_factory.hasInstance(reinterpret_cast<loader::ze_module_build_log_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_module_build_log_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_KERNEL:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Kernel->pfnCreate ==
loader::loaderDispatch->pCore->Kernel->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_kernel_factory.hasInstance(reinterpret_cast<loader::ze_kernel_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_kernel_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_SAMPLER:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->Sampler->pfnCreate ==
loader::loaderDispatch->pCore->Sampler->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_sampler_factory.hasInstance(reinterpret_cast<loader::ze_sampler_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_sampler_object_t *>(handleIn)->handle;
}
break;
}
case ZEL_HANDLE_PHYSICAL_MEM:
{
bool legacy_ldr_intercept_enabled = (!loader::context->driverDDIPathDefault) ||
(reinterpret_cast<ze_handle_t *>(handleIn)->pCore->PhysicalMem->pfnCreate ==
loader::loaderDispatch->pCore->PhysicalMem->pfnCreate);
if (legacy_ldr_intercept_enabled && loader::context->ze_physical_mem_factory.hasInstance(reinterpret_cast<loader::ze_physical_mem_object_t *>(handleIn)->handle))
{
*handleOut = reinterpret_cast<loader::ze_physical_mem_object_t *>(handleIn)->handle;
}
break;
}
default:
return ZE_RESULT_ERROR_INVALID_ENUMERATION;
}
return ZE_RESULT_SUCCESS;
}
#if defined(__cplusplus)
}
#endif
|
