Skip to content

L0 provider: implement support for defer and blocking free #963

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jan 16, 2025
Merged

L0 provider: implement support for defer and blocking free #963

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 15 additions & 0 deletions include/umf/providers/provider_level_zero.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -68,6 +68,21 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
umf_level_zero_memory_provider_params_handle_t hParams,
ze_device_handle_t *hDevices, uint32_t deviceCount);

typedef enum umf_level_zero_memory_provider_free_policy_t {
UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT =
0, ///< Free memory immediately. Default.
UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE, ///< Blocks until all commands using the memory are complete before freeing.
UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE, ///< Schedules the memory to be freed but does not free immediately.
} umf_level_zero_memory_provider_free_policy_t;

/// @brief Set the memory free policy.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @param policy memory free policy.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
umf_level_zero_memory_provider_params_handle_t hParams,
umf_level_zero_memory_provider_free_policy_t policy);

umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);

#ifdef __cplusplus
Expand Down
2 changes: 2 additions & 0 deletions src/libumf.def
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -120,3 +120,5 @@ EXPORTS
umfScalablePoolParamsDestroy
umfScalablePoolParamsSetGranularity
umfScalablePoolParamsSetKeepAllMemory
; Added in UMF_0.11
umfLevelZeroMemoryProviderParamsSetFreePolicy
1 change: 1 addition & 0 deletions src/libumf.map
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -119,4 +119,5 @@ UMF_0.11 {
umfFixedMemoryProviderOps;
umfFixedMemoryProviderParamsCreate;
umfFixedMemoryProviderParamsDestroy;
umfLevelZeroMemoryProviderParamsSetFreePolicy;
} UMF_0.10;
60 changes: 58 additions & 2 deletions src/provider/provider_level_zero.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,6 +75,14 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
return UMF_RESULT_ERROR_NOT_SUPPORTED;
}

umf_result_t umfLevelZeroMemoryProviderParamsSetFreePolicy(
umf_level_zero_memory_provider_params_handle_t hParams,
umf_level_zero_memory_provider_free_policy_t policy) {
(void)hParams;
(void)policy;
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 "
Expand Down Expand Up @@ -107,6 +115,9 @@ typedef struct umf_level_zero_memory_provider_params_t {
resident_device_handles; ///< Array of devices for which the memory should be made resident
uint32_t
resident_device_count; ///< Number of devices for which the memory should be made resident

umf_level_zero_memory_provider_free_policy_t
freePolicy; ///< Memory free policy
} umf_level_zero_memory_provider_params_t;

typedef struct ze_memory_provider_t {
Expand All @@ -118,6 +129,8 @@ typedef struct ze_memory_provider_t {
uint32_t resident_device_count;

ze_device_properties_t device_properties;

ze_driver_memory_free_policy_ext_flags_t freePolicyFlags;
} ze_memory_provider_t;

typedef struct ze_ops_t {
Expand All @@ -144,6 +157,8 @@ typedef struct ze_ops_t {
size_t);
ze_result_t (*zeDeviceGetProperties)(ze_device_handle_t,
ze_device_properties_t *);
ze_result_t (*zeMemFreeExt)(ze_context_handle_t,
ze_memory_free_ext_desc_t *, void *);
} ze_ops_t;

static ze_ops_t g_ze_ops;
Expand Down Expand Up @@ -197,6 +212,8 @@ static void init_ze_global_state(void) {
utils_get_symbol_addr(0, "zeContextMakeMemoryResident", lib_name);
*(void **)&g_ze_ops.zeDeviceGetProperties =
utils_get_symbol_addr(0, "zeDeviceGetProperties", lib_name);
*(void **)&g_ze_ops.zeMemFreeExt =
utils_get_symbol_addr(0, "zeMemFreeExt", lib_name);

if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice ||
!g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree ||
Expand Down Expand Up @@ -232,6 +249,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsCreate(
params->memory_type = UMF_MEMORY_TYPE_UNKNOWN;
params->resident_device_handles = NULL;
params->resident_device_count = 0;
params->freePolicy = UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT;

*hParams = params;

Expand Down Expand Up @@ -308,6 +326,32 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
return UMF_RESULT_SUCCESS;
}

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");
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
}

hParams->freePolicy = policy;
return UMF_RESULT_SUCCESS;
}

static ze_driver_memory_free_policy_ext_flags_t
umfFreePolicyToZePolicy(umf_level_zero_memory_provider_free_policy_t policy) {
switch (policy) {
case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT:
return 0;
case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_BLOCKING_FREE:
return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_BLOCKING_FREE;
case UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFER_FREE:
return ZE_DRIVER_MEMORY_FREE_POLICY_EXT_FLAG_DEFER_FREE;
default:
return 0;
}
}

static umf_result_t ze_memory_provider_initialize(void *params,
void **provider) {
if (params == NULL) {
Expand Down Expand Up @@ -351,6 +395,8 @@ static umf_result_t ze_memory_provider_initialize(void *params,
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));
Expand Down Expand Up @@ -493,8 +539,18 @@ static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
}

ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
ze_result_t ze_result = g_ze_ops.zeMemFree(ze_provider->context, ptr);
return ze2umf_result(ze_result);

if (ze_provider->freePolicyFlags == 0) {
return ze2umf_result(g_ze_ops.zeMemFree(ze_provider->context, ptr));
}

ze_memory_free_ext_desc_t desc = {
.stype = ZE_STRUCTURE_TYPE_MEMORY_FREE_EXT_DESC,
.pNext = NULL,
.freePolicy = ze_provider->freePolicyFlags};

return ze2umf_result(
g_ze_ops.zeMemFreeExt(ze_provider->context, &desc, ptr));
}

static void ze_memory_provider_get_last_native_error(void *provider,
Expand Down
4 changes: 4 additions & 0 deletions test/providers/provider_level_zero_not_impl.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,10 @@ TEST_F(test, level_zero_provider_not_implemented) {
hDevices, 1);
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);

result = umfLevelZeroMemoryProviderParamsSetFreePolicy(
hParams, UMF_LEVEL_ZERO_MEMORY_PROVIDER_FREE_POLICY_DEFAULT);
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);

umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
ASSERT_EQ(ops, nullptr);
}
Loading