add Level Zero memory provider

Author: bratpiorka

CMakeLists.txt

@@ -8,6 +8,7 @@ project(unified-memory-framework VERSION 0.1.0 LANGUAGES C)
 # Build Options
 option(UMF_BUILD_SHARED_LIBRARY "Build UMF as shared library" OFF)
 option(UMF_BUILD_OS_MEMORY_PROVIDER "Build OS memory provider" ON)
+option(UMF_BUILD_ZE_MEMORY_PROVIDER "Build Level Zero memory provider" ON)
 option(UMF_BUILD_LIBUMF_POOL_DISJOINT "Build the libumf_pool_disjoint static library" OFF)
 option(UMF_BUILD_LIBUMF_POOL_JEMALLOC "Build the libumf_pool_jemalloc static library" OFF)
 option(UMF_BUILD_LIBUMF_POOL_SCALABLE "Build the libumf_pool_scalable static library" OFF)

README.md

@@ -30,11 +30,20 @@ A memory provider that provides memory from an operating system.
 
 1) Linux OS
 2) The `UMF_BUILD_OS_MEMORY_PROVIDER` option turned `ON` (by default)
+TODO
 3) Required packages:
    - libhwloc-dev
 4) Required packages for tests:
    - libnuma-dev
 
+### Level Zero memory provider (Linux-only yet)
+
+TODO
+
+#### Requirements
+
+TODO
+
 ## Memory pool managers
 
 ### proxy_pool (part of libumf)
@@ -153,6 +162,7 @@ List of options provided by CMake:
 | - | - | - | - |
 | UMF_BUILD_SHARED_LIBRARY | Build UMF as shared library | ON/OFF | OFF |
 | UMF_BUILD_OS_MEMORY_PROVIDER | Build OS memory provider | ON/OFF | ON |
+| UMF_BUILD_ZE_MEMORY_PROVIDER | Build Level Zero memory provider | ON/OFF | OFF |
 | UMF_BUILD_LIBUMF_POOL_DISJOINT | Build the libumf_pool_disjoint static library | ON/OFF | OFF |
 | UMF_BUILD_LIBUMF_POOL_JEMALLOC | Build the libumf_pool_jemalloc static library | ON/OFF | OFF |
 | UMF_BUILD_LIBUMF_POOL_SCALABLE | Build the libumf_pool_scalable static library | ON/OFF | OFF |

benchmark/CMakeLists.txt

@@ -38,6 +38,10 @@ if (UMF_BUILD_OS_MEMORY_PROVIDER)
 	target_compile_definitions(ubench PRIVATE UMF_BUILD_OS_MEMORY_PROVIDER=1)
 endif()
 
+if (UMF_BUILD_ZE_MEMORY_PROVIDER)
+	target_compile_definitions(ubench PRIVATE UMF_BUILD_ZE_MEMORY_PROVIDER=1)
+endif()
+
 if (UMF_BUILD_LIBUMF_POOL_DISJOINT)
 	target_compile_definitions(ubench PRIVATE UMF_BUILD_LIBUMF_POOL_DISJOINT=1)
 endif()

include/umf/providers/provider_ze_memory.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_ZE_MEMORY_PROVIDER_H
+#define UMF_ZE_MEMORY_PROVIDER_H
+
+#include <ze_api.h>
+
+#include "umf/memory_provider.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @brief ze memory provider settings struct
+typedef struct ze_memory_provider_params_t {
+    ze_context_handle_t context;
+    ze_device_handle_t device;
+    ze_device_mem_alloc_desc_t device_mem_alloc_desc;
+} ze_memory_provider_params_t;
+
+umf_memory_provider_ops_t *umfZeMemoryProviderOps(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_ZE_MEMORY_PROVIDER_H */

src/CMakeLists.txt

@@ -58,6 +58,14 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER)
     endif()
 endif()
 
+if(UMF_BUILD_ZE_MEMORY_PROVIDER)
+    set(UMF_SOURCES_LINUX ${UMF_SOURCES_LINUX}
+        provider/provider_ze_memory.c)
+    if(LINUX)
+        set(UMF_LIBS ${UMF_LIBS} ze_loader)
+    endif()
+endif()
+
 if(LINUX)
     set(UMF_SOURCES ${UMF_SOURCES} ${UMF_SOURCES_LINUX})
 elseif(WINDOWS)

src/libumf.map

@@ -35,6 +35,7 @@ UMF_1.0 {
         umfMemoryProviderCreateFromMemspace;
         umfMemspaceCreateFromNumaArray;
         umfMemspaceDestroy;
+        umfZeMemoryProviderOps;
     local:
         *;
 };

src/provider/provider_ze_memory.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_ze_memory.h>
+
+typedef struct ze_memory_provider_t {
+    ze_context_handle_t context;
+    ze_device_handle_t device;
+    ze_device_mem_alloc_desc_t device_mem_alloc_desc;
+
+} ze_memory_provider_t;
+
+enum umf_result_t ze_memory_provider_initialize(void *params, void **provider) {
+    ze_memory_provider_params_t *ze_params =
+        (ze_memory_provider_params_t *)params;
+
+    // TODO use ba_alloc here
+    ze_memory_provider_t *ze_provider =
+        (ze_memory_provider_t *)malloc(sizeof(ze_memory_provider_t));
+    if (!ze_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    ze_provider->context = ze_params->context;
+    ze_provider->device = ze_params->device;
+    ze_provider->device_mem_alloc_desc = ze_params->device_mem_alloc_desc;
+
+    assert(ze_provider->device_mem_alloc_desc.stype ==
+           ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC);
+    assert(ze_params->device_mem_alloc_desc.pNext == NULL);
+
+    *provider = ze_provider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+void ze_memory_provider_finalize(void *provider) {
+    assert(provider);
+    ze_memory_provider_t *ze_provider = (struct ze_memory_provider_t *)provider;
+
+    free(ze_provider);
+}
+
+static enum umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
+                                                  size_t alignment,
+                                                  void **resultPtr) {
+    assert(provider);
+    assert(resultPtr);
+
+    ze_memory_provider_t *ze_provider = (struct ze_memory_provider_t *)provider;
+    zeMemAllocDevice(ze_provider->context, &ze_provider->device_mem_alloc_desc,
+                     size, alignment, ze_provider->device, resultPtr);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static enum umf_result_t ze_memory_provider_free(void *provider, void *ptr,
+                                                 size_t bytes) {
+    assert(provider);
+
+    ze_memory_provider_t *ze_provider = (struct ze_memory_provider_t *)provider;
+    zeMemFree(ze_provider->context, ptr);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+void ze_memory_provider_get_last_native_error(void *provider,
+                                              const char **ppMessage,
+                                              int32_t *pError) {
+    // empty
+}
+
+static enum umf_result_t
+ze_memory_provider_get_min_page_size(void *provider, void *ptr,
+                                     size_t *pageSize) {
+    *pageSize = 1024 * 4; // TODO
+    return UMF_RESULT_SUCCESS;
+}
+
+static enum umf_result_t
+ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
+                                             size_t *pageSize) {
+    *pageSize = 1024 * 4; // TODO
+    return UMF_RESULT_SUCCESS;
+}
+
+const char *ze_memory_provider_get_name(void *provider) {
+    return "UMF_ZE_PROVIDER";
+}
+
+static enum umf_result_t ze_memory_provider_allocation_merge(void *hProvider,
+                                                             void *lowPtr,
+                                                             void *highPtr,
+                                                             size_t totalSize) {
+    // NOP
+    return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+}
+
+struct umf_memory_provider_ops_t umf_ze_memory_provider_ops = {
+    .version = UMF_VERSION_CURRENT,
+    .initialize = ze_memory_provider_initialize,
+    .finalize = ze_memory_provider_finalize,
+    .alloc = ze_memory_provider_alloc,
+    .free = ze_memory_provider_free,
+    .get_last_native_error = ze_memory_provider_get_last_native_error,
+    .get_recommended_page_size = ze_memory_provider_get_recommended_page_size,
+    .get_min_page_size = ze_memory_provider_get_min_page_size,
+    .purge_lazy = NULL,
+    .purge_force = NULL,
+    .get_name = ze_memory_provider_get_name,
+    .allocation_split = NULL,
+    .allocation_merge = ze_memory_provider_allocation_merge,
+};