Merge pull request #331 from igchor/high_capacity_memspace

High capacity memspace

Author: bratpiorka

README.md

@@ -192,9 +192,10 @@ TODO: Add general information about memspaces.
 Memspace backed by all available NUMA nodes discovered on the platform. Can be retrieved
 using umfMemspaceHostAllGet.
 
-##### Requirements
+#### Highest capacity memspace
 
-This feature relies on the OS memory provider.
+Memspace backed by all available NUMA nodes discovered on the platform sorted by capacity.
+Can be retrieved using umfMemspaceHighestCapacityGet.
 
 ## Contributions
 

include/umf/memspace.h

@@ -50,6 +50,12 @@ umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t hMemspace,
 ///
 umf_memspace_handle_t umfMemspaceHostAllGet(void);
 
+///
+/// \brief Retrieves predefined highest capacity memspace.
+/// \return highest capacity memspace handle on success or NULL on failure.
+///
+umf_memspace_handle_t umfMemspaceHighestCapacityGet(void);
+
 #ifdef __cplusplus
 }
 #endif

src/CMakeLists.txt

@@ -60,7 +60,8 @@ set(UMF_SOURCES
     memspace.c
     provider/provider_tracking.c
     critnib/critnib.c
-    pool/pool_proxy.c)
+    pool/pool_proxy.c
+    topology.c)
 
 set(UMF_SOURCES_LINUX libumf_linux.c)
 
@@ -77,7 +78,8 @@ set(UMF_SOURCES_LINUX
     provider/provider_os_memory_linux.c
     memory_targets/memory_target_numa.c
     memspaces/memspace_numa.c
-    memspaces/memspace_host_all.c)
+    memspaces/memspace_host_all.c
+    memspaces/memspace_highest_capacity.c)
 
 set(UMF_SOURCES_WINDOWS ${UMF_SOURCES_WINDOWS} provider/provider_os_memory.c
                         provider/provider_os_memory_windows.c)

src/libumf.map

@@ -22,6 +22,7 @@ UMF_1.0 {
         umfMemoryProviderPurgeLazy;
         umfMemspaceCreateFromNumaArray;
         umfMemspaceDestroy;
+        umfMemspaceHighestCapacityGet;
         umfMemspaceHostAllGet;
         umfOsMemoryProviderOps;
         umfPoolAlignedMalloc;

src/libumf_linux.c

@@ -10,8 +10,9 @@
 #include <stddef.h>
 
 #include "base_alloc_global.h"
-#include "memspace_host_all_internal.h"
+#include "memspace_internal.h"
 #include "provider_tracking.h"
+#include "topology.h"
 #include "utils_log.h"
 
 umf_memory_tracker_handle_t TRACKER = NULL;
@@ -27,6 +28,8 @@ void __attribute__((destructor)) umfDestroy(void) {
     TRACKER = NULL;
     umfMemoryTrackerDestroy(t);
     umfMemspaceHostAllDestroy();
+    umfMemspaceHighestCapacityDestroy();
+    umfDestroyTopology();
 }
 
 void libumfInit(void) {

src/memory_target.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -53,3 +53,34 @@ void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget) {
     memoryTarget->ops->finalize(memoryTarget->priv);
     umf_ba_global_free(memoryTarget);
 }
+
+umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget,
+                                  umf_memory_target_handle_t *outHandle) {
+    assert(memoryTarget);
+    assert(outHandle);
+
+    *outHandle =
+        (umf_memory_target_t *)umf_ba_global_alloc(sizeof(umf_memory_target_t));
+    if (!*outHandle) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    void *outPriv;
+    umf_result_t ret = memoryTarget->ops->clone(memoryTarget->priv, &outPriv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        umf_ba_global_free(*outHandle);
+        return ret;
+    }
+
+    (*outHandle)->ops = memoryTarget->ops;
+    (*outHandle)->priv = outPriv;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget,
+                                        size_t *capacity) {
+    assert(memoryTarget);
+    assert(capacity);
+    return memoryTarget->ops->get_capacity(memoryTarget->priv, capacity);
+}

src/memory_target.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -31,9 +31,13 @@ typedef umf_memory_target_t *umf_memory_target_handle_t;
 umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
                                    void *params,
                                    umf_memory_target_handle_t *memoryTarget);
-
 void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget);
 
+umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget,
+                                  umf_memory_target_handle_t *outHandle);
+umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget,
+                                        size_t *capacity);
+
 #ifdef __cplusplus
 }
 #endif

src/memory_target_ops.h

@@ -29,6 +29,8 @@ typedef struct umf_memory_target_ops_t {
     umf_result_t (*initialize)(void *params, void **memoryTarget);
     void (*finalize)(void *memoryTarget);
 
+    umf_result_t (*clone)(void *memoryTarget, void **outMemoryTarget);
+
     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);
@@ -37,6 +39,8 @@ typedef struct umf_memory_target_ops_t {
         umf_memspace_handle_t memspace, void **memoryTargets, size_t numTargets,
         umf_memspace_policy_handle_t policy,
         umf_memory_provider_handle_t *provider);
+
+    umf_result_t (*get_capacity)(void *memoryTarget, size_t *capacity);
 } umf_memory_target_ops_t;
 
 #ifdef __cplusplus

src/memory_targets/memory_target_numa.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -18,6 +18,7 @@
 #include "base_alloc.h"
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
+#include "topology.h"
 
 struct numa_memory_target_t {
     size_t id;
@@ -150,10 +151,47 @@ static umf_result_t numa_pool_create_from_memspace(
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t numa_clone(void *memTarget, void **outMemTarget) {
+    struct numa_memory_target_t *numaTarget =
+        (struct numa_memory_target_t *)memTarget;
+    struct numa_memory_target_t *newNumaTarget =
+        umf_ba_global_alloc(sizeof(struct numa_memory_target_t));
+    if (!newNumaTarget) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    newNumaTarget->id = numaTarget->id;
+    *outMemTarget = newNumaTarget;
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_result_t numa_get_capacity(void *memTarget, size_t *capacity) {
+    hwloc_topology_t topology = umfGetTopology();
+    if (!topology) {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    hwloc_obj_t numaNode =
+        hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE,
+                              ((struct numa_memory_target_t *)memTarget)->id);
+    if (!numaNode) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (!numaNode->attr) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *capacity = numaNode->attr->numanode.local_memory;
+    return UMF_RESULT_SUCCESS;
+}
+
 struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = {
     .version = UMF_VERSION_CURRENT,
     .initialize = numa_initialize,
     .finalize = numa_finalize,
     .pool_create_from_memspace = numa_pool_create_from_memspace,
+    .clone = numa_clone,
+    .get_capacity = numa_get_capacity,
     .memory_provider_create_from_memspace =
         numa_memory_provider_create_from_memspace};

src/memspace.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -109,3 +109,102 @@ void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
     umf_ba_global_free(memspace->nodes);
     umf_ba_global_free(memspace);
 }
+
+enum umf_result_t umfMemspaceClone(umf_memspace_handle_t hMemspace,
+                                   umf_memspace_handle_t *outHandle) {
+    if (!hMemspace || !outHandle) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memspace_handle_t clone =
+        umf_ba_global_alloc(sizeof(struct umf_memspace_t));
+    if (!clone) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    clone->size = hMemspace->size;
+    clone->nodes =
+        umf_ba_global_alloc(sizeof(umf_memory_target_handle_t) * clone->size);
+    if (!clone->nodes) {
+        umf_ba_global_free(clone);
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    size_t i;
+    umf_result_t ret;
+
+    for (i = 0; i < clone->size; i++) {
+        ret = umfMemoryTargetClone(hMemspace->nodes[i], &clone->nodes[i]);
+        if (ret != UMF_RESULT_SUCCESS) {
+            goto err;
+        }
+    }
+
+    *outHandle = clone;
+
+    return UMF_RESULT_SUCCESS;
+err:
+    while (i != 0) {
+        i--;
+        umfMemoryTargetDestroy(clone->nodes[i]);
+    }
+    umf_ba_global_free(clone->nodes);
+    umf_ba_global_free(clone);
+    return ret;
+}
+
+struct memory_target_sort_entry {
+    uint64_t property;
+    umf_memory_target_handle_t node;
+};
+
+static int propertyCmp(const void *a, const void *b) {
+    const struct memory_target_sort_entry *entryA = a;
+    const struct memory_target_sort_entry *entryB = b;
+
+    if (entryA->property < entryB->property) {
+        return 1;
+    } else if (entryA->property > entryB->property) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+enum umf_result_t
+umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
+                    umf_result_t (*getProperty)(umf_memory_target_handle_t node,
+                                                uint64_t *property)) {
+    if (!hMemspace || !getProperty) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    struct memory_target_sort_entry *entries = umf_ba_global_alloc(
+        sizeof(struct memory_target_sort_entry) * hMemspace->size);
+    if (!entries) {
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    // create temporary array that contains desired property values for sorting
+    for (size_t i = 0; i < hMemspace->size; i++) {
+        entries[i].node = hMemspace->nodes[i];
+        umf_result_t ret =
+            getProperty(hMemspace->nodes[i], &entries[i].property);
+        if (ret != UMF_RESULT_SUCCESS) {
+            umf_ba_global_free(entries);
+            return ret;
+        }
+    }
+
+    qsort(entries, hMemspace->size, sizeof(struct memory_target_sort_entry),
+          propertyCmp);
+
+    // apply the order to the original array
+    for (size_t i = 0; i < hMemspace->size; i++) {
+        hMemspace->nodes[i] = entries[i].node;
+    }
+
+    umf_ba_global_free(entries);
+
+    return UMF_RESULT_SUCCESS;
+}

src/memspace_internal.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -24,12 +24,30 @@ struct umf_memspace_t {
     umf_memory_target_handle_t *nodes;
 };
 
+///
+/// \brief Clones memspace
+///
+enum umf_result_t umfMemspaceClone(umf_memspace_handle_t hMemspace,
+                                   umf_memspace_handle_t *outHandle);
+
+typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t,
+                                         uint64_t *);
+
+///
+/// \brief Sorts memspace by getProperty() in descending order
+///
+enum umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
+                                      umfGetPropertyFn getProperty);
+
 ///
 /// \brief Destroys memspace
 /// \param hMemspace handle to memspace
 ///
 void umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
 
+void umfMemspaceHostAllDestroy(void);
+void umfMemspaceHighestCapacityDestroy(void);
+
 #ifdef __cplusplus
 }
 #endif