add Level Zero memory provider

bratpiorka · bratpiorka · commit 9ab1e48db196 · 2024-02-20T18:38:41.000+01:00
diff --git a/.github/workflows/gpu.yml b/.github/workflows/gpu.yml
@@ -0,0 +1,66 @@
+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: Install apt packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake libhwloc-dev libnuma-dev libjemalloc-dev libtbb-dev
+
+      - name: Checkout Level Zero
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          repository: oneapi-src/level-zero
+          path: level_zero
+  
+      - name: Build and Install Level Zero
+        run: |
+            cd level_zero
+            mkdir build
+            cd build
+            cmake ..
+            sudo cmake --build . --config Release --target install
+            cd ..
+
+      - name: Checkout
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
+      - 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_LIBUMF_PROVIDER_LEVEL_ZERO=ON
+          -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+          -DUMF_ENABLE_POOL_TRACKING=ON
+
+      - name: Build UMF
+        run: cmake --build ${{github.workspace}}/build -j $(nproc)
+
+      - name: Run tests
+        working-directory: ${{github.workspace}}/build
+        run: |
+          ctest --output-on-failure --test-dir test
diff --git a/.github/workflows/pr_push.yml b/.github/workflows/pr_push.yml
@@ -91,3 +91,6 @@ jobs:
     Benchmark:
         needs: [Build]
         uses: ./.github/workflows/benchmarks.yml
+    GPU:
+      needs: [Build]
+      uses: ./.github/workflows/gpu.yml
diff --git a/CMakeLists.txt b/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_LIBUMF_PROVIDER_LEVEL_ZERO "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)
diff --git a/README.md b/README.md
@@ -84,6 +84,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_LIBUMF_PROVIDER_LEVEL_ZERO | 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 |
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
@@ -52,6 +52,10 @@ if (UMF_BUILD_OS_MEMORY_PROVIDER)
 	endif()
 endif()
 
+if (UMF_BUILD_LIBUMF_PROVIDER_LEVEL_ZERO)
+	target_compile_definitions(ubench PRIVATE UMF_BUILD_LIBUMF_PROVIDER_LEVEL_ZERO=1)
+endif()
+
 if (UMF_BUILD_LIBUMF_POOL_DISJOINT)
 	target_compile_definitions(ubench PRIVATE UMF_BUILD_LIBUMF_POOL_DISJOINT=1)
 
diff --git a/include/umf/providers/provider_level_zero.h b/include/umf/providers/provider_level_zero.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_PROVIDER_LEVEL_ZERO_H
+#define UMF_PROVIDER_LEVEL_ZERO_H
+
+#include <level_zero/ze_api.h>
+
+#include "umf/memory_provider.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @brief Level Zero provider settings struct
+typedef struct level_zero_memory_provider_params_t {
+    ze_context_handle_t context;
+    ze_device_handle_t device;
+    ze_device_mem_alloc_desc_t device_mem_alloc_desc;
+} level_zero_memory_provider_params_t;
+
+umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_PROVIDER_LEVEL_ZERO_H */
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -103,3 +103,4 @@ install(TARGETS umf
 )
 
 add_subdirectory(pool)
+add_subdirectory(provider)
diff --git a/src/libumf.def b/src/libumf.def
@@ -39,3 +39,4 @@ EXPORTS
     umfMemoryProviderCreateFromMemspace
     umfMemspaceDestroy
     umfProxyPoolOps
+    
diff --git a/src/libumf.map b/src/libumf.map
@@ -35,6 +35,7 @@ UMF_1.0 {
         umfMemoryProviderCreateFromMemspace;
         umfMemspaceCreateFromNumaArray;
         umfMemspaceDestroy;
+        umfLevelZeroMemoryProviderOps;
     local:
         *;
 };
diff --git a/src/pool/pool_scalable.c b/src/pool/pool_scalable.c
@@ -13,7 +13,6 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
 #include "umf/pools/pool_scalable.h"
diff --git a/src/provider/CMakeLists.txt b/src/provider/CMakeLists.txt
@@ -0,0 +1,34 @@
+# 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
+
+if(UMF_BUILD_SHARED_LIBRARY)
+    set(PROVIDER_EXTRA_SRCS ${BA_SOURCES})
+    set(PROVIDER_COMPILE_DEFINITIONS UMF_SHARED_LIBRARY)
+endif()
+
+# libumf_provider_level_zero
+if(UMF_BUILD_LIBUMF_PROVIDER_LEVEL_ZERO)
+    add_umf_library(NAME level_zero_provider
+                    TYPE STATIC
+                    SRCS provider_level_zero.c ${PROVIDER_EXTRA_SRCS}
+                    LIBS umf_utils)
+    target_compile_definitions(level_zero_provider PUBLIC ${PROVIDER_COMPILE_DEFINITIONS})
+
+    add_library(${PROJECT_NAME}::level_zero_provider ALIAS level_zero_provider)
+
+    add_dependencies(level_zero_provider
+        umf)
+
+    target_link_libraries(level_zero_provider PRIVATE
+        umf)
+
+    target_include_directories(level_zero_provider PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/umf/providers>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+
+    install(TARGETS level_zero_provider
+        EXPORT ${PROJECT_NAME}-targets
+    )
+endif()
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
@@ -0,0 +1,203 @@
+/*
+ * 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 <dlfcn.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h> // TODO remove
+#include <unistd.h>
+
+#include <umf.h>
+#include <umf/memory_provider_ops.h>
+#include <umf/providers/provider_level_zero.h>
+
+#include "base_alloc_global.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+#include "utils_sanitizers.h"
+
+typedef struct ze_ops_t {
+    ze_result_t (*zeMemAllocDevice)(ze_context_handle_t,
+                                    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_ops_t;
+
+static ze_ops_t g_ze_ops;
+static UTIL_ONCE_FLAG ze_is_initialized = UTIL_ONCE_FLAG_INIT;
+static bool Init_ze_global_state_failed;
+
+static void init_ze_global_state(void) {
+    const char so_name[] = "libze_loader.so";
+    void *ze_handle = dlopen(so_name, RTLD_LAZY);
+    if (!ze_handle) {
+        fprintf(stderr, "%s not found.\n", so_name);
+        Init_ze_global_state_failed = true;
+        return;
+    }
+
+    *(void **)&g_ze_ops.zeMemAllocDevice = dlsym(ze_handle, "zeMemAllocDevice");
+    *(void **)&g_ze_ops.zeMemFree = dlsym(ze_handle, "zeMemFree");
+
+    if (!g_ze_ops.zeMemAllocDevice || !g_ze_ops.zeMemFree) {
+        fprintf(stderr, "Could not find symbols in %s.\n", so_name);
+        dlclose(ze_handle);
+        Init_ze_global_state_failed = true;
+        return;
+    }
+}
+
+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;
+
+    // saved pointer to the global base allocator
+    umf_ba_pool_t *base_allocator;
+} ze_memory_provider_t;
+
+enum umf_result_t ze_memory_provider_initialize(void *params, void **provider) {
+    level_zero_memory_provider_params_t *ze_params =
+        (level_zero_memory_provider_params_t *)params;
+
+    util_init_once(&ze_is_initialized, init_ze_global_state);
+    if (Init_ze_global_state_failed) {
+        fprintf(stderr, "loading Level Zero symbols failed\n");
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    umf_ba_pool_t *base_allocator =
+        umf_ba_get_pool(sizeof(ze_memory_provider_t));
+    if (!base_allocator) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    ze_memory_provider_t *ze_provider = umf_ba_alloc(base_allocator);
+    if (!ze_provider) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    if (ze_params->device_mem_alloc_desc.stype !=
+        ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    ze_provider->base_allocator = base_allocator;
+    ze_provider->context = ze_params->context;
+    ze_provider->device = ze_params->device;
+    ze_provider->device_mem_alloc_desc = ze_params->device_mem_alloc_desc;
+
+    // TODO what about chained desc?
+    assert(ze_params->device_mem_alloc_desc.pNext == NULL);
+
+    *provider = ze_provider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+void ze_memory_provider_finalize(void *provider) {
+    util_init_once(&ze_is_initialized, init_ze_global_state);
+
+    assert(provider);
+    ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
+    umf_ba_free(ze_provider->base_allocator, 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 = (ze_memory_provider_t *)provider;
+    g_ze_ops.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 = (ze_memory_provider_t *)provider;
+    g_ze_ops.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;
+
+    assert(pError);
+    // TODO
+    *pError = 0;
+}
+
+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;
+}
+
+static struct umf_memory_provider_ops_t UMF_LEVEL_ZERO_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,
+};
+
+umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
+    return &UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS;
+}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp
diff --git a/test/test_make_install.txt b/test/test_make_install.txt

Original file line number	Diff line number	Diff line change
`@@ -103,3 +103,4 @@ install(TARGETS umf`
`103`	`103`	`)`
`104`	`104`
`105`	`105`	`add_subdirectory(pool)`
	`106`	`+add_subdirectory(provider)`