Skip to content

Update Level Zero provider config API #920

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
Nov 25, 2024
Merged

Update Level Zero provider config API #920

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
65 changes: 49 additions & 16 deletions benchmark/ubench.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -421,11 +421,10 @@ static void do_ipc_get_put_benchmark(alloc_t *allocs, size_t num_allocs,
}
}

int create_level_zero_params(level_zero_memory_provider_params_t *params) {
int create_level_zero_params(ze_context_handle_t *context,
ze_device_handle_t *device) {
uint32_t driver_idx = 0;
ze_driver_handle_t driver = NULL;
ze_context_handle_t context = NULL;
ze_device_handle_t device = NULL;

int ret = init_level_zero();
if (ret != 0) {
Expand All @@ -439,36 +438,68 @@ int create_level_zero_params(level_zero_memory_provider_params_t *params) {
return ret;
}

ret = create_context(driver, &context);
ret = create_context(driver, context);
if (ret != 0) {
fprintf(stderr, "Failed to create L0 context!\n");
return ret;
}

ret = find_gpu_device(driver, &device);
if (ret || device == NULL) {
ret = find_gpu_device(driver, device);
if (ret) {
fprintf(stderr, "Cannot find GPU device!\n");
destroy_context(context);
destroy_context(*context);
return ret;
}

params->level_zero_context_handle = context;
params->level_zero_device_handle = device;
params->memory_type = UMF_MEMORY_TYPE_DEVICE;

return ret;
}

UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
const size_t BUFFER_SIZE = 100;
const size_t N_BUFFERS = 1000;
level_zero_memory_provider_params_t level_zero_params = {0};
umf_result_t umf_result;
ze_context_handle_t context = NULL;
ze_device_handle_t device = NULL;
umf_level_zero_memory_provider_params_handle_t level_zero_params = NULL;

int ret = create_level_zero_params(&level_zero_params);
int ret = create_level_zero_params(&context, &device);
if (ret != 0) {
fprintf(stderr, "error: create_level_zero_params() failed\n");
exit(-1);
}

umf_result = umfLevelZeroMemoryProviderParamsCreate(&level_zero_params);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"error: umfLevelZeroMemoryProviderParamsCreate() failed\n");
goto err_destroy_context;
}

umf_result =
umfLevelZeroMemoryProviderParamsSetContext(level_zero_params, context);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"error: umfLevelZeroMemoryProviderParamsSetContext() failed\n");
goto err_destroy_params;
}

umf_result =
umfLevelZeroMemoryProviderParamsSetDevice(level_zero_params, device);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"error: umfLevelZeroMemoryProviderParamsSetDevice() failed\n");
goto err_destroy_params;
}

umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
level_zero_params, UMF_MEMORY_TYPE_DEVICE);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(
stderr,
"error: umfLevelZeroMemoryProviderParamsSetMemoryType() failed\n");
goto err_destroy_params;
}

alloc_t *allocs = alloc_array(N_BUFFERS);
if (allocs == NULL) {
fprintf(stderr, "error: alloc_array() failed\n");
Expand All @@ -481,10 +512,9 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
goto err_free_allocs;
}

umf_result_t umf_result;
umf_memory_provider_handle_t provider = NULL;
umf_result = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
&level_zero_params, &provider);
level_zero_params, &provider);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr, "error: umfMemoryProviderCreate() failed\n");
goto err_free_ipc_handles;
Expand Down Expand Up @@ -570,8 +600,11 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
err_free_allocs:
free(allocs);

err_destroy_params:
umfLevelZeroMemoryProviderParamsDestroy(level_zero_params);

err_destroy_context:
destroy_context(level_zero_params.level_zero_context_handle);
destroy_context(context);
}
#endif /* (defined UMF_BUILD_LIBUMF_POOL_DISJOINT && defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */

Expand Down
45 changes: 39 additions & 6 deletions examples/ipc_level_zero/ipc_level_zero.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,15 +20,48 @@ int create_level_zero_pool(ze_context_handle_t context,
ze_device_handle_t device,
umf_memory_pool_handle_t *pool) {
// setup params
level_zero_memory_provider_params_t params = {0};
params.level_zero_context_handle = context;
params.level_zero_device_handle = device;
params.memory_type = UMF_MEMORY_TYPE_DEVICE;
umf_level_zero_memory_provider_params_handle_t provider_params = NULL;

umf_result_t umf_result =
umfLevelZeroMemoryProviderParamsCreate(&provider_params);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"ERROR: Failed to create Level Zero memory provider params!\n");
return -1;
}

umf_result =
umfLevelZeroMemoryProviderParamsSetContext(provider_params, context);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr, "ERROR: Failed to set context in Level Zero memory "
"provider params!\n");
umfLevelZeroMemoryProviderParamsDestroy(provider_params);
return -1;
}

umf_result =
umfLevelZeroMemoryProviderParamsSetDevice(provider_params, device);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr, "ERROR: Failed to set device in Level Zero memory "
"provider params!\n");
umfLevelZeroMemoryProviderParamsDestroy(provider_params);
return -1;
}

umf_result = umfLevelZeroMemoryProviderParamsSetMemoryType(
provider_params, UMF_MEMORY_TYPE_DEVICE);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr, "ERROR: Failed to set memory type in Level Zero memory "
"provider params!\n");
umfLevelZeroMemoryProviderParamsDestroy(provider_params);
return -1;
}

// create Level Zero provider
umf_memory_provider_handle_t provider = 0;
umf_result_t umf_result = umfMemoryProviderCreate(
umfLevelZeroMemoryProviderOps(), &params, &provider);
umf_result = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
provider_params, &provider);
umfLevelZeroMemoryProviderParamsDestroy(provider_params);
if (umf_result != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"ERROR: Failed to create Level Zero memory provider!\n");
Expand Down
48 changes: 40 additions & 8 deletions examples/level_zero_shared_memory/level_zero_shared_memory.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,22 +49,51 @@ int main(void) {

// Setup parameters for the Level Zero memory provider. It will be used for
// allocating memory from Level Zero devices.
level_zero_memory_provider_params_t ze_memory_provider_params = {0};
ze_memory_provider_params.level_zero_context_handle = hContext;
ze_memory_provider_params.level_zero_device_handle = hDevice;
umf_level_zero_memory_provider_params_handle_t ze_memory_provider_params =
NULL;
res = umfLevelZeroMemoryProviderParamsCreate(&ze_memory_provider_params);
if (res != UMF_RESULT_SUCCESS) {
fprintf(stderr, "Failed to create memory provider params!\n");
ret = -1;
goto level_zero_destroy;
}

res = umfLevelZeroMemoryProviderParamsSetContext(ze_memory_provider_params,
hContext);
if (res != UMF_RESULT_SUCCESS) {
fprintf(stderr, "Failed to set context in memory provider params!\n");
ret = -1;
goto provider_params_destroy;
}

res = umfLevelZeroMemoryProviderParamsSetDevice(ze_memory_provider_params,
hDevice);
if (res != UMF_RESULT_SUCCESS) {
fprintf(stderr, "Failed to set device in memory provider params!\n");
ret = -1;
goto provider_params_destroy;
}

// Set the memory type to shared to allow the memory to be accessed on both
// CPU and GPU.
ze_memory_provider_params.memory_type = UMF_MEMORY_TYPE_SHARED;
res = umfLevelZeroMemoryProviderParamsSetMemoryType(
ze_memory_provider_params, UMF_MEMORY_TYPE_SHARED);
if (res != UMF_RESULT_SUCCESS) {
fprintf(stderr,
"Failed to set memory type in memory provider params!\n");
ret = -1;
goto provider_params_destroy;
}

// Create Level Zero memory provider
umf_memory_provider_handle_t ze_memory_provider;
res = umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
&ze_memory_provider_params,
&ze_memory_provider);
res =
umfMemoryProviderCreate(umfLevelZeroMemoryProviderOps(),
ze_memory_provider_params, &ze_memory_provider);
if (res != UMF_RESULT_SUCCESS) {
fprintf(stderr, "Failed to create a memory provider!\n");
ret = -1;
goto level_zero_destroy;
goto provider_params_destroy;
}

printf("Level Zero memory provider created at %p\n",
Expand Down Expand Up @@ -154,6 +183,9 @@ int main(void) {
memory_provider_destroy:
umfMemoryProviderDestroy(ze_memory_provider);

provider_params_destroy:
umfLevelZeroMemoryProviderParamsDestroy(ze_memory_provider_params);

level_zero_destroy:
ret = destroy_context(hContext);
return ret;
Expand Down
64 changes: 50 additions & 14 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 @@ -17,20 +17,56 @@ extern "C" {
typedef struct _ze_device_handle_t *ze_device_handle_t;
typedef struct _ze_context_handle_t *ze_context_handle_t;

/// @brief Level Zero Memory Provider settings struct
typedef struct level_zero_memory_provider_params_t {
ze_context_handle_t
level_zero_context_handle; ///< Handle to the Level Zero context
ze_device_handle_t
level_zero_device_handle; ///< Handle to the Level Zero device

umf_usm_memory_type_t memory_type; ///< Allocation memory type

ze_device_handle_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
} level_zero_memory_provider_params_t;
struct umf_level_zero_memory_provider_params_t;

/// @brief handle to the parameters of the Level Zero Memory Provider.
typedef struct umf_level_zero_memory_provider_params_t
*umf_level_zero_memory_provider_params_handle_t;

/// @brief Create a struct to store parameters of the Level Zero Memory Provider.
/// @param hParams [out] handle to the newly created parameters struct.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsCreate(
umf_level_zero_memory_provider_params_handle_t *hParams);

/// @brief Destroy parameters struct.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsDestroy(
umf_level_zero_memory_provider_params_handle_t hParams);

/// @brief Set the Level Zero context handle in the parameters struct.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @param hContext handle to the Level Zero context. Cannot be \p NULL.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsSetContext(
umf_level_zero_memory_provider_params_handle_t hParams,
ze_context_handle_t hContext);

/// @brief Set the Level Zero device handle in the parameters struct.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @param hDevice handle to the Level Zero device. Can be \p NULL if memory type is \p UMF_MEMORY_TYPE_HOST.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsSetDevice(
umf_level_zero_memory_provider_params_handle_t hParams,
ze_device_handle_t hDevice);

/// @brief Set the memory type in the parameters struct.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @param memoryType memory type.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsSetMemoryType(
umf_level_zero_memory_provider_params_handle_t hParams,
umf_usm_memory_type_t memoryType);

/// @brief Set the resident devices in the parameters struct.
/// @param hParams handle to the parameters of the Level Zero Memory Provider.
/// @param hDevices array of devices for which the memory should be made resident.
/// @param deviceCount number of devices for which the memory should be made resident.
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
umf_level_zero_memory_provider_params_handle_t hParams,
ze_device_handle_t *hDevices, uint32_t deviceCount);

umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);

Expand Down
6 changes: 6 additions & 0 deletions src/libumf.def
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,12 @@ EXPORTS
umfGetIPCHandle
umfGetLastFailedMemoryProvider
umfLevelZeroMemoryProviderOps
umfLevelZeroMemoryProviderParamsCreate
umfLevelZeroMemoryProviderParamsDestroy
umfLevelZeroMemoryProviderParamsSetContext
umfLevelZeroMemoryProviderParamsSetDevice
umfLevelZeroMemoryProviderParamsSetMemoryType
umfLevelZeroMemoryProviderParamsSetResidentDevices
umfMemoryProviderAlloc
umfMemoryProviderAllocationMerge
umfMemoryProviderAllocationSplit
Expand Down
6 changes: 6 additions & 0 deletions src/libumf.map
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,12 @@ UMF_1.0 {
umfGetIPCHandle;
umfGetLastFailedMemoryProvider;
umfLevelZeroMemoryProviderOps;
umfLevelZeroMemoryProviderParamsCreate;
umfLevelZeroMemoryProviderParamsDestroy;
umfLevelZeroMemoryProviderParamsSetContext;
umfLevelZeroMemoryProviderParamsSetDevice;
umfLevelZeroMemoryProviderParamsSetMemoryType;
umfLevelZeroMemoryProviderParamsSetResidentDevices;
umfMemoryProviderAlloc;
umfMemoryProviderAllocationMerge;
umfMemoryProviderAllocationSplit;
Expand Down
Loading
Loading