diff --git a/source/adapters/cuda/usm.cpp b/source/adapters/cuda/usm.cpp index 8a6ac41b08..863d90cd79 100644 --- a/source/adapters/cuda/usm.cpp +++ b/source/adapters/cuda/usm.cpp @@ -403,29 +403,32 @@ ur_usm_pool_handle_t_::ur_usm_pool_handle_t_(ur_context_handle_t Context, umf::memoryProviderMakeUnique(Context, nullptr) .second; + auto UmfHostParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Host]); HostMemPool = - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Host]) + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfHostParamsHandle.get()) .second; for (const auto &Device : Context->getDevices()) { MemProvider = umf::memoryProviderMakeUnique(Context, Device) .second; - DeviceMemPool = umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Device]) - .second; + auto UmfDeviceParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Device]); + DeviceMemPool = + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfDeviceParamsHandle.get()) + .second; MemProvider = umf::memoryProviderMakeUnique(Context, Device) .second; - SharedMemPool = umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Shared]) - .second; + auto UmfSharedParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Shared]); + SharedMemPool = + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfSharedParamsHandle.get()) + .second; Context->addPool(this); } } @@ -452,6 +455,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolCreate( new ur_usm_pool_handle_t_(Context, PoolDesc)); } catch (const UsmAllocationException &Ex) { return Ex.getError(); + } catch (umf_result_t e) { + return umf::umf2urResult(e); + } catch (...) { + return UR_RESULT_ERROR_UNKNOWN; } return UR_RESULT_SUCCESS; #else diff --git a/source/adapters/hip/usm.cpp b/source/adapters/hip/usm.cpp index 5e28f3592d..90f152daf0 100644 --- a/source/adapters/hip/usm.cpp +++ b/source/adapters/hip/usm.cpp @@ -345,30 +345,33 @@ ur_usm_pool_handle_t_::ur_usm_pool_handle_t_(ur_context_handle_t Context, umf::memoryProviderMakeUnique(Context, nullptr) .second; + auto UmfHostParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Host]); HostMemPool = - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Host]) + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfHostParamsHandle.get()) .second; for (const auto &Device : Context->getDevices()) { MemProvider = umf::memoryProviderMakeUnique(Context, Device) .second; - DeviceMemPool = umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Device]) - .second; + auto UmfDeviceParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Device]); + DeviceMemPool = + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfDeviceParamsHandle.get()) + .second; MemProvider = umf::memoryProviderMakeUnique(Context, Device) .second; - SharedMemPool = umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Shared]) - .second; + auto UmfSharedParamsHandle = getUmfParamsHandle( + DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Shared]); + SharedMemPool = + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfSharedParamsHandle.get()) + .second; Context->addPool(this); } } @@ -395,6 +398,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolCreate( new ur_usm_pool_handle_t_(Context, PoolDesc)); } catch (const UsmAllocationException &Ex) { return Ex.getError(); + } catch (umf_result_t e) { + return umf::umf2urResult(e); + } catch (...) { + return UR_RESULT_ERROR_UNKNOWN; } return UR_RESULT_SUCCESS; #else diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index fd13dc35df..6603cdd6f8 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -48,6 +48,8 @@ ur_result_t urContextCreate( } } catch (const std::bad_alloc &) { return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY; + } catch (umf_result_t e) { + return umf::umf2urResult(e); } catch (...) { return UR_RESULT_ERROR_UNKNOWN; } @@ -196,36 +198,41 @@ ur_result_t ur_context_handle_t_::initialize() { auto MemProvider = umf::memoryProviderMakeUnique( reinterpret_cast(this), Device) .second; + auto UmfDeviceParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Device]); DeviceMemPools.emplace( std::piecewise_construct, std::make_tuple(Device->ZeDevice), - std::make_tuple(umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &DisjointPoolConfigInstance - .Configs[usm::DisjointPoolMemType::Device]) + std::make_tuple(umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), + std::move(MemProvider), + UmfDeviceParamsHandle.get()) .second)); MemProvider = umf::memoryProviderMakeUnique( reinterpret_cast(this), Device) .second; + + auto UmfSharedParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Shared]); SharedMemPools.emplace( std::piecewise_construct, std::make_tuple(Device->ZeDevice), - std::make_tuple(umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &DisjointPoolConfigInstance - .Configs[usm::DisjointPoolMemType::Shared]) + std::make_tuple(umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), + std::move(MemProvider), + UmfSharedParamsHandle.get()) .second)); MemProvider = umf::memoryProviderMakeUnique( reinterpret_cast(this), Device) .second; + + auto UmfSharedROParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance + .Configs[usm::DisjointPoolMemType::SharedReadOnly]); SharedReadOnlyMemPools.emplace( std::piecewise_construct, std::make_tuple(Device->ZeDevice), - std::make_tuple( - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &DisjointPoolConfigInstance - .Configs[usm::DisjointPoolMemType::SharedReadOnly]) - .second)); + std::make_tuple(umf::poolMakeUniqueFromOps( + umfDisjointPoolOps(), std::move(MemProvider), + UmfSharedROParamsHandle.get()) + .second)); MemProvider = umf::memoryProviderMakeUnique( reinterpret_cast(this), Device) @@ -273,10 +280,11 @@ ur_result_t ur_context_handle_t_::initialize() { auto MemProvider = umf::memoryProviderMakeUnique( reinterpret_cast(this), nullptr) .second; + auto UmfHostParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Host]); HostMemPool = - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Host]) + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfHostParamsHandle.get()) .second; MemProvider = umf::memoryProviderMakeUnique( diff --git a/source/adapters/level_zero/usm.cpp b/source/adapters/level_zero/usm.cpp index 28bdf233e8..55cff6b209 100644 --- a/source/adapters/level_zero/usm.cpp +++ b/source/adapters/level_zero/usm.cpp @@ -709,6 +709,10 @@ ur_result_t urUSMPoolCreate( } catch (const UsmAllocationException &Ex) { return Ex.getError(); + } catch (umf_result_t e) { + return umf2urResult(e); + } catch (...) { + return UR_RESULT_ERROR_UNKNOWN; } return UR_RESULT_SUCCESS; } @@ -1051,46 +1055,50 @@ ur_usm_pool_handle_t_::ur_usm_pool_handle_t_(ur_context_handle_t Context, umf::memoryProviderMakeUnique(Context, nullptr) .second; + auto UmfHostParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Host]); HostMemPool = - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs.Configs[usm::DisjointPoolMemType::Host]) + umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(MemProvider), + UmfHostParamsHandle.get()) .second; for (auto device : Context->Devices) { MemProvider = umf::memoryProviderMakeUnique(Context, device) .second; + auto UmfDeviceParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Device]); DeviceMemPools.emplace( std::piecewise_construct, std::make_tuple(device), - std::make_tuple(umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Device]) + std::make_tuple(umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), + std::move(MemProvider), + UmfDeviceParamsHandle.get()) .second)); MemProvider = umf::memoryProviderMakeUnique(Context, device) .second; + auto UmfSharedParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance.Configs[usm::DisjointPoolMemType::Shared]); SharedMemPools.emplace( std::piecewise_construct, std::make_tuple(device), - std::make_tuple(umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::Shared]) + std::make_tuple(umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), + std::move(MemProvider), + UmfSharedParamsHandle.get()) .second)); MemProvider = umf::memoryProviderMakeUnique( Context, device) .second; + auto UmfSharedROParamsHandle = getUmfParamsHandle( + DisjointPoolConfigInstance + .Configs[usm::DisjointPoolMemType::SharedReadOnly]); SharedReadOnlyMemPools.emplace( std::piecewise_construct, std::make_tuple(device), - std::make_tuple( - umf::poolMakeUniqueFromOps( - umfDisjointPoolOps(), std::move(MemProvider), - &this->DisjointPoolConfigs - .Configs[usm::DisjointPoolMemType::SharedReadOnly]) - .second)); + std::make_tuple(umf::poolMakeUniqueFromOps( + umfDisjointPoolOps(), std::move(MemProvider), + UmfSharedROParamsHandle.get()) + .second)); } } diff --git a/source/adapters/level_zero/v2/usm.cpp b/source/adapters/level_zero/v2/usm.cpp index f31a2b5202..f7396e282f 100644 --- a/source/adapters/level_zero/v2/usm.cpp +++ b/source/adapters/level_zero/v2/usm.cpp @@ -82,31 +82,55 @@ descToDisjoinPoolMemType(const usm::pool_descriptor &desc) { } static umf::pool_unique_handle_t -makePool(umf_disjoint_pool_params_t *poolParams, +makePool(usm::umf_disjoint_pool_config_t *poolParams, usm::pool_descriptor poolDescriptor) { - level_zero_memory_provider_params_t params = {}; - params.level_zero_context_handle = poolDescriptor.hContext->getZeHandle(); - params.level_zero_device_handle = + umf_level_zero_memory_provider_params_handle_t params = NULL; + umf_result_t umf_ret = umfLevelZeroMemoryProviderParamsCreate(¶ms); + if (umf_ret != UMF_RESULT_SUCCESS) { + throw umf::umf2urResult(umf_ret); + } + + umf_ret = umfLevelZeroMemoryProviderParamsSetContext( + params, poolDescriptor.hContext->getZeHandle()); + if (umf_ret != UMF_RESULT_SUCCESS) { + throw umf::umf2urResult(umf_ret); + }; + + ze_device_handle_t level_zero_device_handle = poolDescriptor.hDevice ? poolDescriptor.hDevice->ZeDevice : nullptr; - params.memory_type = urToUmfMemoryType(poolDescriptor.type); + + umf_ret = umfLevelZeroMemoryProviderParamsSetDevice(params, + level_zero_device_handle); + if (umf_ret != UMF_RESULT_SUCCESS) { + throw umf::umf2urResult(umf_ret); + } + + umf_ret = umfLevelZeroMemoryProviderParamsSetMemoryType( + params, urToUmfMemoryType(poolDescriptor.type)); + if (umf_ret != UMF_RESULT_SUCCESS) { + throw umf::umf2urResult(umf_ret); + } std::vector residentZeHandles; if (poolDescriptor.type == UR_USM_TYPE_DEVICE) { - assert(params.level_zero_device_handle); + assert(level_zero_device_handle); auto residentHandles = poolDescriptor.hContext->getP2PDevices(poolDescriptor.hDevice); - residentZeHandles.push_back(params.level_zero_device_handle); + residentZeHandles.push_back(level_zero_device_handle); for (auto &device : residentHandles) { residentZeHandles.push_back(device->ZeDevice); } - params.resident_device_handles = residentZeHandles.data(); - params.resident_device_count = residentZeHandles.size(); + umf_ret = umfLevelZeroMemoryProviderParamsSetResidentDevices( + params, residentZeHandles.data(), residentZeHandles.size()); + if (umf_ret != UMF_RESULT_SUCCESS) { + throw umf::umf2urResult(umf_ret); + } } auto [ret, provider] = - umf::providerMakeUniqueFromOps(umfLevelZeroMemoryProviderOps(), ¶ms); + umf::providerMakeUniqueFromOps(umfLevelZeroMemoryProviderOps(), params); if (ret != UMF_RESULT_SUCCESS) { throw umf::umf2urResult(ret); } @@ -118,9 +142,11 @@ makePool(umf_disjoint_pool_params_t *poolParams, throw umf::umf2urResult(ret); return std::move(poolHandle); } else { + auto umfParams = getUmfParamsHandle(*poolParams); + auto [ret, poolHandle] = umf::poolMakeUniqueFromOps(umfDisjointPoolOps(), std::move(provider), - static_cast(poolParams)); + static_cast(umfParams.get())); if (ret != UMF_RESULT_SUCCESS) throw umf::umf2urResult(ret); return std::move(poolHandle); @@ -199,10 +225,13 @@ ur_result_t urUSMPoolCreate( pPoolDesc, ///< [in] pointer to USM pool descriptor. Can be chained with ///< ::ur_usm_pool_limits_desc_t ur_usm_pool_handle_t *hPool ///< [out] pointer to USM memory pool -) { - + ) try { *hPool = new ur_usm_pool_handle_t_(hContext, pPoolDesc); return UR_RESULT_SUCCESS; +} catch (umf_result_t e) { + return umf::umf2urResult(e); +} catch (...) { + return exceptionToResult(std::current_exception()); } ur_result_t diff --git a/source/common/CMakeLists.txt b/source/common/CMakeLists.txt index e24d987567..2a181638ba 100644 --- a/source/common/CMakeLists.txt +++ b/source/common/CMakeLists.txt @@ -32,11 +32,10 @@ if (NOT DEFINED UMF_REPO) endif() if (NOT DEFINED UMF_TAG) - # special branch with cherry-picks for incoming pulldown - # contains UMF PRs: #866, #924, and #930 - # branch was based on commit: 3bae087c9a8c0cbed5bde40f0d5a2 - # umf-fixes-nov-pulldown: 25.11.2024: Disable libudev in hwloc builds - set(UMF_TAG a7b6152b7b095c88ddf34bc7d442eb4c2b3f74d6) + # tag v0.10.0 + # Tagger: Łukasz Stolarczuk + # Date: Mon Dec 9 17:01:43 2024 +0100 + set(UMF_TAG v0.10.0) endif() message(STATUS "Will fetch Unified Memory Framework from ${UMF_REPO}") diff --git a/source/common/umf_pools/disjoint_pool_config_parser.cpp b/source/common/umf_pools/disjoint_pool_config_parser.cpp index 0e82072ae2..5a5329ff17 100644 --- a/source/common/umf_pools/disjoint_pool_config_parser.cpp +++ b/source/common/umf_pools/disjoint_pool_config_parser.cpp @@ -25,9 +25,13 @@ constexpr auto operator""_GB(unsigned long long x) -> size_t { return x * 1024 * 1024 * 1024; } +umf_disjoint_pool_config_t::umf_disjoint_pool_config_t() + : SlabMinSize(0), MaxPoolableSize(0), Capacity(0), + MinBucketSize(UMF_DISJOINT_POOL_MIN_BUCKET_DEFAULT_SIZE), PoolTrace(0), + SharedLimits(nullptr), Name("disjoint_pool") {} + DisjointPoolAllConfigs::DisjointPoolAllConfigs(int trace) { for (auto &Config : Configs) { - Config = umfDisjointPoolParamsDefault(); Config.PoolTrace = trace; } diff --git a/source/common/umf_pools/disjoint_pool_config_parser.hpp b/source/common/umf_pools/disjoint_pool_config_parser.hpp index 2efb7ddfdc..e3ee1f7b54 100644 --- a/source/common/umf_pools/disjoint_pool_config_parser.hpp +++ b/source/common/umf_pools/disjoint_pool_config_parser.hpp @@ -18,12 +18,28 @@ namespace usm { enum DisjointPoolMemType { Host, Device, Shared, SharedReadOnly, All }; +typedef struct umf_disjoint_pool_config_t { + umf_disjoint_pool_config_t(); + + size_t SlabMinSize; + size_t MaxPoolableSize; + size_t Capacity; + size_t MinBucketSize; + int PoolTrace; + umf_disjoint_pool_shared_limits_t *SharedLimits; + const char *Name; +} umf_disjoint_pool_config_t; + +using umfDisjointPoolParamsHandle = + std::unique_ptr; + // Stores configuration for all instances of USM allocator class DisjointPoolAllConfigs { public: size_t EnableBuffers = 1; std::shared_ptr limits; - umf_disjoint_pool_params_t Configs[DisjointPoolMemType::All]; + umf_disjoint_pool_config_t Configs[DisjointPoolMemType::All]; DisjointPoolAllConfigs(int trace = 0); }; @@ -54,6 +70,32 @@ class DisjointPoolAllConfigs { // "1;32M;host:1M,4,64K;device:1M,4,64K;shared:0,0,2M" DisjointPoolAllConfigs parseDisjointPoolConfig(const std::string &config, int trace = 1); + +static inline void UMF_CALL_THROWS(umf_result_t res) { + if (res != UMF_RESULT_SUCCESS) { + throw res; + } +} + +static inline umfDisjointPoolParamsHandle +getUmfParamsHandle(umf_disjoint_pool_config_t &config) { + umf_disjoint_pool_params_handle_t cHandle; + UMF_CALL_THROWS(umfDisjointPoolParamsCreate(&cHandle)); + + umfDisjointPoolParamsHandle handle(cHandle, &umfDisjointPoolParamsDestroy); + UMF_CALL_THROWS( + umfDisjointPoolParamsSetSlabMinSize(cHandle, config.SlabMinSize)); + UMF_CALL_THROWS(umfDisjointPoolParamsSetMaxPoolableSize( + cHandle, config.MaxPoolableSize)); + UMF_CALL_THROWS(umfDisjointPoolParamsSetCapacity(cHandle, config.Capacity)); + UMF_CALL_THROWS( + umfDisjointPoolParamsSetMinBucketSize(cHandle, config.MinBucketSize)); + UMF_CALL_THROWS( + umfDisjointPoolParamsSetSharedLimits(cHandle, config.SharedLimits)); + UMF_CALL_THROWS(umfDisjointPoolParamsSetName(cHandle, config.Name)); + UMF_CALL_THROWS(umfDisjointPoolParamsSetTrace(cHandle, config.PoolTrace)); + return handle; +} } // namespace usm #endif