Initial memspace and memory_target APIs

igchor · igchor · commit b8182317cf13 · 2023-12-04T22:15:12.000+01:00
diff --git a/include/umf.h b/include/umf.h
@@ -12,5 +12,7 @@
 
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
+#include <umf/memspace.h>
+#include <umf/memspace_policy.h>
 
 #endif /* UMF_UNIFIED_MEMORY_FRAMEWORK_H */
diff --git a/include/umf/memspace.h b/include/umf/memspace.h
@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMSPACE_H
+#define UMF_MEMSPACE_H 1
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/memspace_policy.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memspace_t *umf_memspace_handle_t;
+
+// TODO: consider 3rd function that would only return pool ops (as opposed
+// to actual pool instance with a provider). This could be useful for UR,
+// where we could ask UMF for a best pool (e.g. based on policy) but supply
+// a custom provider (L0/CUDA, etc.).
+enum umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
+                                            umf_memspace_policy_handle_t policy,
+                                            umf_memory_pool_handle_t *pool);
+enum umf_result_t
+umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t memspace,
+                                    umf_memspace_policy_handle_t policy,
+                                    umf_memory_provider_handle_t *provider);
+
+// TODO: iteration, filtering, sorting API
+// can we just define memspace as an array of targets?
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMSPACE_H */
diff --git a/include/umf/memspace_policy.h b/include/umf/memspace_policy.h
@@ -0,0 +1,27 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMSPACE_POLICY_H
+#define UMF_MEMSPACE_POLICY_H 1
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memspace_policy_t *umf_memspace_policy_handle_t;
+
+// TODO: define different policies
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMSPACE_POLICY_H */
diff --git a/include/umf/memspaces/memspace_numa.h b/include/umf/memspaces/memspace_numa.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMSPACE_NUMA_H
+#define UMF_MEMSPACE_NUMA_H 1
+
+#include <umf/base.h>
+#include <umf/memspace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum umf_result_t
+umfMemspaceCreateFromNumaId(size_t id,
+                            umf_memspace_handle_t *memspace /* out */);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMSPACE_NUMA_H */
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -8,6 +8,9 @@ set(UMF_SOURCES
     memory_pool.c
     memory_provider.c
     memory_provider_get_last_failed.c
+    memory_target.c
+    memory_targets/memory_target_numa.c
+    memspace.c
     pool/pool_disjoint.cpp
     provider/provider_os_memory.c
     provider/provider_tracking.c
diff --git a/src/memory_target.c b/src/memory_target.c
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright (C) 2023 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 <stdlib.h>
+
+#include "memory_target.h"
+#include "memory_target_ops.h"
+
+enum umf_result_t
+umfMemoryTargetCreate(struct umf_memory_target_ops_t *ops, void *params,
+                      umf_memory_target_handle_t *memory_target) {
+    umf_memory_target_handle_t target = (struct umf_memory_target_t *)malloc(
+        sizeof(struct umf_memory_target_t));
+    if (!target) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    assert(ops->version == UMF_VERSION_CURRENT);
+
+    target->ops = ops;
+
+    void *target_priv;
+    enum umf_result_t ret = ops->initialize(params, &target_priv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        free(target);
+        return ret;
+    }
+
+    target->priv = target_priv;
+
+    *memory_target = target;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+void umfMemoryTargetDestroy(umf_memory_target_handle_t memory_target) {
+    memory_target->ops->finalize(memory_target->priv);
+    free(memory_target);
+}
diff --git a/src/memory_target.h b/src/memory_target.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMORY_TARGET_H
+#define UMF_MEMORY_TARGET_H 1
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct umf_memory_target_ops_t;
+
+struct umf_memory_target_t {
+    struct umf_memory_target_ops_t *ops;
+    void *priv;
+};
+
+typedef struct umf_memory_target_t *umf_memory_target_handle_t;
+
+enum umf_result_t
+umfMemoryTargetCreate(struct umf_memory_target_ops_t *ops, void *params,
+                      umf_memory_target_handle_t *memory_target);
+
+void umfMemoryTargetDestroy(umf_memory_target_handle_t memory_target);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_TARGET_H */
diff --git a/src/memory_target_ops.h b/src/memory_target_ops.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMORY_TARGET_OPS_H
+#define UMF_MEMORY_TARGET_OPS_H 1
+
+#include <stdbool.h>
+
+#include <umf/base.h>
+#include <umf/memspace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memory_target_t *umf_memory_target_handle_t;
+
+struct umf_memory_target_ops_t {
+    /// Version of the ops structure.
+    /// Should be initialized using UMF_VERSION_CURRENT
+    uint32_t version;
+
+    enum umf_result_t (*initialize)(void *params, void **mem_target);
+    void (*finalize)(void *mem_target);
+
+    enum umf_result_t (*pool_create_from_memspace)(
+        umf_memspace_handle_t memspace, void **mem_targets,
+        umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool);
+
+    enum umf_result_t (*memory_provider_create_from_memspace)(
+        umf_memspace_handle_t memspace, void **mem_targets,
+        umf_memspace_policy_handle_t policy,
+        umf_memory_provider_handle_t *provider);
+
+    // TODO: query API (capacity, distance, etc.)
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef UMF_MEMORY_TARGET_OPS_H */
diff --git a/src/memory_targets/memory_target_numa.c b/src/memory_targets/memory_target_numa.c
@@ -0,0 +1,63 @@
+/*
+ *
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <stdlib.h>
+
+#include "memory_target_numa.h"
+
+struct numa_memory_target_t {
+    size_t id;
+};
+
+static enum umf_result_t numa_initialize(void *params, void **mem_target) {
+    struct umf_numa_memory_target_config_t *config =
+        (struct umf_numa_memory_target_config_t *)params;
+
+    struct numa_memory_target_t *numa_target =
+        malloc(sizeof(struct numa_memory_target_t));
+    if (!numa_target) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    numa_target->id = config->id;
+    *mem_target = numa_target;
+    return UMF_RESULT_SUCCESS;
+}
+
+static void numa_finalize(void *mem_target) { free(mem_target); }
+
+static enum umf_result_t numa_pool_create_from_memspace(
+    umf_memspace_handle_t memspace, void **mem_targets,
+    umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool) {
+    // TODO: cast mem_targets to (struct numa_memory_target_t**), parse ids and initialize os provider
+    (void)memspace;
+    (void)mem_targets;
+    (void)policy;
+    (void)pool;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+static enum umf_result_t numa_memory_provider_create_from_memspace(
+    umf_memspace_handle_t memspace, void **mem_targets,
+    umf_memspace_policy_handle_t policy,
+    umf_memory_provider_handle_t *provider) {
+    // TODO: cast mem_targets to (struct numa_memory_target_t**), parse ids and initialize os provider
+    (void)memspace;
+    (void)mem_targets;
+    (void)policy;
+    (void)provider;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
+struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = {
+    .initialize = numa_initialize,
+    .finalize = numa_finalize,
+    .pool_create_from_memspace = numa_pool_create_from_memspace,
+    .memory_provider_create_from_memspace =
+        numa_memory_provider_create_from_memspace};
diff --git a/src/memory_targets/memory_target_numa.h b/src/memory_targets/memory_target_numa.h
@@ -0,0 +1,33 @@
+/*
+ *
+ * Copyright (C) 2023 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_MEMORY_TARGET_NUMA_H
+#define UMF_MEMORY_TARGET_NUMA_H 1
+
+#include <umf.h>
+#include <umf/memspace.h>
+
+#include "../memory_target.h"
+#include "../memory_target_ops.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct umf_numa_memory_target_config_t {
+    size_t id;
+};
+
+extern struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_TARGET_NUMA_H */
diff --git a/src/memspace.c b/src/memspace.c
