diff --git a/.github/intel-llvm-mirror-base-commit b/.github/intel-llvm-mirror-base-commit index 861a2ddec1..1257af881e 100644 --- a/.github/intel-llvm-mirror-base-commit +++ b/.github/intel-llvm-mirror-base-commit @@ -1 +1 @@ -c270247bc15562ace836c4c0878046a86bbe87fa +bf62e0bfd96cf67214624f3ea6ebe7575ed1fd2e diff --git a/source/adapters/cuda/usm.cpp b/source/adapters/cuda/usm.cpp index a1d8b9455c..a532475a0d 100644 --- a/source/adapters/cuda/usm.cpp +++ b/source/adapters/cuda/usm.cpp @@ -94,10 +94,15 @@ urUSMSharedAlloc(ur_context_handle_t, ur_device_handle_t hDevice, /// USM: Frees the given USM pointer associated with the context. /// -UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext, - void *pMem) { - (void)hContext; // unused - return umf::umf2urResult(umfFree(pMem)); +UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t, void *pMem) { + umf_memory_pool_handle_t hPool = NULL; + umf_result_t ret = umfPoolByPtr(pMem, &hPool); + if (ret == UMF_RESULT_SUCCESS) { + return umf::umf2urResult(umfPoolFree(hPool, pMem)); + } else if (ret == UMF_RESULT_ERROR_INVALID_ARGUMENT) { + return mapErrorUR(cuMemFree((CUdeviceptr)pMem)); + } + return umf::umf2urResult(ret); } UR_APIEXPORT ur_result_t UR_APICALL @@ -178,8 +183,9 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem, return ReturnValue(Device); } case UR_USM_ALLOC_INFO_POOL: { - auto UMFPool = umfPoolByPtr(pMem); - if (!UMFPool) { + umf_memory_pool_handle_t UMFPool = nullptr; + auto UMFResult = umfPoolByPtr(pMem, &UMFPool); + if (UMFResult != UMF_RESULT_SUCCESS || !UMFPool) { return UR_RESULT_ERROR_INVALID_VALUE; } ur_usm_pool_handle_t Pool = hContext->getOwningURPool(UMFPool); diff --git a/source/adapters/hip/usm.cpp b/source/adapters/hip/usm.cpp index f8baf04d88..24c0872c9a 100644 --- a/source/adapters/hip/usm.cpp +++ b/source/adapters/hip/usm.cpp @@ -126,7 +126,8 @@ USMFreeImpl([[maybe_unused]] ur_context_handle_t hContext, void *pMem) { /// USM: Frees the given USM pointer associated with the context. UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext, void *pMem) { - if (auto Pool = umfPoolByPtr(pMem)) { + umf_memory_pool_handle_t Pool = nullptr; + if (umfPoolByPtr(pMem, &Pool) == UMF_RESULT_SUCCESS && Pool) { return umf::umf2urResult(umfPoolFree(Pool, pMem)); } else { return USMFreeImpl(hContext, pMem); @@ -230,8 +231,9 @@ urUSMGetMemAllocInfo(ur_context_handle_t hContext, const void *pMem, return ReturnValue(Device); } case UR_USM_ALLOC_INFO_POOL: { - auto UMFPool = umfPoolByPtr(pMem); - if (!UMFPool) { + umf_memory_pool_handle_t UMFPool = nullptr; + auto UMFResult = umfPoolByPtr(pMem, &UMFPool); + if (UMFResult != UMF_RESULT_SUCCESS || !UMFPool) { return UR_RESULT_ERROR_INVALID_VALUE; } ur_usm_pool_handle_t Pool = hContext->getOwningURPool(UMFPool); @@ -316,10 +318,11 @@ enum umf_result_t USMMemoryProvider::free(void *Ptr, size_t Size) { return UMF_RESULT_SUCCESS; } -void USMMemoryProvider::get_last_native_error(const char **ErrMsg, - int32_t *ErrCode) { +enum umf_result_t USMMemoryProvider::get_last_native_error(const char **ErrMsg, + int32_t *ErrCode) { (void)ErrMsg; *ErrCode = static_cast(getLastStatusRef()); + return UMF_RESULT_SUCCESS; } umf_result_t USMMemoryProvider::get_min_page_size(const void *Ptr, diff --git a/source/adapters/hip/usm.hpp b/source/adapters/hip/usm.hpp index 8a3a36ffca..43f8a11736 100644 --- a/source/adapters/hip/usm.hpp +++ b/source/adapters/hip/usm.hpp @@ -61,24 +61,19 @@ class USMMemoryProvider { umf_result_t initialize(ur_context_handle_t Ctx, ur_device_handle_t Dev); umf_result_t alloc(size_t Size, size_t Align, void **Ptr); umf_result_t free(void *Ptr, size_t Size); - void get_last_native_error(const char **ErrMsg, int32_t *ErrCode); + umf_result_t get_last_native_error(const char **ErrMsg, int32_t *ErrCode); umf_result_t get_min_page_size(const void *, size_t *); umf_result_t get_recommended_page_size(size_t, size_t *) { return UMF_RESULT_ERROR_NOT_SUPPORTED; }; - umf_result_t purge_lazy(void *, size_t) { - return UMF_RESULT_ERROR_NOT_SUPPORTED; - }; - umf_result_t purge_force(void *, size_t) { - return UMF_RESULT_ERROR_NOT_SUPPORTED; - }; - umf_result_t allocation_merge(void *, void *, size_t) { - return UMF_RESULT_ERROR_UNKNOWN; - } - umf_result_t allocation_split(void *, size_t, size_t) { - return UMF_RESULT_ERROR_UNKNOWN; + umf_result_t get_name(const char **Name) { + if (!Name) { + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + *Name = "HIP"; + return UMF_RESULT_SUCCESS; } - const char *get_name() { return "HIP"; } virtual ~USMMemoryProvider() = default; }; diff --git a/source/adapters/level_zero/async_alloc.cpp b/source/adapters/level_zero/async_alloc.cpp index 6d55fda0f2..67aa0dcfcc 100644 --- a/source/adapters/level_zero/async_alloc.cpp +++ b/source/adapters/level_zero/async_alloc.cpp @@ -235,18 +235,24 @@ ur_result_t urEnqueueUSMFreeExp( (ZeCommandList, WaitList.Length, WaitList.ZeEventList)); } - auto hPool = umfPoolByPtr(Mem); - if (!hPool) { + umf_memory_pool_handle_t hPool = nullptr; + auto umfRet = umfPoolByPtr(Mem, &hPool); + if (umfRet != UMF_RESULT_SUCCESS || !hPool) { return USMFreeHelper(Queue->Context, Mem); } UsmPool *usmPool = nullptr; - auto ret = umfPoolGetTag(hPool, (void **)&usmPool); - if (ret != UMF_RESULT_SUCCESS || usmPool == nullptr) { + umfRet = umfPoolGetTag(hPool, (void **)&usmPool); + if (umfRet != UMF_RESULT_SUCCESS || usmPool == nullptr) { + return USMFreeHelper(Queue->Context, Mem); + } + + size_t size = 0; + umfRet = umfPoolMallocUsableSize(hPool, Mem, &size); + if (umfRet != UMF_RESULT_SUCCESS) { return USMFreeHelper(Queue->Context, Mem); } - size_t size = umfPoolMallocUsableSize(hPool, Mem); (*Event)->RefCount.retain(); usmPool->AsyncPool.insert(Mem, size, *Event, Queue); diff --git a/source/adapters/level_zero/enqueued_pool.cpp b/source/adapters/level_zero/enqueued_pool.cpp index c81abb9049..1b6da1cb8c 100644 --- a/source/adapters/level_zero/enqueued_pool.cpp +++ b/source/adapters/level_zero/enqueued_pool.cpp @@ -57,11 +57,14 @@ void EnqueuedPool::insert(void *Ptr, size_t Size, ur_event_handle_t Event, bool EnqueuedPool::cleanup() { auto Lock = std::lock_guard(Mutex); auto FreedAllocations = !Freelist.empty(); + + auto umfRet [[maybe_unused]] = UMF_RESULT_SUCCESS; for (auto It : Freelist) { - auto hPool = umfPoolByPtr(It.Ptr); + umf_memory_pool_handle_t hPool = nullptr; + umfRet = umfPoolByPtr(It.Ptr, &hPool); assert(hPool != nullptr); - auto umfRet [[maybe_unused]] = umfPoolFree(hPool, It.Ptr); + umfRet = umfPoolFree(hPool, It.Ptr); assert(umfRet == UMF_RESULT_SUCCESS); if (It.Event) @@ -81,11 +84,13 @@ bool EnqueuedPool::cleanupForQueue(void *Queue) { bool FreedAllocations = false; + auto umfRet [[maybe_unused]] = UMF_RESULT_SUCCESS; while (It != Freelist.end() && It->Queue == Queue) { - auto hPool = umfPoolByPtr(It->Ptr); + umf_memory_pool_handle_t hPool = nullptr; + umfRet = umfPoolByPtr(It->Ptr, &hPool); assert(hPool != nullptr); - auto umfRet [[maybe_unused]] = umfPoolFree(hPool, It->Ptr); + umfRet = umfPoolFree(hPool, It->Ptr); assert(umfRet == UMF_RESULT_SUCCESS); if (It->Event) diff --git a/source/adapters/level_zero/usm.cpp b/source/adapters/level_zero/usm.cpp index e8dfb89df1..3aa86fd429 100644 --- a/source/adapters/level_zero/usm.cpp +++ b/source/adapters/level_zero/usm.cpp @@ -44,34 +44,6 @@ ur_result_t getProviderNativeError(const char *providerName, usm::DisjointPoolAllConfigs DisjointPoolConfigInstance = InitializeDisjointPoolConfig(); -ur_result_t umf2urResult(umf_result_t umfResult) { - if (umfResult == UMF_RESULT_SUCCESS) - return UR_RESULT_SUCCESS; - - switch (umfResult) { - case UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY: - return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY; - case UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC: { - auto hProvider = umfGetLastFailedMemoryProvider(); - if (hProvider == nullptr) - return UR_RESULT_ERROR_UNKNOWN; - - ur_result_t Err = UR_RESULT_ERROR_UNKNOWN; - umfMemoryProviderGetLastNativeError(hProvider, nullptr, - reinterpret_cast(&Err)); - return Err; - } - case UMF_RESULT_ERROR_INVALID_ARGUMENT: - return UR_RESULT_ERROR_INVALID_ARGUMENT; - case UMF_RESULT_ERROR_INVALID_ALIGNMENT: - return UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT; - case UMF_RESULT_ERROR_NOT_SUPPORTED: - return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; - default: - return UR_RESULT_ERROR_UNKNOWN; - }; -} - usm::DisjointPoolAllConfigs InitializeDisjointPoolConfig() { const char *PoolUrTraceVal = std::getenv("UR_L0_USM_ALLOCATOR_TRACE"); const char *PoolPiTraceVal = @@ -472,8 +444,9 @@ ur_result_t urUSMGetMemAllocInfo( return ReturnValue(Size); } case UR_USM_ALLOC_INFO_POOL: { - auto UMFPool = umfPoolByPtr(Ptr); - if (!UMFPool) { + umf_memory_pool_handle_t UMFPool = nullptr; + auto umfRet = umfPoolByPtr(Ptr, &UMFPool); + if (umfRet != UMF_RESULT_SUCCESS || !UMFPool) { return UR_RESULT_ERROR_INVALID_VALUE; } @@ -513,7 +486,7 @@ ur_result_t urUSMPoolCreate( } catch (const UsmAllocationException &Ex) { return Ex.getError(); } catch (umf_result_t e) { - return umf2urResult(e); + return umf::umf2urResult(e); } catch (...) { return UR_RESULT_ERROR_UNKNOWN; } @@ -808,15 +781,16 @@ typedef struct ze_ipc_data_t { ze_ipc_mem_handle_t zeHandle; } ze_ipc_data_t; -umf_result_t L0MemoryProvider::get_ipc_handle_size(size_t *Size) { +umf_result_t L0MemoryProvider::ext_get_ipc_handle_size(size_t *Size) { UR_ASSERT(Size, UMF_RESULT_ERROR_INVALID_ARGUMENT); *Size = sizeof(ze_ipc_data_t); return UMF_RESULT_SUCCESS; } -umf_result_t L0MemoryProvider::get_ipc_handle(const void *Ptr, size_t /*Size*/, - void *IpcData) { +umf_result_t L0MemoryProvider::ext_get_ipc_handle(const void *Ptr, + size_t /*Size*/, + void *IpcData) { UR_ASSERT(Ptr && IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT); 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*/, return UMF_RESULT_SUCCESS; } -umf_result_t L0MemoryProvider::put_ipc_handle(void *IpcData) { +umf_result_t L0MemoryProvider::ext_put_ipc_handle(void *IpcData) { UR_ASSERT(IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT); // 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) { return UMF_RESULT_SUCCESS; } -umf_result_t L0MemoryProvider::open_ipc_handle(void *IpcData, void **Ptr) { +umf_result_t L0MemoryProvider::ext_open_ipc_handle(void *IpcData, void **Ptr) { UR_ASSERT(IpcData && Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT); ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData; @@ -880,7 +854,8 @@ umf_result_t L0MemoryProvider::open_ipc_handle(void *IpcData, void **Ptr) { return UMF_RESULT_SUCCESS; } -umf_result_t L0MemoryProvider::close_ipc_handle(void *Ptr, size_t /*Size*/) { +umf_result_t L0MemoryProvider::ext_close_ipc_handle(void *Ptr, + size_t /*Size*/) { UR_ASSERT(Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT); auto Ret = ZE_CALL_NOCHECK(zeMemCloseIpcHandle, (Context->ZeContext, Ptr)); @@ -1307,15 +1282,16 @@ ur_result_t USMFreeHelper(ur_context_handle_t Context, void *Ptr, Context->MemAllocs.erase(It); } - auto hPool = umfPoolByPtr(Ptr); - if (!hPool) { + umf_memory_pool_handle_t hPool = nullptr; + auto umfRet = umfPoolByPtr(Ptr, &hPool); + if (umfRet != UMF_RESULT_SUCCESS || !hPool) { if (IndirectAccessTrackingEnabled) UR_CALL(ContextReleaseHelper(Context)); return UR_RESULT_ERROR_INVALID_MEM_OBJECT; } - auto umfRet = umfPoolFree(hPool, Ptr); + umfRet = umfPoolFree(hPool, Ptr); if (IndirectAccessTrackingEnabled) UR_CALL(ContextReleaseHelper(Context)); - return umf2urResult(umfRet); + return umf::umf2urResult(umfRet); } diff --git a/source/adapters/level_zero/usm.hpp b/source/adapters/level_zero/usm.hpp index f99a2f79c8..e0e59e72f5 100644 --- a/source/adapters/level_zero/usm.hpp +++ b/source/adapters/level_zero/usm.hpp @@ -86,9 +86,10 @@ class USMMemoryProviderBase { virtual ur_result_t allocateImpl(void **, size_t, uint32_t) = 0; public: - virtual void get_last_native_error(const char ** /*ErrMsg*/, - int32_t *ErrCode) { + virtual umf_result_t get_last_native_error(const char ** /*ErrMsg*/, + int32_t *ErrCode) { *ErrCode = static_cast(getLastStatusRef()); + return UMF_RESULT_SUCCESS; }; virtual umf_result_t initialize(ur_context_handle_t, ur_device_handle_t) { return UMF_RESULT_ERROR_NOT_SUPPORTED; @@ -105,34 +106,28 @@ class USMMemoryProviderBase { virtual umf_result_t get_recommended_page_size(size_t, size_t *) { return UMF_RESULT_ERROR_NOT_SUPPORTED; }; - virtual umf_result_t purge_lazy(void *, size_t) { - return UMF_RESULT_ERROR_NOT_SUPPORTED; - }; - virtual umf_result_t purge_force(void *, size_t) { - return UMF_RESULT_ERROR_NOT_SUPPORTED; - }; - virtual umf_result_t allocation_merge(void *, void *, size_t) { + virtual umf_result_t ext_get_ipc_handle_size(size_t *) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t allocation_split(void *, size_t, size_t) { + virtual umf_result_t ext_get_ipc_handle(const void *, size_t, void *) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t get_ipc_handle_size(size_t *) { + virtual umf_result_t ext_put_ipc_handle(void *) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t get_ipc_handle(const void *, size_t, void *) { + virtual umf_result_t ext_open_ipc_handle(void *, void **) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t put_ipc_handle(void *) { + virtual umf_result_t ext_close_ipc_handle(void *, size_t) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t open_ipc_handle(void *, void **) { + virtual umf_result_t ext_ctl(int, const char *, void *, size_t, + umf_ctl_query_type_t) { return UMF_RESULT_ERROR_NOT_SUPPORTED; } - virtual umf_result_t close_ipc_handle(void *, size_t) { + virtual umf_result_t get_name(const char **) { return UMF_RESULT_ERROR_NOT_SUPPORTED; - } - virtual const char *get_name() { return ""; }; + }; virtual ~USMMemoryProviderBase() = default; }; @@ -151,12 +146,19 @@ class L0MemoryProvider : public USMMemoryProviderBase { umf_result_t free(void *Ptr, size_t Size) override; umf_result_t get_min_page_size(const void *, size_t *) override; // TODO: Different name for each provider (Host/Shared/SharedRO/Device) - const char *get_name() override { return "Level Zero"; }; - umf_result_t get_ipc_handle_size(size_t *) override; - umf_result_t get_ipc_handle(const void *, size_t, void *) override; - umf_result_t put_ipc_handle(void *) override; - umf_result_t open_ipc_handle(void *, void **) override; - umf_result_t close_ipc_handle(void *, size_t) override; + umf_result_t get_name(const char **name) override { + if (!name) { + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + *name = "Level Zero"; + return UMF_RESULT_SUCCESS; + }; + umf_result_t ext_get_ipc_handle_size(size_t *) override; + umf_result_t ext_get_ipc_handle(const void *, size_t, void *) override; + umf_result_t ext_put_ipc_handle(void *) override; + umf_result_t ext_open_ipc_handle(void *, void **) override; + umf_result_t ext_close_ipc_handle(void *, size_t) override; }; // Allocation routines for shared memory type diff --git a/source/adapters/level_zero/v2/command_list_manager.cpp b/source/adapters/level_zero/v2/command_list_manager.cpp index 4532e6ded3..728db1360b 100644 --- a/source/adapters/level_zero/v2/command_list_manager.cpp +++ b/source/adapters/level_zero/v2/command_list_manager.cpp @@ -839,20 +839,26 @@ ur_result_t ur_command_list_manager::appendUSMFreeExp( auto [pWaitEvents, numWaitEvents] = getWaitListView(phEventWaitList, numEventsInWaitList); - umf_memory_pool_handle_t hPool = umfPoolByPtr(pMem); - if (!hPool) { + umf_memory_pool_handle_t hPool = nullptr; + auto umfRet = umfPoolByPtr(pMem, &hPool); + if (umfRet != UMF_RESULT_SUCCESS || !hPool) { return UR_RESULT_ERROR_INVALID_MEM_OBJECT; } UsmPool *usmPool = nullptr; - auto ret = umfPoolGetTag(hPool, (void **)&usmPool); - if (ret != UMF_RESULT_SUCCESS || !usmPool) { + umfRet = umfPoolGetTag(hPool, (void **)&usmPool); + if (umfRet != UMF_RESULT_SUCCESS || !usmPool) { // This should never happen UR_LOG(ERR, "enqueueUSMFreeExp: invalid pool tag"); return UR_RESULT_ERROR_UNKNOWN; } - size_t size = umfPoolMallocUsableSize(hPool, pMem); + size_t size = 0; + umfRet = umfPoolMallocUsableSize(hPool, pMem, &size); + if (umfRet != UMF_RESULT_SUCCESS) { + UR_LOG(ERR, "enqueueUSMFreeExp: failed to retrieve usable malloc size"); + return UR_RESULT_ERROR_UNKNOWN; + } if (numWaitEvents > 0) { ZE2UR_CALL(zeCommandListAppendWaitOnEvents, diff --git a/source/adapters/level_zero/v2/usm.cpp b/source/adapters/level_zero/v2/usm.cpp index f95d86e1c3..c30b23ee35 100644 --- a/source/adapters/level_zero/v2/usm.cpp +++ b/source/adapters/level_zero/v2/usm.cpp @@ -243,8 +243,9 @@ ur_result_t ur_usm_pool_handle_t_::allocate( } ur_result_t ur_usm_pool_handle_t_::free(void *ptr) { - auto umfPool = umfPoolByPtr(ptr); - if (umfPool) { + umf_memory_pool_handle_t umfPool = nullptr; + auto umfRet = umfPoolByPtr(ptr, &umfPool); + if (umfRet == UMF_RESULT_SUCCESS && umfPool) { return umf::umf2urResult(umfPoolFree(umfPool, ptr)); } else { UR_LOG(ERR, "Failed to find pool for pointer: {}", ptr); @@ -537,8 +538,9 @@ ur_result_t urUSMGetMemAllocInfo( return ReturnValue(size); } case UR_USM_ALLOC_INFO_POOL: { - auto umfPool = umfPoolByPtr(ptr); - if (!umfPool) { + umf_memory_pool_handle_t umfPool = nullptr; + auto umfRet = umfPoolByPtr(ptr, &umfPool); + if (umfRet != UMF_RESULT_SUCCESS || !umfPool) { return UR_RESULT_ERROR_INVALID_VALUE; } diff --git a/source/adapters/offload/platform.cpp b/source/adapters/offload/platform.cpp index bc3da4bdfe..671dd98fbe 100644 --- a/source/adapters/offload/platform.cpp +++ b/source/adapters/offload/platform.cpp @@ -61,7 +61,7 @@ urPlatformGetInfo(ur_platform_handle_t hPlatform, ur_platform_info_t propName, case UR_PLATFORM_INFO_BACKEND: return ReturnValue(UR_BACKEND_OFFLOAD); case UR_PLATFORM_INFO_ADAPTER: - return ReturnValue(&Adapter); + return ReturnValue(Adapter); break; default: return UR_RESULT_ERROR_INVALID_ENUMERATION; diff --git a/source/common/CMakeLists.txt b/source/common/CMakeLists.txt index 13dbad4ee7..1e17a0301d 100644 --- a/source/common/CMakeLists.txt +++ b/source/common/CMakeLists.txt @@ -42,12 +42,13 @@ if (NOT DEFINED UMF_REPO) endif() if (NOT DEFINED UMF_TAG) - # commit 0a63bbd489e8e910c3f9a2129b287bfc63925716 (HEAD -> main, upstream/main) - # Author: Rafał Rudnicki - # Date: Mon May 12 09:46:48 2025 +0200 - # Merge pull request #1308 from lukaszstolarczuk/depr-hwloc-disable-cmake - # [CMake] Warn about UMF_DISABLE_HWLOC being deprecated - set(UMF_TAG 0a63bbd489e8e910c3f9a2129b287bfc63925716) + # commit b02c3c5b3c2cf4b09ff82ce36c95a63e293aa88e + # Merge: 5835cb8 6dcd296 + # Author: Krzysztof Filipek + # Date: Wed Jul 2 10:55:35 2025 +0200 + # Merge pull request #1397 from lplewa/memspace_experiment + # move memspace api to experimental + set(UMF_TAG v0.12.0-dev4) endif() message(STATUS "Will fetch Unified Memory Framework from ${UMF_REPO}") diff --git a/source/common/umf_helpers.hpp b/source/common/umf_helpers.hpp index c7eee2bd5b..4a97ba95f9 100644 --- a/source/common/umf_helpers.hpp +++ b/source/common/umf_helpers.hpp @@ -76,11 +76,16 @@ using provider_unique_handle_t = return UMF_RESULT_ERROR_NOT_SUPPORTED; \ } -DEFINE_CHECK_OP(get_ipc_handle_size) -DEFINE_CHECK_OP(get_ipc_handle) -DEFINE_CHECK_OP(put_ipc_handle) -DEFINE_CHECK_OP(open_ipc_handle) -DEFINE_CHECK_OP(close_ipc_handle) +DEFINE_CHECK_OP(ext_purge_lazy) +DEFINE_CHECK_OP(ext_purge_force) +DEFINE_CHECK_OP(ext_allocation_merge) +DEFINE_CHECK_OP(ext_allocation_split) +DEFINE_CHECK_OP(ext_get_ipc_handle_size) +DEFINE_CHECK_OP(ext_get_ipc_handle) +DEFINE_CHECK_OP(ext_put_ipc_handle) +DEFINE_CHECK_OP(ext_open_ipc_handle) +DEFINE_CHECK_OP(ext_close_ipc_handle) +DEFINE_CHECK_OP(ext_ctl) #define UMF_ASSIGN_OP(ops, type, func, default_return) \ ops.func = [](void *obj, auto... args) { \ @@ -179,23 +184,27 @@ auto memoryProviderMakeUnique(Args &&...args) { reinterpret_cast(*obj), *reinterpret_cast(const_cast(params))); }; - ops.finalize = [](void *obj) { delete reinterpret_cast(obj); }; + ops.finalize = [](void *obj) -> umf_result_t { + delete reinterpret_cast(obj); + return UMF_RESULT_SUCCESS; + }; UMF_ASSIGN_OP(ops, T, alloc, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_NORETURN(ops, T, get_last_native_error); + UMF_ASSIGN_OP(ops, T, get_last_native_error, UMF_RESULT_ERROR_UNKNOWN); UMF_ASSIGN_OP(ops, T, get_recommended_page_size, UMF_RESULT_ERROR_UNKNOWN); UMF_ASSIGN_OP(ops, T, get_min_page_size, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP(ops, T, get_name, ""); + UMF_ASSIGN_OP(ops, T, get_name, UMF_RESULT_ERROR_UNKNOWN); UMF_ASSIGN_OP(ops, T, free, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP(ops.ext, T, purge_lazy, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP(ops.ext, T, purge_force, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP(ops.ext, T, allocation_merge, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP(ops.ext, T, allocation_split, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_OPT(ops.ipc, T, get_ipc_handle_size, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_OPT(ops.ipc, T, get_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_OPT(ops.ipc, T, put_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_OPT(ops.ipc, T, open_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); - UMF_ASSIGN_OP_OPT(ops.ipc, T, close_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_purge_lazy, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_purge_force, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_allocation_merge, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_allocation_split, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_get_ipc_handle_size, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_get_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_put_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_open_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_close_ipc_handle, UMF_RESULT_ERROR_UNKNOWN); + UMF_ASSIGN_OP_OPT(ops, T, ext_ctl, UMF_RESULT_ERROR_UNKNOWN); umf_memory_provider_handle_t hProvider = nullptr; auto ret = umfMemoryProviderCreate(&ops, &argsTuple, &hProvider); @@ -287,8 +296,9 @@ inline ur_result_t umf2urResult(umf_result_t umfResult) { case UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY: return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY; case UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC: { - auto hProvider = umfGetLastFailedMemoryProvider(); - if (hProvider == nullptr) { + umf_memory_provider_handle_t hProvider = nullptr; + auto umfRet = umfGetLastFailedMemoryProvider(&hProvider); + if (umfRet != UMF_RESULT_SUCCESS || hProvider == nullptr) { return UR_RESULT_ERROR_UNKNOWN; } @@ -300,7 +310,13 @@ inline ur_result_t umf2urResult(umf_result_t umfResult) { UR_LOG(ERR, "UMF failed with: {}", Msg); } - return getProviderNativeError(umfMemoryProviderGetName(hProvider), Err); + const char *Name = nullptr; + umfRet = umfMemoryProviderGetName(hProvider, &Name); + if (umfRet != UMF_RESULT_SUCCESS) { + return UR_RESULT_ERROR_UNKNOWN; + } + + return getProviderNativeError(Name, Err); } case UMF_RESULT_ERROR_INVALID_ARGUMENT: return UR_RESULT_ERROR_INVALID_ARGUMENT; diff --git a/source/common/umf_pools/disjoint_pool_config_parser.cpp b/source/common/umf_pools/disjoint_pool_config_parser.cpp index 42c894b412..d2b12e576b 100644 --- a/source/common/umf_pools/disjoint_pool_config_parser.cpp +++ b/source/common/umf_pools/disjoint_pool_config_parser.cpp @@ -208,9 +208,11 @@ DisjointPoolAllConfigs parseDisjointPoolConfig(const std::string &config, AllConfigs.EnableBuffers = EnableBuffers; + umf_disjoint_pool_shared_limits_handle_t limits; + umfDisjointPoolSharedLimitsCreate(MaxSize, &limits); + AllConfigs.limits = std::shared_ptr( - umfDisjointPoolSharedLimitsCreate(MaxSize), - umfDisjointPoolSharedLimitsDestroy); + std::move(limits), umfDisjointPoolSharedLimitsDestroy); for (auto &Config : AllConfigs.Configs) { Config.SharedLimits = AllConfigs.limits.get(); diff --git a/source/loader/layers/sanitizer/msan/msan_ddi.cpp b/source/loader/layers/sanitizer/msan/msan_ddi.cpp index dc5e5ab770..439afeae99 100644 --- a/source/loader/layers/sanitizer/msan/msan_ddi.cpp +++ b/source/loader/layers/sanitizer/msan/msan_ddi.cpp @@ -51,6 +51,48 @@ ur_result_t setupContext(ur_context_handle_t Context, uint32_t numDevices, return UR_RESULT_SUCCESS; } +ur_result_t urEnqueueUSMFill2DFallback(ur_queue_handle_t hQueue, void *pMem, + size_t pitch, size_t patternSize, + const void *pPattern, size_t width, + size_t height, + uint32_t numEventsInWaitList, + const ur_event_handle_t *phEventWaitList, + ur_event_handle_t *phEvent) { + ur_result_t Result = getContext()->urDdiTable.Enqueue.pfnUSMFill2D( + hQueue, pMem, pitch, patternSize, pPattern, width, height, + numEventsInWaitList, phEventWaitList, phEvent); + if (Result == UR_RESULT_SUCCESS || + Result != UR_RESULT_ERROR_UNSUPPORTED_FEATURE) { + return Result; + } + + // fallback code + auto pfnUSMFill = getContext()->urDdiTable.Enqueue.pfnUSMFill; + + std::vector WaitEvents(numEventsInWaitList); + + for (size_t HeightIndex = 0; HeightIndex < height; HeightIndex++) { + ur_event_handle_t Event = nullptr; + + UR_CALL(pfnUSMFill(hQueue, (void *)((char *)pMem + pitch * HeightIndex), + patternSize, pPattern, width, WaitEvents.size(), + WaitEvents.data(), &Event)); + + WaitEvents.push_back(Event); + } + + if (phEvent) { + UR_CALL(getContext()->urDdiTable.Enqueue.pfnEventsWait( + hQueue, WaitEvents.size(), WaitEvents.data(), phEvent)); + } + + for (const auto Event : WaitEvents) { + UR_CALL(getContext()->urDdiTable.Event.pfnRelease(Event)); + } + + return UR_RESULT_SUCCESS; +} + } // namespace /////////////////////////////////////////////////////////////////////////////// @@ -1726,11 +1768,6 @@ ur_result_t urEnqueueUSMMemcpy2D( { auto pfnUSMMemcpy = getContext()->urDdiTable.Enqueue.pfnUSMMemcpy; - std::vector WaitEvents(numEventsInWaitList); - for (uint32_t i = 0; i < numEventsInWaitList; i++) { - WaitEvents[i] = phEventWaitList[i]; - } - for (size_t HeightIndex = 0; HeightIndex < height; HeightIndex++) { ur_event_handle_t Event = nullptr; const auto DstOrigin = @@ -1742,8 +1779,8 @@ ur_result_t urEnqueueUSMMemcpy2D( width - 1) + MSAN_ORIGIN_GRANULARITY; pfnUSMMemcpy(hQueue, false, (void *)DstOrigin, (void *)SrcOrigin, - SrcOriginEnd - SrcOrigin, WaitEvents.size(), - WaitEvents.data(), &Event); + SrcOriginEnd - SrcOrigin, numEventsInWaitList, + phEventWaitList, &Event); Events.push_back(Event); } } @@ -1756,9 +1793,9 @@ ur_result_t urEnqueueUSMMemcpy2D( const auto DstShadow = DstDI->Shadow->MemToShadow((uptr)pDst); const char Pattern = 0; ur_event_handle_t Event = nullptr; - UR_CALL(getContext()->urDdiTable.Enqueue.pfnUSMFill2D( - hQueue, (void *)DstShadow, dstPitch, 1, &Pattern, width, height, 0, - nullptr, &Event)); + UR_CALL(urEnqueueUSMFill2DFallback(hQueue, (void *)DstShadow, dstPitch, 1, + &Pattern, width, height, 0, nullptr, + &Event)); Events.push_back(Event); } @@ -1767,7 +1804,7 @@ ur_result_t urEnqueueUSMMemcpy2D( hQueue, Events.size(), Events.data(), phEvent)); } - for (const auto &E : Events) + for (const auto E : Events) UR_CALL(getContext()->urDdiTable.Event.pfnRelease(E)); return UR_RESULT_SUCCESS; diff --git a/test/adapters/level_zero/ipc.cpp b/test/adapters/level_zero/ipc.cpp index f1896a7f40..63f70e7ec2 100644 --- a/test/adapters/level_zero/ipc.cpp +++ b/test/adapters/level_zero/ipc.cpp @@ -32,7 +32,9 @@ TEST_P(urL0IpcTest, SuccessHostL0Ipc) { ASSERT_SUCCESS(urUSMHostAlloc(context, nullptr, nullptr, allocSize, &ptr)); ASSERT_NE(ptr, nullptr); - umf_memory_pool_handle_t umfPool = umfPoolByPtr(ptr); + umf_memory_pool_handle_t umfPool = nullptr; + auto umfRet = umfPoolByPtr(ptr, &umfPool); + ASSERT_UMF_SUCCESS(umfRet); ASSERT_NE(umfPool, nullptr); umf_memory_provider_handle_t umfProvider = nullptr;