Skip to content

Commit 76e9ac0

Browse files
nrspruitKornevNikita
nrspruit
authored and
KornevNikita
committed
[UR][L0] Avoid calls to destroy interop data structures given loader instability (#17543)
- When an application transfers ownership of a L0 handle to the UR, this does not prevent the OS from releasing the memory backing the handle when the interop library is torn down. This leads to a situation where the UR is trying to destroy interop data structures that have already been destroyed by the OS. - UR has never known the lifetime of the handle, but with the static L0 Loader, the workaround in the loader to handle this situation and "pretend" the memory was freed is impossible to use. - To fix this issue, avoid calls to destroy interop data structures when the runtime is being torn down. - This avoids calling a function that already did not perform the intended operation and prevents segfaults when the UR tries to destroy interop data structures that have already been destroyed. --------- Signed-off-by: Neil R. Spruit <[email protected]>
1 parent 7257a7a commit 76e9ac0

19 files changed

+186
-59
lines changed

‎unified-runtime/source/adapters/level_zero/common.hpp

Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,13 @@
1818
#include <unordered_map>
1919
#include <vector>
2020

21+
#ifdef _WIN32
22+
#include "windows.h"
23+
#else
24+
#include <dlfcn.h>
25+
#include <unistd.h>
26+
#endif
27+
2128
#include <ur/ur.hpp>
2229
#include <ur_ddi.h>
2330
#include <ze_api.h>
@@ -30,6 +37,68 @@
3037

3138
struct _ur_platform_handle_t;
3239

40+
[[maybe_unused]] static bool checkL0LoaderTeardown() {
41+
bool loaderStable = true;
42+
#ifdef _WIN32
43+
uint32_t ZeDriverCount = 0;
44+
HMODULE zeLoader = LoadLibrary("ze_loader.dll");
45+
if (zeLoader) {
46+
typedef ze_result_t (*zeDriverGet_t)(uint32_t *, ze_driver_handle_t *);
47+
zeDriverGet_t zeDriverGetLoader =
48+
(zeDriverGet_t)GetProcAddress(zeLoader, "zeDriverGet");
49+
if (zeDriverGetLoader) {
50+
ze_result_t result = zeDriverGetLoader(&ZeDriverCount, nullptr);
51+
logger::debug(
52+
"ZE ---> checkL0LoaderTeardown result = {} driver count = {}", result,
53+
ZeDriverCount);
54+
if (result != ZE_RESULT_SUCCESS || ZeDriverCount == 0) {
55+
loaderStable = false;
56+
}
57+
} else {
58+
logger::debug("ZE ---> checkL0LoaderTeardown: Failed to get address of "
59+
"zeDriverGet");
60+
loaderStable = false;
61+
}
62+
FreeLibrary(zeLoader);
63+
} else {
64+
logger::debug(
65+
"ZE ---> checkL0LoaderTeardown: Failed to load ze_loader.dll");
66+
loaderStable = false;
67+
}
68+
#else
69+
uint32_t ZeDriverCount = 0;
70+
void *zeLoader = dlopen("libze_loader.so.1", RTLD_LAZY);
71+
if (zeLoader) {
72+
typedef ze_result_t (*zeDriverGet_t)(uint32_t *, ze_driver_handle_t *);
73+
zeDriverGet_t zeDriverGetLoader =
74+
(zeDriverGet_t)dlsym(zeLoader, "zeDriverGet");
75+
if (zeDriverGetLoader) {
76+
ze_result_t result = zeDriverGetLoader(&ZeDriverCount, nullptr);
77+
logger::debug(
78+
"ZE ---> checkL0LoaderTeardown result = {} driver count = {}", result,
79+
ZeDriverCount);
80+
if (result != ZE_RESULT_SUCCESS || ZeDriverCount == 0) {
81+
loaderStable = false;
82+
}
83+
} else {
84+
logger::debug("ZE ---> checkL0LoaderTeardown: Failed to get address of "
85+
"zeDriverGet");
86+
loaderStable = false;
87+
}
88+
dlclose(zeLoader);
89+
} else {
90+
logger::debug(
91+
"ZE ---> checkL0LoaderTeardown: Failed to load libze_loader.so.1");
92+
loaderStable = false;
93+
}
94+
#endif
95+
if (!loaderStable) {
96+
logger::debug(
97+
"ZE ---> checkL0LoaderTeardown: Loader is not stable, returning false");
98+
}
99+
return loaderStable;
100+
}
101+
33102
static auto getUrResultString = [](ur_result_t Result) {
34103
switch (Result) {
35104
case UR_RESULT_SUCCESS:
@@ -435,6 +504,9 @@ struct _ur_object {
435504
// Indicates if we own the native handle or it came from interop that
436505
// asked to not transfer the ownership to SYCL RT.
437506
bool OwnNativeHandle = false;
507+
508+
// Indicates if this object is an interop handle.
509+
bool IsInteropNativeHandle = false;
438510
};
439511

440512
// Record for a memory allocation. This structure is used to keep information

‎unified-runtime/source/adapters/level_zero/context.cpp

Lines changed: 13 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -151,6 +151,7 @@ ur_result_t urContextCreateWithNativeHandle(
151151
ur_context_handle_t_ *UrContext = new ur_context_handle_t_(
152152
ZeContext, NumDevices, Devices, OwnNativeHandle);
153153
UrContext->initialize();
154+
UrContext->IsInteropNativeHandle = true;
154155
*Context = reinterpret_cast<ur_context_handle_t>(UrContext);
155156
} catch (const std::bad_alloc &) {
156157
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -262,7 +263,11 @@ ur_result_t ContextReleaseHelper(ur_context_handle_t Context) {
262263
Contexts.erase(It);
263264
}
264265
ze_context_handle_t DestroyZeContext =
265-
Context->OwnNativeHandle ? Context->ZeContext : nullptr;
266+
((Context->OwnNativeHandle && !Context->IsInteropNativeHandle) ||
267+
(Context->OwnNativeHandle && Context->IsInteropNativeHandle &&
268+
checkL0LoaderTeardown()))
269+
? Context->ZeContext
270+
: nullptr;
266271

267272
// Clean up any live memory associated with Context
268273
ur_result_t Result = Context->finalize();
@@ -299,11 +304,14 @@ ur_result_t ur_context_handle_t_::finalize() {
299304
std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
300305
for (auto &EventCache : EventCaches) {
301306
for (auto &Event : EventCache) {
302-
auto ZeResult = ZE_CALL_NOCHECK(zeEventDestroy, (Event->ZeEvent));
307+
if (!Event->IsInteropNativeHandle ||
308+
(Event->IsInteropNativeHandle && checkL0LoaderTeardown())) {
309+
auto ZeResult = ZE_CALL_NOCHECK(zeEventDestroy, (Event->ZeEvent));
310+
// Gracefully handle the case that L0 was already unloaded.
311+
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
312+
return ze2urResult(ZeResult);
313+
}
303314
Event->ZeEvent = nullptr;
304-
// Gracefully handle the case that L0 was already unloaded.
305-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
306-
return ze2urResult(ZeResult);
307315
delete Event;
308316
}
309317
EventCache.clear();

‎unified-runtime/source/adapters/level_zero/device.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1416,6 +1416,7 @@ ur_result_t urDeviceCreateWithNativeHandle(
14161416
if (Dev == nullptr)
14171417
return UR_RESULT_ERROR_INVALID_VALUE;
14181418

1419+
Dev->IsInteropNativeHandle = true;
14191420
*Device = Dev;
14201421
return UR_RESULT_SUCCESS;
14211422
}

‎unified-runtime/source/adapters/level_zero/event.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1001,6 +1001,7 @@ ur_result_t urEventCreateWithNativeHandle(
10011001
UREvent->CleanedUp = true;
10021002

10031003
*Event = reinterpret_cast<ur_event_handle_t>(UREvent);
1004+
UREvent->IsInteropNativeHandle = true;
10041005

10051006
return UR_RESULT_SUCCESS;
10061007
}
@@ -1116,11 +1117,14 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) {
11161117
}
11171118
if (Event->OwnNativeHandle) {
11181119
if (DisableEventsCaching) {
1119-
auto ZeResult = ZE_CALL_NOCHECK(zeEventDestroy, (Event->ZeEvent));
1120+
if (!Event->IsInteropNativeHandle ||
1121+
(Event->IsInteropNativeHandle && checkL0LoaderTeardown())) {
1122+
auto ZeResult = ZE_CALL_NOCHECK(zeEventDestroy, (Event->ZeEvent));
1123+
// Gracefully handle the case that L0 was already unloaded.
1124+
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1125+
return ze2urResult(ZeResult);
1126+
}
11201127
Event->ZeEvent = nullptr;
1121-
// Gracefully handle the case that L0 was already unloaded.
1122-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1123-
return ze2urResult(ZeResult);
11241128
auto Context = Event->Context;
11251129
if (auto Res = Context->decrementUnreleasedEventsInPool(Event))
11261130
return Res;

‎unified-runtime/source/adapters/level_zero/kernel.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -940,10 +940,13 @@ ur_result_t urKernelRelease(
940940
auto KernelProgram = Kernel->Program;
941941
if (Kernel->OwnNativeHandle) {
942942
for (auto &ZeKernel : Kernel->ZeKernels) {
943-
auto ZeResult = ZE_CALL_NOCHECK(zeKernelDestroy, (ZeKernel));
944-
// Gracefully handle the case that L0 was already unloaded.
945-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
946-
return ze2urResult(ZeResult);
943+
if (!Kernel->IsInteropNativeHandle ||
944+
(Kernel->IsInteropNativeHandle && checkL0LoaderTeardown())) {
945+
auto ZeResult = ZE_CALL_NOCHECK(zeKernelDestroy, (ZeKernel));
946+
// Gracefully handle the case that L0 was already unloaded.
947+
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
948+
return ze2urResult(ZeResult);
949+
}
947950
}
948951
}
949952
Kernel->ZeKernelMap.clear();
@@ -1154,6 +1157,7 @@ ur_result_t urKernelCreateWithNativeHandle(
11541157
}
11551158

11561159
Kernel->Program = Program;
1160+
Kernel->IsInteropNativeHandle = true;
11571161

11581162
UR_CALL(Kernel->initialize());
11591163

‎unified-runtime/source/adapters/level_zero/memory.cpp

Lines changed: 10 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1563,6 +1563,7 @@ ur_result_t urMemImageCreateWithNativeHandle(
15631563
auto OwnNativeHandle = Properties ? Properties->isNativeHandleOwned : false;
15641564
UR_CALL(createUrMemFromZeImage(Context, ZeHImage, OwnNativeHandle,
15651565
ZeImageDesc, Mem));
1566+
(*Mem)->IsInteropNativeHandle = true;
15661567

15671568
return UR_RESULT_SUCCESS;
15681569
}
@@ -1662,11 +1663,14 @@ ur_result_t urMemRelease(
16621663
if (Image->OwnNativeHandle) {
16631664
UR_CALL(Mem->getZeHandle(ZeHandleImage, ur_mem_handle_t_::write_only,
16641665
nullptr, nullptr, 0u));
1665-
auto ZeResult = ZE_CALL_NOCHECK(
1666-
zeImageDestroy, (ur_cast<ze_image_handle_t>(ZeHandleImage)));
1667-
// Gracefully handle the case that L0 was already unloaded.
1668-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1669-
return ze2urResult(ZeResult);
1666+
if (!Image->IsInteropNativeHandle ||
1667+
(Image->IsInteropNativeHandle && checkL0LoaderTeardown())) {
1668+
auto ZeResult = ZE_CALL_NOCHECK(
1669+
zeImageDestroy, (ur_cast<ze_image_handle_t>(ZeHandleImage)));
1670+
// Gracefully handle the case that L0 was already unloaded.
1671+
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1672+
return ze2urResult(ZeResult);
1673+
}
16701674
}
16711675
delete Image;
16721676
} else {
@@ -1772,6 +1776,7 @@ ur_result_t urMemBufferCreateWithNativeHandle(
17721776
Buffer = new _ur_buffer(Context, Size, Device, ur_cast<char *>(NativeMem),
17731777
OwnNativeHandle);
17741778
*Mem = reinterpret_cast<ur_mem_handle_t>(Buffer);
1779+
(*Mem)->IsInteropNativeHandle = true;
17751780
} catch (const std::bad_alloc &) {
17761781
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
17771782
} catch (...) {

‎unified-runtime/source/adapters/level_zero/program.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -956,7 +956,6 @@ ur_result_t urProgramCreateWithNativeHandle(
956956
UR_ASSERT(Context && NativeProgram, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
957957
UR_ASSERT(Program, UR_RESULT_ERROR_INVALID_NULL_POINTER);
958958
auto ZeModule = ur_cast<ze_module_handle_t>(NativeProgram);
959-
960959
// We assume here that programs created from a native handle always
961960
// represent a fully linked executable (state Exe) and not an unlinked
962961
// executable (state Object).
@@ -966,6 +965,7 @@ ur_result_t urProgramCreateWithNativeHandle(
966965
ur_program_handle_t_::Exe, Context, ZeModule,
967966
Properties ? Properties->isNativeHandleOwned : false);
968967
*Program = reinterpret_cast<ur_program_handle_t>(UrProgram);
968+
(*Program)->IsInteropNativeHandle = true;
969969
} catch (const std::bad_alloc &) {
970970
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
971971
} catch (...) {
@@ -1036,15 +1036,15 @@ ur_program_handle_t_::ur_program_handle_t_(ur_context_handle_t Context)
10361036
ur_program_handle_t_::ur_program_handle_t_(state, ur_context_handle_t Context,
10371037
ze_module_handle_t InteropZeModule)
10381038
: Context{Context}, NativeProperties{nullptr}, OwnZeModule{true},
1039-
AssociatedDevices({Context->getDevices()[0]}),
1040-
InteropZeModule{InteropZeModule} {}
1039+
AssociatedDevices({Context->getDevices()[0]}), InteropZeModule{
1040+
InteropZeModule} {}
10411041

10421042
ur_program_handle_t_::ur_program_handle_t_(state, ur_context_handle_t Context,
10431043
ze_module_handle_t InteropZeModule,
10441044
bool OwnZeModule)
10451045
: Context{Context}, NativeProperties{nullptr}, OwnZeModule{OwnZeModule},
1046-
AssociatedDevices({Context->getDevices()[0]}),
1047-
InteropZeModule{InteropZeModule} {
1046+
AssociatedDevices({Context->getDevices()[0]}), InteropZeModule{
1047+
InteropZeModule} {
10481048
// TODO: Currently it is not possible to understand the device associated
10491049
// with provided ZeModule. So we can't set the state on that device to Exe.
10501050
}
@@ -1080,10 +1080,10 @@ void ur_program_handle_t_::ur_release_program_resources(bool deletion) {
10801080
if (DeviceData.ZeBuildLog)
10811081
ZE_CALL_NOCHECK(zeModuleBuildLogDestroy, (DeviceData.ZeBuildLog));
10821082
}
1083-
10841083
// interop api
1085-
if (InteropZeModule && OwnZeModule)
1084+
if (InteropZeModule && OwnZeModule && checkL0LoaderTeardown()) {
10861085
ZE_CALL_NOCHECK(zeModuleDestroy, (InteropZeModule));
1086+
}
10871087

10881088
for (auto &[ZeDevice, DeviceData] : this->DeviceDataMap)
10891089
if (DeviceData.ZeModule)

‎unified-runtime/source/adapters/level_zero/queue.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -798,6 +798,7 @@ ur_result_t urQueueCreateWithNativeHandle(
798798
ur_queue_handle_t_ *Queue = new ur_queue_handle_t_(
799799
ComputeQueues, CopyQueues, Context, UrDevice, OwnNativeHandle, Flags);
800800
*RetQueue = reinterpret_cast<ur_queue_handle_t>(Queue);
801+
(*RetQueue)->IsInteropNativeHandle = true;
801802
} catch (const std::bad_alloc &) {
802803
return UR_RESULT_ERROR_OUT_OF_RESOURCES;
803804
} catch (...) {
@@ -1599,10 +1600,13 @@ ur_result_t urQueueReleaseInternal(ur_queue_handle_t Queue) {
15991600
for (auto &QueueGroup : QueueMap)
16001601
for (auto &ZeQueue : QueueGroup.second.ZeQueues)
16011602
if (ZeQueue) {
1602-
auto ZeResult = ZE_CALL_NOCHECK(zeCommandQueueDestroy, (ZeQueue));
1603-
// Gracefully handle the case that L0 was already unloaded.
1604-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1605-
return ze2urResult(ZeResult);
1603+
if (!Queue->IsInteropNativeHandle ||
1604+
(Queue->IsInteropNativeHandle && checkL0LoaderTeardown())) {
1605+
auto ZeResult = ZE_CALL_NOCHECK(zeCommandQueueDestroy, (ZeQueue));
1606+
// Gracefully handle the case that L0 was already unloaded.
1607+
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
1608+
return ze2urResult(ZeResult);
1609+
}
16061610
}
16071611
}
16081612

‎unified-runtime/source/adapters/level_zero/usm.cpp

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -644,13 +644,18 @@ ur_result_t UR_APICALL urUSMPoolTrimToExp(ur_context_handle_t,
644644
} // namespace ur::level_zero
645645

646646
static ur_result_t USMFreeImpl(ur_context_handle_t Context, void *Ptr) {
647-
auto ZeResult = ZE_CALL_NOCHECK(zeMemFree, (Context->ZeContext, Ptr));
648-
// Handle When the driver is already released
649-
if (ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
650-
return UR_RESULT_SUCCESS;
651-
} else {
652-
return ze2urResult(ZeResult);
647+
ur_result_t Res = UR_RESULT_SUCCESS;
648+
if (!Context->IsInteropNativeHandle ||
649+
(Context->IsInteropNativeHandle && checkL0LoaderTeardown())) {
650+
auto ZeResult = ZE_CALL_NOCHECK(zeMemFree, (Context->ZeContext, Ptr));
651+
// Handle When the driver is already released
652+
if (ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
653+
Res = UR_RESULT_SUCCESS;
654+
} else {
655+
Res = ze2urResult(ZeResult);
656+
}
653657
}
658+
return Res;
654659
}
655660

656661
static ur_result_t USMQueryPageSize(ur_context_handle_t Context, void *Ptr,

‎unified-runtime/source/adapters/level_zero/v2/common.hpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,8 @@ struct ze_handle_wrapper {
7979
return;
8080
}
8181

82-
if (ownZeHandle) {
82+
if ((ownZeHandle && !IsInteropNativeHandle) ||
83+
(ownZeHandle && IsInteropNativeHandle && checkL0LoaderTeardown())) {
8384
auto zeResult = destroy(handle);
8485
// Gracefully handle the case that L0 was already unloaded.
8586
if (zeResult && zeResult != ZE_RESULT_ERROR_UNINITIALIZED)
@@ -102,6 +103,7 @@ struct ze_handle_wrapper {
102103
private:
103104
ZeHandleT handle;
104105
bool ownZeHandle;
106+
bool IsInteropNativeHandle = false;
105107
};
106108

107109
using ze_kernel_handle_t = HANDLE_WRAPPER_TYPE(::ze_kernel_handle_t,

‎unified-runtime/source/adapters/level_zero/v2/context.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -152,6 +152,7 @@ ur_result_t urContextCreateWithNativeHandle(
152152

153153
*phContext =
154154
new ur_context_handle_t_(zeContext, numDevices, phDevices, ownZeHandle);
155+
(*phContext)->IsInteropNativeHandle = true;
155156
return UR_RESULT_SUCCESS;
156157
} catch (...) {
157158
return exceptionToResult(std::current_exception());

‎unified-runtime/source/adapters/level_zero/v2/event.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -398,6 +398,7 @@ urEventCreateWithNativeHandle(ur_native_handle_t hNativeEvent,
398398
ZE2UR_CALL(zeEventHostSignal, ((*phEvent)->getZeEvent()));
399399
} else {
400400
*phEvent = new ur_event_handle_t_(hContext, hNativeEvent, pProperties);
401+
(*phEvent)->IsInteropNativeHandle = true;
401402
}
402403
return UR_RESULT_SUCCESS;
403404
} catch (...) {

‎unified-runtime/source/adapters/level_zero/v2/kernel.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -361,6 +361,7 @@ urKernelCreateWithNativeHandle(ur_native_handle_t hNativeKernel,
361361

362362
*phKernel =
363363
new ur_kernel_handle_t_(hNativeKernel, hProgram, hContext, pProperties);
364+
(*phKernel)->IsInteropNativeHandle = true;
364365
return UR_RESULT_SUCCESS;
365366
} catch (...) {
366367
return exceptionToResult(std::current_exception());

0 commit comments

Comments
 (0)