add mempolicy with support of interleave, bind and preferred

include/umf.h

@@ -12,7 +12,7 @@
 
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
+#include <umf/mempolicy.h>
 #include <umf/memspace.h>
-#include <umf/memspace_policy.h>
 
 #endif /* UMF_UNIFIED_MEMORY_FRAMEWORK_H */

include/umf/mempolicy.h

@@ -0,0 +1,59 @@
+/*
+ *
+ * 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_MEMPOLICY_H
+#define UMF_MEMPOLICY_H 1
+
+#include <umf/base.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_mempolicy_t *umf_mempolicy_handle_t;
+typedef const struct umf_mempolicy_t *umf_const_mempolicy_handle_t;
+
+typedef enum umf_mempolicy_membind_t {
+    /// Interleave memory from all memory in memspace
+    UMF_MEMPOLICY_INTERLEAVE,
+    /// Bind memory to namespace
+    UMF_MEMPOLICY_BIND,
+    /// Prefer memory from namespace but fallback to other memory if not available
+    UMF_MEMPOLICY_PREFERRED
+} umf_mempolicy_membind_t;
+
+///
+/// @brief Creates a new memory policy
+/// @param bind memory binding policy
+/// @param hPolicy [out] handle to the newly created memory policy
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMempolicyCreate(umf_mempolicy_membind_t bind,
+                                umf_mempolicy_handle_t *hPolicy);
+
+///
+/// @brief Destroys memory policy
+/// @param hPolicy handle to memory policy
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMempolicyDestroy(umf_mempolicy_handle_t hPolicy);
+
+///
+/// @brief Sets custom part size for interleaved memory policy - by default it's interleaved by pages
+/// @param hPolicy handle to memory policy
+/// @param partSize size of the part or zero to use default part size (page size)
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMempolicySetInterleavePartSize(umf_mempolicy_handle_t hPolicy,
+                                               size_t partSize);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMPOLICY_H */

include/umf/memspace.h

@@ -13,7 +13,7 @@
 #include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
-#include <umf/memspace_policy.h>
+#include <umf/mempolicy.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -29,7 +29,7 @@ typedef struct umf_memspace_t *umf_memspace_handle_t;
 /// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
 umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t hMemspace,
-                                       umf_memspace_policy_handle_t hPolicy,
+                                       umf_const_mempolicy_handle_t hPolicy,
                                        umf_memory_pool_handle_t *hPool);
 
 ///
@@ -41,7 +41,7 @@ umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t hMemspace,
 ///
 umf_result_t
 umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t hMemspace,
-                                    umf_memspace_policy_handle_t hPolicy,
+                                    umf_const_mempolicy_handle_t hPolicy,
                                     umf_memory_provider_handle_t *hProvider);
 
 ///

scripts/docs_config/api.rst

@@ -104,7 +104,18 @@ TODO: Add general information about memspaces.
 Memspace
 ------------------------------------------
 .. doxygenfile:: memspace.h
-    :sections: define enum typedef func var
+    :sections: define enum typedef func
+
+Mempolicy             
+==========================================
+
+TODO: Add general information about mempolicies.
+
+Mempolicy
+------------------------------------------
+.. doxygenfile:: mempolicy.h
+    :sections: define enum typedef func
+
 
 Inter-Process Communication
 ==========================================
@@ -118,4 +129,4 @@ operations for this API to work. Otherwise IPC APIs return an error.
 IPC API
 ------------------------------------------
 .. doxygenfile:: ipc.h
-    :sections: define enum typedef func var
+    :sections: define enum typedef func var

src/CMakeLists.txt

@@ -58,6 +58,7 @@ set(UMF_SOURCES
     memory_provider.c
     memory_provider_get_last_failed.c
     memory_target.c
+    mempolicy.c
     memspace.c
     provider/provider_tracking.c
     critnib/critnib.c

src/libumf.def.in

@@ -33,6 +33,9 @@ EXPORTS
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
     umfMemoryProviderPutIPCHandle
+    umfMempolicyCreate;
+    umfMempolicyDestroy;
+    umfMempolicySetInterleavePartSize;
     umfMemspaceDestroy
     umfOpenIPCHandle    
     umfOsMemoryProviderOps

src/libumf.map

@@ -28,6 +28,9 @@ UMF_1.0 {
         umfMemoryProviderPurgeForce;
         umfMemoryProviderPurgeLazy;
         umfMemoryProviderPutIPCHandle;
+        umfMempolicyCreate;
+        umfMempolicyDestroy;
+        umfMempolicySetInterleavePartSize;
         umfMemspaceCreateFromNumaArray;
         umfMemspaceDestroy;
         umfMemspaceHighestBandwidthGet;

src/memory_target.h

@@ -16,8 +16,6 @@
 extern "C" {
 #endif
 
-#include "base_alloc.h"
-
 struct umf_memory_target_ops_t;
 typedef struct umf_memory_target_ops_t umf_memory_target_ops_t;
 

src/memory_target_ops.h

@@ -10,8 +10,6 @@
 #ifndef UMF_MEMORY_TARGET_OPS_H
 #define UMF_MEMORY_TARGET_OPS_H 1
 
-#include <stdbool.h>
-
 #include <umf/base.h>
 #include <umf/memspace.h>
 
@@ -33,11 +31,11 @@ typedef struct umf_memory_target_ops_t {
 
     umf_result_t (*pool_create_from_memspace)(
         umf_memspace_handle_t memspace, void **memoryTargets, size_t numTargets,
-        umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool);
+        umf_const_mempolicy_handle_t policy, umf_memory_pool_handle_t *pool);
 
     umf_result_t (*memory_provider_create_from_memspace)(
         umf_memspace_handle_t memspace, void **memoryTargets, size_t numTargets,
-        umf_memspace_policy_handle_t policy,
+        umf_const_mempolicy_handle_t policy,
         umf_memory_provider_handle_t *provider);
 
     umf_result_t (*get_capacity)(void *memoryTarget, size_t *capacity);

src/memory_targets/memory_target_numa.c

@@ -18,6 +18,7 @@
 #include "base_alloc.h"
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
+#include "mempolicy_internal.h"
 #include "topology.h"
 #include "utils_log.h"
 
@@ -48,10 +49,9 @@ static void numa_finalize(void *memTarget) { umf_ba_global_free(memTarget); }
 
 static umf_result_t numa_memory_provider_create_from_memspace(
     umf_memspace_handle_t memspace, void **memTargets, size_t numTargets,
-    umf_memspace_policy_handle_t policy,
+    umf_const_mempolicy_handle_t policy,
     umf_memory_provider_handle_t *provider) {
-    // TODO: apply policy
-    (void)policy;
+
     struct numa_memory_target_t **numaTargets =
         (struct numa_memory_target_t **)memTargets;
 
@@ -70,6 +70,26 @@ static umf_result_t numa_memory_provider_create_from_memspace(
     }
 
     umf_os_memory_provider_params_t params = umfOsMemoryProviderParamsDefault();
+
+    if (policy) {
+        switch (policy->type) {
+        case UMF_MEMPOLICY_INTERLEAVE:
+            params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
+            params.part_size = policy->ops.part_size;
+            break;
+        case UMF_MEMPOLICY_BIND:
+            params.numa_mode = UMF_NUMA_MODE_BIND;
+            break;
+        case UMF_MEMPOLICY_PREFERRED:
+            params.numa_mode = UMF_NUMA_MODE_PREFERRED;
+            break;
+        default:
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+    } else {
+        params.numa_mode = UMF_NUMA_MODE_BIND;
+    }
+
     params.numa_list =
         umf_ba_global_alloc(sizeof(*params.numa_list) * numNodesProvider);
 
@@ -82,7 +102,6 @@ static umf_result_t numa_memory_provider_create_from_memspace(
     }
 
     params.numa_list_len = numNodesProvider;
-    params.numa_mode = UMF_NUMA_MODE_BIND;
 
     umf_memory_provider_handle_t numaProvider = NULL;
     int ret = umfMemoryProviderCreate(umfOsMemoryProviderOps(), &params,
@@ -101,7 +120,7 @@ static umf_result_t numa_memory_provider_create_from_memspace(
 
 static umf_result_t numa_pool_create_from_memspace(
     umf_memspace_handle_t memspace, void **memTargets, size_t numTargets,
-    umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool) {
+    umf_const_mempolicy_handle_t policy, umf_memory_pool_handle_t *pool) {
     (void)memspace;
     (void)memTargets;
     (void)numTargets;

src/mempolicy.c

@@ -0,0 +1,50 @@
+/*
+ *
+ * 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 <umf/mempolicy.h>
+
+#include "base_alloc_global.h"
+#include "mempolicy_internal.h"
+
+umf_result_t umfMempolicyCreate(umf_mempolicy_membind_t bind,
+                                umf_mempolicy_handle_t *policy) {
+    if (policy == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *policy = umf_ba_global_alloc(sizeof(**policy));
+
+    if (*policy == NULL) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    (*policy)->type = bind;
+    if (bind == UMF_MEMPOLICY_INTERLEAVE) {
+        (*policy)->ops.part_size = 0;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMempolicyDestroy(umf_mempolicy_handle_t policy) {
+    umf_ba_global_free(policy);
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMempolicySetInterleavePartSize(umf_mempolicy_handle_t policy,
+                                               size_t partSize) {
+    if (policy == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (policy->type != UMF_MEMPOLICY_INTERLEAVE) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    policy->ops.part_size = partSize;
+    return UMF_RESULT_SUCCESS;
+}

src/mempolicy_internal.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_MEMPOLICY_INTERNAL_H
+#define UMF_MEMPOLICY_INTERNAL_H 1
+
+#include <umf/mempolicy.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_mempolicy_t {
+    umf_mempolicy_membind_t type;
+    union {
+        size_t part_size;
+    } ops;
+} umf_mempolicy_t;
+
+typedef const umf_mempolicy_t umf_const_mempolicy_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMPOLICY_INTERNAL_H */

src/memspace.c

@@ -52,7 +52,7 @@ static umf_result_t memoryTargetHandlesToPriv(umf_memspace_handle_t memspace,
 }
 
 umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
-                                       umf_memspace_policy_handle_t policy,
+                                       umf_const_mempolicy_handle_t policy,
                                        umf_memory_pool_handle_t *pool) {
     if (!memspace || !pool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -77,7 +77,7 @@ umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
 
 umf_result_t
 umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t memspace,
-                                    umf_memspace_policy_handle_t policy,
+                                    umf_const_mempolicy_handle_t policy,
                                     umf_memory_provider_handle_t *provider) {
     if (!memspace || !provider) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;