add to header and export umfMemspaceCreateFromNumaArray

include/umf/memspace.h

@@ -20,6 +20,7 @@ extern "C" {
 #endif
 
 typedef struct umf_memspace_t *umf_memspace_handle_t;
+typedef const struct umf_memspace_t *umf_const_memspace_handle_t;
 
 ///
 /// \brief Creates new memory pool from memspace and policy.
@@ -28,7 +29,7 @@ typedef struct umf_memspace_t *umf_memspace_handle_t;
 /// \param hPool [out] handle to the newly created memory pool
 /// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
-umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t hMemspace,
+umf_result_t umfPoolCreateFromMemspace(umf_const_memspace_handle_t hMemspace,
                                        umf_const_mempolicy_handle_t hPolicy,
                                        umf_memory_pool_handle_t *hPool);
 
@@ -40,33 +41,48 @@ umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t hMemspace,
 /// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
 umf_result_t
-umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t hMemspace,
+umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t hMemspace,
                                     umf_const_mempolicy_handle_t hPolicy,
                                     umf_memory_provider_handle_t *hProvider);
+///
+/// \brief Creates new memspace from array of NUMA node ids.
+/// \param nodeIds array of NUMA node ids
+/// \param numIds size of the array
+/// \param hMemspace [out] handle to the newly created memspace
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
+                                            umf_memspace_handle_t *hMemspace);
+
+///
+/// \brief Destroys memspace
+/// \param hMemspace handle to memspace
+///
+void umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
 
 ///
 /// \brief Retrieves predefined host all memspace.
 /// \return host all memspace handle on success or NULL on failure.
 ///
-umf_memspace_handle_t umfMemspaceHostAllGet(void);
+umf_const_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);
+umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void);
 
 /// \brief Retrieves predefined highest bandwidth memspace.
 /// \return highest bandwidth memspace handle on success or NULL on
 ///         failure (no HMAT support).
 ///
-umf_memspace_handle_t umfMemspaceHighestBandwidthGet(void);
+umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void);
 
 /// \brief Retrieves predefined lowest latency memspace.
 /// \return lowest latency memspace handle on success or NULL on
 ///         failure (no HMAT support).
 ///
-umf_memspace_handle_t umfMemspaceLowestLatencyGet(void);
+umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void);
 
 #ifdef __cplusplus
 }

src/memory_target_ops.h

@@ -30,12 +30,13 @@ typedef struct umf_memory_target_ops_t {
     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_const_mempolicy_handle_t policy, umf_memory_pool_handle_t *pool);
+        umf_const_memspace_handle_t memspace, void **memoryTargets,
+        size_t numTargets, 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_const_mempolicy_handle_t policy,
+        umf_const_memspace_handle_t memspace, void **memoryTargets,
+        size_t numTargets, 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

@@ -49,7 +49,7 @@ static umf_result_t numa_initialize(void *params, void **memTarget) {
 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_const_memspace_handle_t memspace, void **memTargets, size_t numTargets,
     umf_const_mempolicy_handle_t policy,
     umf_memory_provider_handle_t *provider) {
 
@@ -151,7 +151,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_const_memspace_handle_t memspace, void **memTargets, size_t numTargets,
     umf_const_mempolicy_handle_t policy, umf_memory_pool_handle_t *pool) {
     (void)memspace;
     (void)memTargets;

src/memspace.c

@@ -18,7 +18,8 @@
 #include "memspace_internal.h"
 
 #ifndef NDEBUG
-static umf_result_t verifyMemTargetsTypes(umf_memspace_handle_t memspace) {
+static umf_result_t
+verifyMemTargetsTypes(umf_const_memspace_handle_t memspace) {
     assert(memspace);
     if (memspace->size == 0) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -35,8 +36,9 @@ static umf_result_t verifyMemTargetsTypes(umf_memspace_handle_t memspace) {
 }
 #endif
 
-static umf_result_t memoryTargetHandlesToPriv(umf_memspace_handle_t memspace,
-                                              void ***pPrivs) {
+static umf_result_t
+memoryTargetHandlesToPriv(umf_const_memspace_handle_t memspace,
+                          void ***pPrivs) {
     assert(memspace);
     void **privs = umf_ba_global_alloc(sizeof(void *) * memspace->size);
     if (privs == NULL) {
@@ -51,7 +53,7 @@ static umf_result_t memoryTargetHandlesToPriv(umf_memspace_handle_t memspace,
     return UMF_RESULT_SUCCESS;
 }
 
-umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
+umf_result_t umfPoolCreateFromMemspace(umf_const_memspace_handle_t memspace,
                                        umf_const_mempolicy_handle_t policy,
                                        umf_memory_pool_handle_t *pool) {
     if (!memspace || !pool) {
@@ -76,7 +78,7 @@ umf_result_t umfPoolCreateFromMemspace(umf_memspace_handle_t memspace,
 }
 
 umf_result_t
-umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t memspace,
+umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t memspace,
                                     umf_const_mempolicy_handle_t policy,
                                     umf_memory_provider_handle_t *provider) {
     if (!memspace || !provider) {
@@ -110,7 +112,7 @@ void umfMemspaceDestroy(umf_memspace_handle_t memspace) {
     umf_ba_global_free(memspace);
 }
 
-umf_result_t umfMemspaceClone(umf_memspace_handle_t hMemspace,
+umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
                               umf_memspace_handle_t *outHandle) {
     if (!hMemspace || !outHandle) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -209,7 +211,7 @@ umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
     return UMF_RESULT_SUCCESS;
 }
 
-umf_result_t umfMemspaceFilter(umf_memspace_handle_t hMemspace,
+umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
                                umfGetTargetFn getTarget,
                                umf_memspace_handle_t *filteredMemspace) {
     if (!hMemspace || !getTarget) {

src/memspace_internal.h

@@ -27,7 +27,7 @@ struct umf_memspace_t {
 ///
 /// \brief Clones memspace
 ///
-umf_result_t umfMemspaceClone(umf_memspace_handle_t hMemspace,
+umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
                               umf_memspace_handle_t *outHandle);
 
 typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t,
@@ -47,16 +47,10 @@ typedef umf_result_t (*umfGetTargetFn)(umf_memory_target_handle_t initiator,
 ///
 /// \brief Filters the targets using getTarget() to create a new memspace
 ///
-umf_result_t umfMemspaceFilter(umf_memspace_handle_t hMemspace,
+umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
                                umfGetTargetFn getTarget,
                                umf_memspace_handle_t *filteredMemspace);
 
-///
-/// \brief Destroys memspace
-/// \param hMemspace handle to memspace
-///
-void umfMemspaceDestroy(umf_memspace_handle_t hMemspace);
-
 void umfMemspaceHostAllDestroy(void);
 void umfMemspaceHighestCapacityDestroy(void);
 void umfMemspaceHighestBandwidthDestroy(void);

src/memspaces/memspace_highest_bandwidth.c

@@ -15,7 +15,6 @@
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
 #include "memspace_internal.h"
-#include "memspace_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -52,7 +51,7 @@ umfMemspaceHighestBandwidthCreate(umf_memspace_handle_t *hMemspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
+    umf_const_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
     if (!hostAllMemspace) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -97,7 +96,7 @@ static void umfMemspaceHighestBandwidthInit(void) {
     }
 }
 
-umf_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
+umf_const_memspace_handle_t umfMemspaceHighestBandwidthGet(void) {
     util_init_once(&UMF_MEMSPACE_HBW_INITIALIZED,
                    umfMemspaceHighestBandwidthInit);
     return UMF_MEMSPACE_HIGHEST_BANDWIDTH;

src/memspaces/memspace_highest_capacity.c

@@ -14,7 +14,6 @@
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
 #include "memspace_internal.h"
-#include "memspace_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 
@@ -24,7 +23,7 @@ umfMemspaceHighestCapacityCreate(umf_memspace_handle_t *hMemspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
+    umf_const_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
     if (!hostAllMemspace) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -69,7 +68,7 @@ static void umfMemspaceHighestCapacityInit(void) {
     (void)ret;
 }
 
-umf_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
+umf_const_memspace_handle_t umfMemspaceHighestCapacityGet(void) {
     util_init_once(&UMF_MEMSPACE_HIGHEST_CAPACITY_INITIALIZED,
                    umfMemspaceHighestCapacityInit);
     return UMF_MEMSPACE_HIGHEST_CAPACITY;

src/memspaces/memspace_host_all.c

@@ -14,7 +14,6 @@
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
 #include "memspace_internal.h"
-#include "memspace_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 
@@ -91,7 +90,7 @@ static void umfMemspaceHostAllInit(void) {
     // doesn't support Windows.
 }
 
-umf_memspace_handle_t umfMemspaceHostAllGet(void) {
+umf_const_memspace_handle_t umfMemspaceHostAllGet(void) {
     util_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit);
     return UMF_MEMSPACE_HOST_ALL;
 }

src/memspaces/memspace_lowest_latency.c

@@ -15,7 +15,6 @@
 #include "base_alloc_global.h"
 #include "memory_target_numa.h"
 #include "memspace_internal.h"
-#include "memspace_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -52,7 +51,7 @@ umfMemspaceLowestLatencyCreate(umf_memspace_handle_t *hMemspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
+    umf_const_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
     if (!hostAllMemspace) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -97,7 +96,7 @@ static void umfMemspaceLowestLatencyInit(void) {
 #endif
 }
 
-umf_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
+umf_const_memspace_handle_t umfMemspaceLowestLatencyGet(void) {
     util_init_once(&UMF_MEMSPACE_LOWEST_LATENCY_INITIALIZED,
                    umfMemspaceLowestLatencyInit);
     return UMF_MEMSPACE_LOWEST_LATENCY;

src/memspaces/memspace_numa.c

@@ -12,7 +12,6 @@
 #include "../memory_targets/memory_target_numa.h"
 #include "../memspace_internal.h"
 #include "base_alloc_global.h"
-#include "memspace_numa.h"
 
 umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
                                             umf_memspace_handle_t *hMemspace) {

test/memspaces/memspace_fixtures.hpp

@@ -50,7 +50,7 @@ struct numaNodesTest : ::umf_test::test {
 };
 
 using isQuerySupportedFunc = bool (*)(size_t);
-using memspaceGetFunc = umf_memspace_handle_t (*)();
+using memspaceGetFunc = umf_const_memspace_handle_t (*)();
 using memspaceGetParams = std::tuple<isQuerySupportedFunc, memspaceGetFunc>;
 
 struct memspaceGetTest : ::numaNodesTest,
@@ -68,7 +68,7 @@ struct memspaceGetTest : ::numaNodesTest,
         ASSERT_NE(hMemspace, nullptr);
     }
 
-    umf_memspace_handle_t hMemspace = nullptr;
+    umf_const_memspace_handle_t hMemspace = nullptr;
 };
 
 struct memspaceProviderTest : ::memspaceGetTest {

test/memspaces/memspace_helpers.hpp

@@ -7,7 +7,6 @@
 
 #include "base.hpp"
 #include "memspace_internal.h"
-#include "memspaces/memspace_numa.h"
 #include "test_helpers.h"
 
 #include <numa.h>

test/memspaces/memspace_highest_capacity.cpp

@@ -20,7 +20,7 @@ struct memspaceHighestCapacityProviderTest : ::numaNodesTest {
     void SetUp() override {
         ::numaNodesTest::SetUp();
 
-        umf_memspace_handle_t hMemspace = umfMemspaceHighestCapacityGet();
+        umf_const_memspace_handle_t hMemspace = umfMemspaceHighestCapacityGet();
         UT_ASSERTne(hMemspace, nullptr);
 
         umf_result_t ret =

test/memspaces/memspace_host_all.cpp

@@ -27,7 +27,7 @@ struct memspaceHostAllTest : ::numaNodesTest {
         ASSERT_NE(hMemspace, nullptr);
     }
 
-    umf_memspace_handle_t hMemspace = nullptr;
+    umf_const_memspace_handle_t hMemspace = nullptr;
 };
 
 struct memspaceHostAllProviderTest : ::memspaceHostAllTest {
@@ -50,7 +50,7 @@ struct memspaceHostAllProviderTest : ::memspaceHostAllTest {
 };
 
 TEST_F(numaNodesTest, memspaceGet) {
-    umf_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
+    umf_const_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
     UT_ASSERTne(hMemspace, nullptr);
 
     // Confirm that the HOST ALL memspace is composed of all available NUMA nodes.
@@ -95,7 +95,7 @@ TEST_F(memspaceHostAllProviderTest, hostAllDefaults) {
     // default parameters based on default memspace (HostAll) uses the fast,
     // default kernel path (no mbind).
 
-    umf_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
+    umf_const_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
     UT_ASSERTne(hMemspace, nullptr);
 
     umf_memory_provider_handle_t hProvider = nullptr;

test/memspaces/memspace_numa.cpp

@@ -2,7 +2,6 @@
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "memspaces/memspace_numa.h"
 #include "base.hpp"
 #include "memspace_fixtures.hpp"
 #include "memspace_helpers.hpp"