diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.h index df6dd7364..b20fb40d5 100644 --- a/include/umf/providers/provider_level_zero.h +++ b/include/umf/providers/provider_level_zero.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -83,6 +83,14 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy( umf_level_zero_memory_provider_params_handle_t hParams, umf_level_zero_memory_provider_free_policy_t policy); +/// @brief Set the device ordinal in the parameters struct. +/// @param hParams handle to the parameters of the Level Zero Memory Provider. +/// @param deviceOrdinal device ordinal. +/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure. +umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal( + umf_level_zero_memory_provider_params_handle_t hParams, + uint32_t deviceOrdinal); + umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void); #ifdef __cplusplus diff --git a/src/libumf.def b/src/libumf.def index 090b3a86f..f93553e90 100644 --- a/src/libumf.def +++ b/src/libumf.def @@ -122,3 +122,4 @@ EXPORTS umfFixedMemoryProviderParamsCreate umfFixedMemoryProviderParamsDestroy umfLevelZeroMemoryProviderParamsSetFreePolicy + umfLevelZeroMemoryProviderParamsSetDeviceOrdinal diff --git a/src/libumf.map b/src/libumf.map index c33bb7c10..7a7ac5ad3 100644 --- a/src/libumf.map +++ b/src/libumf.map @@ -120,4 +120,5 @@ UMF_0.11 { umfFixedMemoryProviderParamsCreate; umfFixedMemoryProviderParamsDestroy; umfLevelZeroMemoryProviderParamsSetFreePolicy; + umfLevelZeroMemoryProviderParamsSetDeviceOrdinal; } UMF_0.10; diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c index eaea8abd9..8c8beda31 100644 --- a/src/provider/provider_level_zero.c +++ b/src/provider/provider_level_zero.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -83,6 +83,14 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy( return UMF_RESULT_ERROR_NOT_SUPPORTED; } +umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal( + umf_level_zero_memory_provider_params_handle_t hParams, + uint32_t deviceOrdinal) { + (void)hParams; + (void)deviceOrdinal; + return UMF_RESULT_ERROR_NOT_SUPPORTED; +} + umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) { // not supported LOG_ERR("L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is " @@ -118,6 +126,8 @@ typedef struct umf_level_zero_memory_provider_params_t { umf_level_zero_memory_provider_free_policy_t freePolicy; ///< Memory free policy + + uint32_t device_ordinal; } umf_level_zero_memory_provider_params_t; typedef struct ze_memory_provider_t { @@ -131,6 +141,10 @@ typedef struct ze_memory_provider_t { ze_device_properties_t device_properties; ze_driver_memory_free_policy_ext_flags_t freePolicyFlags; + + size_t min_page_size; + + uint32_t device_ordinal; } ze_memory_provider_t; typedef struct ze_ops_t { @@ -159,6 +173,9 @@ typedef struct ze_ops_t { ze_device_properties_t *); ze_result_t (*zeMemFreeExt)(ze_context_handle_t, ze_memory_free_ext_desc_t *, void *); + ze_result_t (*zeMemGetAllocProperties)(ze_context_handle_t, const void *, + ze_memory_allocation_properties_t *, + ze_device_handle_t *); } ze_ops_t; static ze_ops_t g_ze_ops; @@ -214,13 +231,15 @@ static void init_ze_global_state(void) { utils_get_symbol_addr(0, "zeDeviceGetProperties", lib_name); *(void **)&g_ze_ops.zeMemFreeExt = utils_get_symbol_addr(0, "zeMemFreeExt", lib_name); + *(void **)&g_ze_ops.zeMemGetAllocProperties = + utils_get_symbol_addr(0, "zeMemGetAllocProperties", lib_name); if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice || !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree || !g_ze_ops.zeMemGetIpcHandle || !g_ze_ops.zeMemOpenIpcHandle || !g_ze_ops.zeMemCloseIpcHandle || !g_ze_ops.zeContextMakeMemoryResident || - !g_ze_ops.zeDeviceGetProperties) { + !g_ze_ops.zeDeviceGetProperties || !g_ze_ops.zeMemGetAllocProperties) { // g_ze_ops.zeMemPutIpcHandle can be NULL because it was introduced // starting from Level Zero 1.6 LOG_ERR("Required Level Zero symbols not found."); @@ -232,7 +251,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsCreate( umf_level_zero_memory_provider_params_handle_t *hParams) { libumfInit(); if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -250,6 +269,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsCreate( params->resident_device_handles = NULL; params->resident_device_count = 0; params->freePolicy = UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT; + params->device_ordinal = 0; *hParams = params; @@ -267,12 +287,12 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetContext( umf_level_zero_memory_provider_params_handle_t hParams, ze_context_handle_t hContext) { if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } if (!hContext) { - LOG_ERR("Level zero context handle is NULL"); + LOG_ERR("Level Zero context handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -285,7 +305,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDevice( umf_level_zero_memory_provider_params_handle_t hParams, ze_device_handle_t hDevice) { if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -298,7 +318,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType( umf_level_zero_memory_provider_params_handle_t hParams, umf_usm_memory_type_t memoryType) { if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -307,11 +327,23 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType( return UMF_RESULT_SUCCESS; } +umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal( + umf_level_zero_memory_provider_params_handle_t hParams, + uint32_t deviceOrdinal) { + if (!hParams) { + LOG_ERR("Level Zero memory provider params handle is NULL"); + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + hParams->device_ordinal = deviceOrdinal; + + return UMF_RESULT_SUCCESS; +} + umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices( umf_level_zero_memory_provider_params_handle_t hParams, ze_device_handle_t *hDevices, uint32_t deviceCount) { if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -330,7 +362,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy( umf_level_zero_memory_provider_params_handle_t hParams, umf_level_zero_memory_provider_free_policy_t policy) { if (!hParams) { - LOG_ERR("Level zero memory provider params handle is NULL"); + LOG_ERR("Level Zero memory provider params handle is NULL"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -351,100 +383,6 @@ umfFreePolicyToZePolicy(umf_level_zero_memory_provider_free_policy_t policy) { return 0; } } - -static umf_result_t ze_memory_provider_initialize(void *params, - void **provider) { - if (params == NULL) { - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - umf_level_zero_memory_provider_params_handle_t ze_params = - (umf_level_zero_memory_provider_params_handle_t)params; - - if (!ze_params->level_zero_context_handle) { - LOG_ERR("Level Zero context handle is NULL"); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - if ((ze_params->memory_type == UMF_MEMORY_TYPE_HOST) == - (ze_params->level_zero_device_handle != NULL)) { - LOG_ERR("Level Zero device handle is NULL"); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - if ((bool)ze_params->resident_device_count && - (ze_params->resident_device_handles == NULL)) { - LOG_ERR("Resident devices handles array is NULL, but device_count is " - "not zero"); - return UMF_RESULT_ERROR_INVALID_ARGUMENT; - } - - utils_init_once(&ze_is_initialized, init_ze_global_state); - if (Init_ze_global_state_failed) { - LOG_ERR("Loading Level Zero symbols failed"); - return UMF_RESULT_ERROR_UNKNOWN; - } - - ze_memory_provider_t *ze_provider = - umf_ba_global_alloc(sizeof(ze_memory_provider_t)); - if (!ze_provider) { - LOG_ERR("Cannot allocate memory for Level Zero Memory Provider"); - return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; - } - - ze_provider->context = ze_params->level_zero_context_handle; - ze_provider->device = ze_params->level_zero_device_handle; - ze_provider->memory_type = (ze_memory_type_t)ze_params->memory_type; - ze_provider->freePolicyFlags = - umfFreePolicyToZePolicy(ze_params->freePolicy); - - memset(&ze_provider->device_properties, 0, - sizeof(ze_provider->device_properties)); - ze_provider->device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES; - - if (ze_provider->device) { - umf_result_t ret = ze2umf_result(g_ze_ops.zeDeviceGetProperties( - ze_provider->device, &ze_provider->device_properties)); - - if (ret != UMF_RESULT_SUCCESS) { - LOG_ERR("Cannot get device properties"); - umf_ba_global_free(ze_provider); - return ret; - } - } - - if (ze_params->resident_device_count) { - ze_provider->resident_device_handles = umf_ba_global_alloc( - sizeof(ze_device_handle_t) * ze_params->resident_device_count); - if (!ze_provider->resident_device_handles) { - LOG_ERR("Cannot allocate memory for resident devices"); - umf_ba_global_free(ze_provider); - return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; - } - - ze_provider->resident_device_count = ze_params->resident_device_count; - - for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) { - ze_provider->resident_device_handles[i] = - ze_params->resident_device_handles[i]; - } - } else { - ze_provider->resident_device_handles = NULL; - ze_provider->resident_device_count = 0; - } - - *provider = ze_provider; - - return UMF_RESULT_SUCCESS; -} - -static void ze_memory_provider_finalize(void *provider) { - ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider; - umf_ba_global_free(ze_provider->resident_device_handles); - - umf_ba_global_free(provider); -} - static bool use_relaxed_allocation(ze_memory_provider_t *ze_provider, size_t size) { assert(ze_provider); @@ -482,8 +420,7 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size, ? &relaxed_device_allocation_desc : NULL, .flags = 0, - .ordinal = 0 // TODO - }; + .ordinal = ze_provider->device_ordinal}; ze_result = g_ze_ops.zeMemAllocDevice(ze_provider->context, &dev_desc, size, alignment, ze_provider->device, resultPtr); @@ -500,8 +437,7 @@ static umf_result_t ze_memory_provider_alloc(void *provider, size_t size, ? &relaxed_device_allocation_desc : NULL, .flags = 0, - .ordinal = 0 // TODO - }; + .ordinal = ze_provider->device_ordinal}; ze_result = g_ze_ops.zeMemAllocShared(ze_provider->context, &dev_desc, &host_desc, size, alignment, ze_provider->device, resultPtr); @@ -553,6 +489,133 @@ static umf_result_t ze_memory_provider_free(void *provider, void *ptr, g_ze_ops.zeMemFreeExt(ze_provider->context, &desc, ptr)); } +static umf_result_t query_min_page_size(ze_memory_provider_t *ze_provider, + size_t *min_page_size) { + assert(min_page_size); + + LOG_DEBUG("Querying minimum page size"); + + void *ptr; + umf_result_t result = ze_memory_provider_alloc(ze_provider, 1, 0, &ptr); + if (result != UMF_RESULT_SUCCESS) { + return result; + } + + ze_memory_allocation_properties_t properties = { + .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES}; + ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties( + ze_provider->context, ptr, &properties, NULL); + + *min_page_size = properties.pageSize; + + ze_memory_provider_free(ze_provider, ptr, 1); + + return ze2umf_result(ze_result); +} + +static void ze_memory_provider_finalize(void *provider) { + ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider; + umf_ba_global_free(ze_provider->resident_device_handles); + + umf_ba_global_free(provider); +} + +static umf_result_t ze_memory_provider_initialize(void *params, + void **provider) { + if (params == NULL) { + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + umf_level_zero_memory_provider_params_handle_t ze_params = + (umf_level_zero_memory_provider_params_handle_t)params; + + if (!ze_params->level_zero_context_handle) { + LOG_ERR("Level Zero context handle is NULL"); + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + if ((ze_params->memory_type == UMF_MEMORY_TYPE_HOST) == + (ze_params->level_zero_device_handle != NULL)) { + LOG_ERR("Level Zero device handle should be set only for device and " + "shared memory types"); + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + if ((bool)ze_params->resident_device_count && + (ze_params->resident_device_handles == NULL)) { + LOG_ERR("Resident devices handles array is NULL, but device_count is " + "not zero"); + return UMF_RESULT_ERROR_INVALID_ARGUMENT; + } + + utils_init_once(&ze_is_initialized, init_ze_global_state); + if (Init_ze_global_state_failed) { + LOG_ERR("Loading Level Zero symbols failed"); + return UMF_RESULT_ERROR_UNKNOWN; + } + + ze_memory_provider_t *ze_provider = + umf_ba_global_alloc(sizeof(ze_memory_provider_t)); + if (!ze_provider) { + LOG_ERR("Cannot allocate memory for Level Zero Memory Provider"); + return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; + } + + ze_provider->context = ze_params->level_zero_context_handle; + ze_provider->device = ze_params->level_zero_device_handle; + ze_provider->memory_type = (ze_memory_type_t)ze_params->memory_type; + ze_provider->freePolicyFlags = + umfFreePolicyToZePolicy(ze_params->freePolicy); + ze_provider->min_page_size = 0; + ze_provider->device_ordinal = ze_params->device_ordinal; + + memset(&ze_provider->device_properties, 0, + sizeof(ze_provider->device_properties)); + ze_provider->device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES; + + if (ze_provider->device) { + umf_result_t ret = ze2umf_result(g_ze_ops.zeDeviceGetProperties( + ze_provider->device, &ze_provider->device_properties)); + + if (ret != UMF_RESULT_SUCCESS) { + LOG_ERR("Cannot get device properties"); + umf_ba_global_free(ze_provider); + return ret; + } + } + + if (ze_params->resident_device_count) { + ze_provider->resident_device_handles = umf_ba_global_alloc( + sizeof(ze_device_handle_t) * ze_params->resident_device_count); + if (!ze_provider->resident_device_handles) { + LOG_ERR("Cannot allocate memory for resident devices"); + umf_ba_global_free(ze_provider); + return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; + } + + ze_provider->resident_device_count = ze_params->resident_device_count; + + for (uint32_t i = 0; i < ze_provider->resident_device_count; i++) { + ze_provider->resident_device_handles[i] = + ze_params->resident_device_handles[i]; + } + } else { + ze_provider->resident_device_handles = NULL; + ze_provider->resident_device_count = 0; + } + + umf_result_t result = + query_min_page_size(ze_provider, &ze_provider->min_page_size); + if (result != UMF_RESULT_SUCCESS) { + ze_memory_provider_finalize(provider); + return result; + } + + *provider = ze_provider; + + return UMF_RESULT_SUCCESS; +} + static void ze_memory_provider_get_last_native_error(void *provider, const char **ppMessage, int32_t *pError) { @@ -569,11 +632,23 @@ static void ze_memory_provider_get_last_native_error(void *provider, static umf_result_t ze_memory_provider_get_min_page_size(void *provider, void *ptr, size_t *pageSize) { - (void)provider; - (void)ptr; + ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider; + + if (!ptr) { + *pageSize = ze_provider->min_page_size; + return UMF_RESULT_SUCCESS; + } + + ze_memory_allocation_properties_t properties = { + .stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES}; + ze_result_t ze_result = g_ze_ops.zeMemGetAllocProperties( + ze_provider->context, ptr, &properties, NULL); + if (ze_result != ZE_RESULT_SUCCESS) { + return ze2umf_result(ze_result); + } + + *pageSize = properties.pageSize; - // TODO - *pageSize = 1024 * 64; return UMF_RESULT_SUCCESS; } @@ -600,12 +675,8 @@ static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr, static umf_result_t ze_memory_provider_get_recommended_page_size(void *provider, size_t size, size_t *pageSize) { - (void)provider; (void)size; - - // TODO - *pageSize = 1024 * 64; - return UMF_RESULT_SUCCESS; + return ze_memory_provider_get_min_page_size(provider, NULL, pageSize); } static const char *ze_memory_provider_get_name(void *provider) { diff --git a/src/utils/utils_level_zero.cpp b/src/utils/utils_level_zero.cpp index 833047dd7..40f906f43 100644 --- a/src/utils/utils_level_zero.cpp +++ b/src/utils/utils_level_zero.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -60,6 +60,9 @@ struct libze_ops { const ze_device_mem_alloc_desc_t *, size_t, size_t, ze_device_handle_t, void **); ze_result_t (*zeMemFree)(ze_context_handle_t, void *); + ze_result_t (*zeDeviceGetMemoryProperties)( + ze_device_handle_t hDevice, uint32_t *pCount, + ze_device_memory_properties_t *pMemProperties); } libze_ops; #if USE_DLOPEN @@ -125,6 +128,9 @@ struct DlHandleCloser { libze_ops.zeMemFree = [](auto... args) { return noop_stub(args...); }; + libze_ops.zeDeviceGetMemoryProperties = [](auto... args) { + return noop_stub(args...); + }; utils_close_library(dlHandle); } } @@ -265,6 +271,13 @@ int InitLevelZeroOps() { fprintf(stderr, "zeMemFree symbol not found in %s\n", lib_name); return -1; } + *(void **)&libze_ops.zeDeviceGetMemoryProperties = utils_get_symbol_addr( + zeDlHandle.get(), "zeDeviceGetMemoryProperties", lib_name); + if (libze_ops.zeDeviceGetMemoryProperties == nullptr) { + fprintf(stderr, "zeDeviceGetMemoryProperties symbol not found in %s\n", + lib_name); + return -1; + } return 0; } @@ -292,6 +305,7 @@ int InitLevelZeroOps() { libze_ops.zeMemGetAllocProperties = zeMemGetAllocProperties; libze_ops.zeMemAllocDevice = zeMemAllocDevice; libze_ops.zeMemFree = zeMemFree; + libze_ops.zeDeviceGetMemoryProperties = zeDeviceGetMemoryProperties; return 0; } @@ -745,3 +759,15 @@ ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr) { libze_ops.zeMemGetAllocProperties(context, ptr, &alloc_props, &device); return alloc_props.type; } + +int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device) { + uint32_t pCount = 0; + ze_result_t ze_result = + libze_ops.zeDeviceGetMemoryProperties(device, &pCount, nullptr); + if (ze_result != ZE_RESULT_SUCCESS) { + fprintf(stderr, "zeDeviceGetMemoryProperties() failed!\n"); + return -1; + } + + return static_cast(pCount); +} diff --git a/src/utils/utils_level_zero.h b/src/utils/utils_level_zero.h index b29a4dc43..d0f3fe154 100644 --- a/src/utils/utils_level_zero.h +++ b/src/utils/utils_level_zero.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -45,6 +45,8 @@ int utils_ze_destroy_context(ze_context_handle_t context); ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr); +int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device); + #ifdef __cplusplus } #endif diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp index cdf620ace..af90aa72e 100644 --- a/test/providers/provider_level_zero.cpp +++ b/test/providers/provider_level_zero.cpp @@ -347,6 +347,18 @@ TEST_P(umfLevelZeroProviderTest, getPageSize) { ASSERT_GE(recommendedPageSize, minPageSize); + void *ptr; + umf_result = umfMemoryProviderAlloc(provider, 1, 0, &ptr); + + size_t actualPageSize = 0; + umf_result = + umfMemoryProviderGetMinPageSize(provider, ptr, &actualPageSize); + ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); + ASSERT_GE(actualPageSize, minPageSize); + + umf_result = umfMemoryProviderFree(provider, ptr, 1); + ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); + umfMemoryProviderDestroy(provider); } @@ -421,6 +433,39 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) { res = umfLevelZeroMemoryProviderParamsSetMemoryType(nullptr, UMF_MEMORY_TYPE_DEVICE); EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0); + EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); +} + +TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) { + int64_t numProps = + utils_ze_get_num_memory_properties(l0TestHelper.get_test_device()); + ASSERT_GE(numProps, 0); + + for (uint32_t ordinal = 0; ordinal < static_cast(numProps); + ordinal++) { + umf_memory_provider_handle_t provider = nullptr; + umf_result_t res = + umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(params, ordinal); + EXPECT_EQ(res, UMF_RESULT_SUCCESS); + + res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(), params, + &provider); + ASSERT_EQ(res, UMF_RESULT_SUCCESS); + ASSERT_NE(provider, nullptr); + + size_t size = 1024; + void *ptr = nullptr; + res = umfMemoryProviderAlloc(provider, size, 0, &ptr); + ASSERT_EQ(res, UMF_RESULT_SUCCESS); + ASSERT_NE(ptr, nullptr); + + res = umfMemoryProviderFree(provider, ptr, size); + ASSERT_EQ(res, UMF_RESULT_SUCCESS); + + umfMemoryProviderDestroy(provider); + } } // TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool diff --git a/test/providers/provider_level_zero_not_impl.cpp b/test/providers/provider_level_zero_not_impl.cpp index c55c236fe..4948bd66f 100644 --- a/test/providers/provider_level_zero_not_impl.cpp +++ b/test/providers/provider_level_zero_not_impl.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2024 Intel Corporation +// Copyright (C) 2024-2025 Intel Corporation // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -35,6 +35,9 @@ TEST_F(test, level_zero_provider_not_implemented) { hParams, UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT); ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0); + ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps(); ASSERT_EQ(ops, nullptr); }