add Level Zero memory provider

Author: bratpiorka

.github/workflows/gpu.yml

@@ -0,0 +1,46 @@
+name: GPU
+
+on: workflow_call
+
+permissions:
+  contents: read
+
+jobs:
+  ubuntu-build:
+    name: Build - Ubuntu
+
+    strategy:
+      matrix:
+        os: ['ubuntu-22.04']
+        build_type: [Release]
+        compiler: [{c: gcc, cxx: g++}]
+        shared_library: ['ON', 'OFF']
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
+      - name: Install apt packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev level-zero-dev
+
+      - name: Configure build
+        run: >
+          cmake
+          -B ${{github.workspace}}/build
+          -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+          -DCMAKE_C_COMPILER=${{matrix.compiler.c}}
+          -DCMAKE_CXX_COMPILER=${{matrix.compiler.cxx}}
+          -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+          -DUMF_BUILD_BENCHMARKS=ON
+          -DUMF_BUILD_TESTS=ON
+          -DUMF_FORMAT_CODE_STYLE=ON
+          -DUMF_DEVELOPER_MODE=ON
+          -DUMF_BUILD_ZE_MEMORY_PROVIDER=ON
+          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+          -DUMF_ENABLE_POOL_TRACKING=ON
+
+      - name: Build UMF
+        run: cmake --build ${{github.workspace}}/build -j $(nproc)

.github/workflows/pr_push.yml

@@ -85,3 +85,6 @@ jobs:
     Benchmark:
         needs: [Build]
         uses: ./.github/workflows/benchmarks.yml
+    GPU:
+      needs: [Build]
+      uses: ./.github/workflows/gpu.yml

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" OFF)
 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 <level_zero/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,15 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER)
     endif()
 endif()
 
+# TODO static lib!!
+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,140 @@
+/*
+ * 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>  // TODO remove
+#include <stdlib.h> // TODO remove
+#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) {
+    (void)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) {
+    (void)provider;
+    (void)ppMessage;
+    (void)pError;
+    // TODO
+}
+
+static enum umf_result_t
+ze_memory_provider_get_min_page_size(void *provider, void *ptr,
+                                     size_t *pageSize) {
+    (void)provider;
+    (void)ptr;
+
+    *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) {
+    (void)provider;
+    (void)size;
+
+    *pageSize = 1024 * 4; // TODO
+    return UMF_RESULT_SUCCESS;
+}
+
+const char *ze_memory_provider_get_name(void *provider) {
+    (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) {
+    (void)hProvider;
+    (void)lowPtr;
+    (void)highPtr;
+    (void)totalSize;
+
+    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,
+};

test/test_make_install.txt

@@ -16,6 +16,7 @@
 ./include/umf/pools/pool_scalable.h
 ./include/umf/providers
 ./include/umf/providers/provider_os_memory.h
+./include/umf/providers/provider_ze_memory.h
 ./lib
 ./lib/cmake
 ./lib/cmake/unified-memory-framework