Expand DEFAULT memspace tests

Those tests confirm that the DEFAULT memspace is composed of
memory targets that correspond to all available NUMA node ids.
They also affirm that the memory obtained from DEFAULT memspace
follows UMF_NUMA_MODE_BIND policy and is made available to all
discovered NUMA nodes.

Author: kswiecicki

test/CMakeLists.txt

@@ -117,13 +117,14 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
                  SRCS provider_os_memory_multiple_numa_nodes.cpp
                  LIBS umf_utils numa)
     add_umf_test(NAME memspace_numa
-                 SRCS memspace_numa.cpp
+                 SRCS memspaces/memspace_numa.cpp
                  LIBS numa)
     add_umf_test(NAME provider_os_memory_config
                  SRCS provider_os_memory_config.cpp
                  LIBS umf_utils numa)
     add_umf_test(NAME memspace_default
-                 SRCS memspace_default.cpp)
+                 SRCS memspaces/memspace_default.cpp
+                 LIBS numa)
 endif()
 
 if(UMF_BUILD_SHARED_LIBRARY)

test/memspace_default.cpp

@@ -0,0 +1,91 @@
+// 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 "memory_target_numa.h"
+#include "memspace_helpers.hpp"
+#include "memspace_internal.h"
+#include "test_helpers.h"
+
+#include <numa.h>
+#include <numaif.h>
+#include <umf/memspace.h>
+
+using umf_test::test;
+
+TEST_F(numaNodesTest, memspaceGet) {
+    umf_memspace_handle_t hMemspace = umfMemspaceDefaultGet();
+    UT_ASSERTne(hMemspace, nullptr);
+
+    // Confirm that the DEFAULT memspace is composed of all available NUMA nodes.
+    UT_ASSERTeq(hMemspace->size, nodeIds.size());
+    for (size_t i = 0; i < hMemspace->size; i++) {
+        // NUMA memory target internally casts the config directly into priv.
+        struct umf_numa_memory_target_config_t *numaTargetCfg =
+            (struct umf_numa_memory_target_config_t *)hMemspace->nodes[i]->priv;
+        UT_ASSERT(std::find(nodeIds.begin(), nodeIds.end(),
+                            numaTargetCfg->id) != nodeIds.end());
+    }
+}
+
+TEST_F(memspaceDefaultTest, providerFromDefaultMemspace) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    enum umf_result_t ret =
+        umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    UT_ASSERTne(hProvider, nullptr);
+
+    umfMemoryProviderDestroy(hProvider);
+}
+
+TEST_F(memspaceDefaultProviderTest, allocFree) {
+    void *ptr = nullptr;
+    size_t size = SIZE_4K;
+    size_t alignment = 0;
+
+    enum umf_result_t ret =
+        umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    UT_ASSERTne(ptr, nullptr);
+
+    memset(ptr, 0xFF, size);
+
+    ret = umfMemoryProviderFree(hProvider, ptr, size);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+}
+
+TEST_F(memspaceDefaultProviderTest, memoryPolicy) {
+    void *ptr = nullptr;
+    size_t size = SIZE_4K;
+    size_t alignment = 0;
+
+    enum umf_result_t umf_ret =
+        umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
+    UT_ASSERTeq(umf_ret, UMF_RESULT_SUCCESS);
+    UT_ASSERTne(ptr, nullptr);
+
+    auto it = std::max_element(nodeIds.begin(), nodeIds.end());
+    UT_ASSERT(it != nodeIds.end());
+
+    unsigned long maxNodeId = *it;
+
+    unsigned bitsPerUlong = sizeof(unsigned long) * 8;
+    unsigned nrUlongs = (maxNodeId + bitsPerUlong) / bitsPerUlong;
+    std::vector<unsigned long> memNodeMasks(nrUlongs, 0);
+
+    int memMode = -1;
+    int ret = get_mempolicy(&memMode, memNodeMasks.data(),
+                            nrUlongs * bitsPerUlong, ptr, MPOL_F_ADDR);
+    UT_ASSERTeq(ret, 0);
+    // Obtained memory should be bound to all available NUMA nodes.
+    UT_ASSERTeq(memMode, MPOL_BIND);
+    for (auto &nodeId : nodeIds) {
+        size_t memNodeMaskIdx = ((nodeId + bitsPerUlong) / bitsPerUlong) - 1;
+        auto &memNodeMask = memNodeMasks.at(memNodeMaskIdx);
+
+        UT_ASSERT(memNodeMask && (1UL << (nodeId % bitsPerUlong)));
+    }
+
+    umf_ret = umfMemoryProviderFree(hProvider, ptr, size);
+    UT_ASSERTeq(umf_ret, UMF_RESULT_SUCCESS);
+}