Skip to content

Commit 8a816e4

Browse files
kswiecickikswiecicki
authored
[UR] Bump UMF tag (#19262)
Changes in the UMF API required some fixes in L0, L0v2, HIP and CUDA adapters.
1 parent 29e7b63 commit 8a816e4

File tree

13 files changed

+157
-135
lines changed

13 files changed

+157
-135
lines changed

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

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -94,10 +94,15 @@ urUSMSharedAlloc(ur_context_handle_t, ur_device_handle_t hDevice,
9494

9595
/// USM: Frees the given USM pointer associated with the context.
9696
///
97-
UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext,
98-
void *pMem) {
99-
(void)hContext; // unused
100-
return umf::umf2urResult(umfFree(pMem));
97+
UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t, void *pMem) {
98+
umf_memory_pool_handle_t hPool = NULL;
99+
umf_result_t ret = umfPoolByPtr(pMem, &hPool);
100+
if (ret == UMF_RESULT_SUCCESS) {
101+
return umf::umf2urResult(umfPoolFree(hPool, pMem));
102+
} else if (ret == UMF_RESULT_ERROR_INVALID_ARGUMENT) {
103+
return mapErrorUR(cuMemFree((CUdeviceptr)pMem));
104+
}
105+
return umf::umf2urResult(ret);
101106
}
102107

103108
UR_APIEXPORT ur_result_t UR_APICALL
@@ -178,8 +183,9 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
178183
return ReturnValue(Device);
179184
}
180185
case UR_USM_ALLOC_INFO_POOL: {
181-
auto UMFPool = umfPoolByPtr(pMem);
182-
if (!UMFPool) {
186+
umf_memory_pool_handle_t UMFPool = nullptr;
187+
auto UMFResult = umfPoolByPtr(pMem, &UMFPool);
188+
if (UMFResult != UMF_RESULT_SUCCESS || !UMFPool) {
183189
return UR_RESULT_ERROR_INVALID_VALUE;
184190
}
185191
ur_usm_pool_handle_t Pool = hContext->getOwningURPool(UMFPool);

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

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -126,7 +126,8 @@ USMFreeImpl([[maybe_unused]] ur_context_handle_t hContext, void *pMem) {
126126
/// USM: Frees the given USM pointer associated with the context.
127127
UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext,
128128
void *pMem) {
129-
if (auto Pool = umfPoolByPtr(pMem)) {
129+
umf_memory_pool_handle_t Pool = nullptr;
130+
if (umfPoolByPtr(pMem, &Pool) == UMF_RESULT_SUCCESS && Pool) {
130131
return umf::umf2urResult(umfPoolFree(Pool, pMem));
131132
} else {
132133
return USMFreeImpl(hContext, pMem);
@@ -230,8 +231,9 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem,
230231
return ReturnValue(Device);
231232
}
232233
case UR_USM_ALLOC_INFO_POOL: {
233-
auto UMFPool = umfPoolByPtr(pMem);
234-
if (!UMFPool) {
234+
umf_memory_pool_handle_t UMFPool = nullptr;
235+
auto UMFResult = umfPoolByPtr(pMem, &UMFPool);
236+
if (UMFResult != UMF_RESULT_SUCCESS || !UMFPool) {
235237
return UR_RESULT_ERROR_INVALID_VALUE;
236238
}
237239
ur_usm_pool_handle_t Pool = hContext->getOwningURPool(UMFPool);
@@ -316,10 +318,11 @@ enum umf_result_t USMMemoryProvider::free(void *Ptr, size_t Size) {
316318
return UMF_RESULT_SUCCESS;
317319
}
318320

319-
void USMMemoryProvider::get_last_native_error(const char **ErrMsg,
320-
int32_t *ErrCode) {
321+
enum umf_result_t USMMemoryProvider::get_last_native_error(const char **ErrMsg,
322+
int32_t *ErrCode) {
321323
(void)ErrMsg;
322324
*ErrCode = static_cast<int32_t>(getLastStatusRef());
325+
return UMF_RESULT_SUCCESS;
323326
}
324327

325328
umf_result_t USMMemoryProvider::get_min_page_size(const void *Ptr,

‎unified-runtime/source/adapters/hip/usm.hpp

Lines changed: 8 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -61,24 +61,19 @@ class USMMemoryProvider {
6161
umf_result_t initialize(ur_context_handle_t Ctx, ur_device_handle_t Dev);
6262
umf_result_t alloc(size_t Size, size_t Align, void **Ptr);
6363
umf_result_t free(void *Ptr, size_t Size);
64-
void get_last_native_error(const char **ErrMsg, int32_t *ErrCode);
64+
umf_result_t get_last_native_error(const char **ErrMsg, int32_t *ErrCode);
6565
umf_result_t get_min_page_size(const void *, size_t *);
6666
umf_result_t get_recommended_page_size(size_t, size_t *) {
6767
return UMF_RESULT_ERROR_NOT_SUPPORTED;
6868
};
69-
umf_result_t purge_lazy(void *, size_t) {
70-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
71-
};
72-
umf_result_t purge_force(void *, size_t) {
73-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
74-
};
75-
umf_result_t allocation_merge(void *, void *, size_t) {
76-
return UMF_RESULT_ERROR_UNKNOWN;
77-
}
78-
umf_result_t allocation_split(void *, size_t, size_t) {
79-
return UMF_RESULT_ERROR_UNKNOWN;
69+
umf_result_t get_name(const char **Name) {
70+
if (!Name) {
71+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
72+
}
73+
74+
*Name = "HIP";
75+
return UMF_RESULT_SUCCESS;
8076
}
81-
const char *get_name() { return "HIP"; }
8277

8378
virtual ~USMMemoryProvider() = default;
8479
};

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

Lines changed: 11 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -235,18 +235,24 @@ ur_result_t urEnqueueUSMFreeExp(
235235
(ZeCommandList, WaitList.Length, WaitList.ZeEventList));
236236
}
237237

238-
auto hPool = umfPoolByPtr(Mem);
239-
if (!hPool) {
238+
umf_memory_pool_handle_t hPool = nullptr;
239+
auto umfRet = umfPoolByPtr(Mem, &hPool);
240+
if (umfRet != UMF_RESULT_SUCCESS || !hPool) {
240241
return USMFreeHelper(Queue->Context, Mem);
241242
}
242243

243244
UsmPool *usmPool = nullptr;
244-
auto ret = umfPoolGetTag(hPool, (void **)&usmPool);
245-
if (ret != UMF_RESULT_SUCCESS || usmPool == nullptr) {
245+
umfRet = umfPoolGetTag(hPool, (void **)&usmPool);
246+
if (umfRet != UMF_RESULT_SUCCESS || usmPool == nullptr) {
247+
return USMFreeHelper(Queue->Context, Mem);
248+
}
249+
250+
size_t size = 0;
251+
umfRet = umfPoolMallocUsableSize(hPool, Mem, &size);
252+
if (umfRet != UMF_RESULT_SUCCESS) {
246253
return USMFreeHelper(Queue->Context, Mem);
247254
}
248255

249-
size_t size = umfPoolMallocUsableSize(hPool, Mem);
250256
(*Event)->RefCount.retain();
251257
usmPool->AsyncPool.insert(Mem, size, *Event, Queue);
252258

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

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -57,11 +57,14 @@ void EnqueuedPool::insert(void *Ptr, size_t Size, ur_event_handle_t Event,
5757
bool EnqueuedPool::cleanup() {
5858
auto Lock = std::lock_guard(Mutex);
5959
auto FreedAllocations = !Freelist.empty();
60+
61+
auto umfRet [[maybe_unused]] = UMF_RESULT_SUCCESS;
6062
for (auto It : Freelist) {
61-
auto hPool = umfPoolByPtr(It.Ptr);
63+
umf_memory_pool_handle_t hPool = nullptr;
64+
umfRet = umfPoolByPtr(It.Ptr, &hPool);
6265
assert(hPool != nullptr);
6366

64-
auto umfRet [[maybe_unused]] = umfPoolFree(hPool, It.Ptr);
67+
umfRet = umfPoolFree(hPool, It.Ptr);
6568
assert(umfRet == UMF_RESULT_SUCCESS);
6669

6770
if (It.Event)
@@ -81,11 +84,13 @@ bool EnqueuedPool::cleanupForQueue(void *Queue) {
8184

8285
bool FreedAllocations = false;
8386

87+
auto umfRet [[maybe_unused]] = UMF_RESULT_SUCCESS;
8488
while (It != Freelist.end() && It->Queue == Queue) {
85-
auto hPool = umfPoolByPtr(It->Ptr);
89+
umf_memory_pool_handle_t hPool = nullptr;
90+
umfRet = umfPoolByPtr(It->Ptr, &hPool);
8691
assert(hPool != nullptr);
8792

88-
auto umfRet [[maybe_unused]] = umfPoolFree(hPool, It->Ptr);
93+
umfRet = umfPoolFree(hPool, It->Ptr);
8994
assert(umfRet == UMF_RESULT_SUCCESS);
9095

9196
if (It->Event)

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

Lines changed: 17 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -44,34 +44,6 @@ ur_result_t getProviderNativeError(const char *providerName,
4444
usm::DisjointPoolAllConfigs DisjointPoolConfigInstance =
4545
InitializeDisjointPoolConfig();
4646

47-
ur_result_t umf2urResult(umf_result_t umfResult) {
48-
if (umfResult == UMF_RESULT_SUCCESS)
49-
return UR_RESULT_SUCCESS;
50-
51-
switch (umfResult) {
52-
case UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY:
53-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
54-
case UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC: {
55-
auto hProvider = umfGetLastFailedMemoryProvider();
56-
if (hProvider == nullptr)
57-
return UR_RESULT_ERROR_UNKNOWN;
58-
59-
ur_result_t Err = UR_RESULT_ERROR_UNKNOWN;
60-
umfMemoryProviderGetLastNativeError(hProvider, nullptr,
61-
reinterpret_cast<int32_t *>(&Err));
62-
return Err;
63-
}
64-
case UMF_RESULT_ERROR_INVALID_ARGUMENT:
65-
return UR_RESULT_ERROR_INVALID_ARGUMENT;
66-
case UMF_RESULT_ERROR_INVALID_ALIGNMENT:
67-
return UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT;
68-
case UMF_RESULT_ERROR_NOT_SUPPORTED:
69-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
70-
default:
71-
return UR_RESULT_ERROR_UNKNOWN;
72-
};
73-
}
74-
7547
usm::DisjointPoolAllConfigs InitializeDisjointPoolConfig() {
7648
const char *PoolUrTraceVal = std::getenv("UR_L0_USM_ALLOCATOR_TRACE");
7749
const char *PoolPiTraceVal =
@@ -472,8 +444,9 @@ ur_result_t urUSMGetMemAllocInfo(
472444
return ReturnValue(Size);
473445
}
474446
case UR_USM_ALLOC_INFO_POOL: {
475-
auto UMFPool = umfPoolByPtr(Ptr);
476-
if (!UMFPool) {
447+
umf_memory_pool_handle_t UMFPool = nullptr;
448+
auto umfRet = umfPoolByPtr(Ptr, &UMFPool);
449+
if (umfRet != UMF_RESULT_SUCCESS || !UMFPool) {
477450
return UR_RESULT_ERROR_INVALID_VALUE;
478451
}
479452

@@ -513,7 +486,7 @@ ur_result_t urUSMPoolCreate(
513486
} catch (const UsmAllocationException &Ex) {
514487
return Ex.getError();
515488
} catch (umf_result_t e) {
516-
return umf2urResult(e);
489+
return umf::umf2urResult(e);
517490
} catch (...) {
518491
return UR_RESULT_ERROR_UNKNOWN;
519492
}
@@ -808,15 +781,16 @@ typedef struct ze_ipc_data_t {
808781
ze_ipc_mem_handle_t zeHandle;
809782
} ze_ipc_data_t;
810783

811-
umf_result_t L0MemoryProvider::get_ipc_handle_size(size_t *Size) {
784+
umf_result_t L0MemoryProvider::ext_get_ipc_handle_size(size_t *Size) {
812785
UR_ASSERT(Size, UMF_RESULT_ERROR_INVALID_ARGUMENT);
813786
*Size = sizeof(ze_ipc_data_t);
814787

815788
return UMF_RESULT_SUCCESS;
816789
}
817790

818-
umf_result_t L0MemoryProvider::get_ipc_handle(const void *Ptr, size_t /*Size*/,
819-
void *IpcData) {
791+
umf_result_t L0MemoryProvider::ext_get_ipc_handle(const void *Ptr,
792+
size_t /*Size*/,
793+
void *IpcData) {
820794

821795
UR_ASSERT(Ptr && IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT);
822796
ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData;
@@ -831,7 +805,7 @@ umf_result_t L0MemoryProvider::get_ipc_handle(const void *Ptr, size_t /*Size*/,
831805
return UMF_RESULT_SUCCESS;
832806
}
833807

834-
umf_result_t L0MemoryProvider::put_ipc_handle(void *IpcData) {
808+
umf_result_t L0MemoryProvider::ext_put_ipc_handle(void *IpcData) {
835809
UR_ASSERT(IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT);
836810

837811
// zeMemPutIpcHandle was introduced in Level Zero 1.6. Before Level Zero 1.6,
@@ -849,7 +823,7 @@ umf_result_t L0MemoryProvider::put_ipc_handle(void *IpcData) {
849823
return UMF_RESULT_SUCCESS;
850824
}
851825

852-
umf_result_t L0MemoryProvider::open_ipc_handle(void *IpcData, void **Ptr) {
826+
umf_result_t L0MemoryProvider::ext_open_ipc_handle(void *IpcData, void **Ptr) {
853827
UR_ASSERT(IpcData && Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT);
854828
ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData;
855829

@@ -880,7 +854,8 @@ umf_result_t L0MemoryProvider::open_ipc_handle(void *IpcData, void **Ptr) {
880854
return UMF_RESULT_SUCCESS;
881855
}
882856

883-
umf_result_t L0MemoryProvider::close_ipc_handle(void *Ptr, size_t /*Size*/) {
857+
umf_result_t L0MemoryProvider::ext_close_ipc_handle(void *Ptr,
858+
size_t /*Size*/) {
884859

885860
UR_ASSERT(Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT);
886861
auto Ret = ZE_CALL_NOCHECK(zeMemCloseIpcHandle, (Context->ZeContext, Ptr));
@@ -1307,15 +1282,16 @@ ur_result_t USMFreeHelper(ur_context_handle_t Context, void *Ptr,
13071282
Context->MemAllocs.erase(It);
13081283
}
13091284

1310-
auto hPool = umfPoolByPtr(Ptr);
1311-
if (!hPool) {
1285+
umf_memory_pool_handle_t hPool = nullptr;
1286+
auto umfRet = umfPoolByPtr(Ptr, &hPool);
1287+
if (umfRet != UMF_RESULT_SUCCESS || !hPool) {
13121288
if (IndirectAccessTrackingEnabled)
13131289
UR_CALL(ContextReleaseHelper(Context));
13141290
return UR_RESULT_ERROR_INVALID_MEM_OBJECT;
13151291
}
13161292

1317-
auto umfRet = umfPoolFree(hPool, Ptr);
1293+
umfRet = umfPoolFree(hPool, Ptr);
13181294
if (IndirectAccessTrackingEnabled)
13191295
UR_CALL(ContextReleaseHelper(Context));
1320-
return umf2urResult(umfRet);
1296+
return umf::umf2urResult(umfRet);
13211297
}

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

Lines changed: 25 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -86,9 +86,10 @@ class USMMemoryProviderBase {
8686
virtual ur_result_t allocateImpl(void **, size_t, uint32_t) = 0;
8787

8888
public:
89-
virtual void get_last_native_error(const char ** /*ErrMsg*/,
90-
int32_t *ErrCode) {
89+
virtual umf_result_t get_last_native_error(const char ** /*ErrMsg*/,
90+
int32_t *ErrCode) {
9191
*ErrCode = static_cast<int32_t>(getLastStatusRef());
92+
return UMF_RESULT_SUCCESS;
9293
};
9394
virtual umf_result_t initialize(ur_context_handle_t, ur_device_handle_t) {
9495
return UMF_RESULT_ERROR_NOT_SUPPORTED;
@@ -105,34 +106,28 @@ class USMMemoryProviderBase {
105106
virtual umf_result_t get_recommended_page_size(size_t, size_t *) {
106107
return UMF_RESULT_ERROR_NOT_SUPPORTED;
107108
};
108-
virtual umf_result_t purge_lazy(void *, size_t) {
109-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
110-
};
111-
virtual umf_result_t purge_force(void *, size_t) {
112-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
113-
};
114-
virtual umf_result_t allocation_merge(void *, void *, size_t) {
109+
virtual umf_result_t ext_get_ipc_handle_size(size_t *) {
115110
return UMF_RESULT_ERROR_NOT_SUPPORTED;
116111
}
117-
virtual umf_result_t allocation_split(void *, size_t, size_t) {
112+
virtual umf_result_t ext_get_ipc_handle(const void *, size_t, void *) {
118113
return UMF_RESULT_ERROR_NOT_SUPPORTED;
119114
}
120-
virtual umf_result_t get_ipc_handle_size(size_t *) {
115+
virtual umf_result_t ext_put_ipc_handle(void *) {
121116
return UMF_RESULT_ERROR_NOT_SUPPORTED;
122117
}
123-
virtual umf_result_t get_ipc_handle(const void *, size_t, void *) {
118+
virtual umf_result_t ext_open_ipc_handle(void *, void **) {
124119
return UMF_RESULT_ERROR_NOT_SUPPORTED;
125120
}
126-
virtual umf_result_t put_ipc_handle(void *) {
121+
virtual umf_result_t ext_close_ipc_handle(void *, size_t) {
127122
return UMF_RESULT_ERROR_NOT_SUPPORTED;
128123
}
129-
virtual umf_result_t open_ipc_handle(void *, void **) {
124+
virtual umf_result_t ext_ctl(int, const char *, void *, size_t,
125+
umf_ctl_query_type_t) {
130126
return UMF_RESULT_ERROR_NOT_SUPPORTED;
131127
}
132-
virtual umf_result_t close_ipc_handle(void *, size_t) {
128+
virtual umf_result_t get_name(const char **) {
133129
return UMF_RESULT_ERROR_NOT_SUPPORTED;
134-
}
135-
virtual const char *get_name() { return ""; };
130+
};
136131
virtual ~USMMemoryProviderBase() = default;
137132
};
138133

@@ -151,12 +146,19 @@ class L0MemoryProvider : public USMMemoryProviderBase {
151146
umf_result_t free(void *Ptr, size_t Size) override;
152147
umf_result_t get_min_page_size(const void *, size_t *) override;
153148
// TODO: Different name for each provider (Host/Shared/SharedRO/Device)
154-
const char *get_name() override { return "Level Zero"; };
155-
umf_result_t get_ipc_handle_size(size_t *) override;
156-
umf_result_t get_ipc_handle(const void *, size_t, void *) override;
157-
umf_result_t put_ipc_handle(void *) override;
158-
umf_result_t open_ipc_handle(void *, void **) override;
159-
umf_result_t close_ipc_handle(void *, size_t) override;
149+
umf_result_t get_name(const char **name) override {
150+
if (!name) {
151+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
152+
}
153+
154+
*name = "Level Zero";
155+
return UMF_RESULT_SUCCESS;
156+
};
157+
umf_result_t ext_get_ipc_handle_size(size_t *) override;
158+
umf_result_t ext_get_ipc_handle(const void *, size_t, void *) override;
159+
umf_result_t ext_put_ipc_handle(void *) override;
160+
umf_result_t ext_open_ipc_handle(void *, void **) override;
161+
umf_result_t ext_close_ipc_handle(void *, size_t) override;
160162
};
161163

162164
// Allocation routines for shared memory type

0 commit comments

Comments
 (0)