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

@@ -123,7 +123,8 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
                  SRCS provider_os_memory_config.cpp
                  LIBS umf_utils numa)
     add_umf_test(NAME memspace_default
-                 SRCS memspaces/memspace_default.cpp)
+                 SRCS memspaces/memspace_default.cpp
+                 LIBS numa)
 endif()
 
 if(UMF_BUILD_SHARED_LIBRARY)

test/memspaces/memspace_default.cpp

@@ -2,64 +2,90 @@
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "base.hpp"
+#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;
 
-#define SIZE_4K (4096)
-
-struct predefinedMemspaceTest : test {
-
-    void SetUp() override {
-        ::test::SetUp();
-
-        hMemspace = umfMemspaceDefaultGet();
-        UT_ASSERTne(hMemspace, nullptr);
-    }
-
-    umf_memspace_handle_t hMemspace;
-};
-
-struct predefinedMemspaceProviderTest : predefinedMemspaceTest {
-
-    void SetUp() override {
-        ::predefinedMemspaceTest::SetUp();
-
-        enum umf_result_t ret =
-            umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &provider);
-        UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
-        UT_ASSERTne(provider, nullptr);
-    }
-
-    void TearDown() override {
-        ::predefinedMemspaceTest::TearDown();
+TEST_F(numaNodesTest, memspaceGet) {
+    umf_memspace_handle_t hMemspace = umfMemspaceDefaultGet();
+    UT_ASSERTne(hMemspace, nullptr);
 
-        umfMemoryProviderDestroy(provider);
+    // 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());
     }
+}
 
-    umf_memory_provider_handle_t provider = nullptr;
-};
+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);
 
-TEST_F(test, memspaceGet) {
-    umf_memspace_handle_t hMemspace = umfMemspaceDefaultGet();
-    UT_ASSERTne(hMemspace, nullptr);
+    umfMemoryProviderDestroy(hProvider);
 }
 
-TEST_F(predefinedMemspaceProviderTest, allocFree) {
+TEST_F(memspaceDefaultProviderTest, allocFree) {
     void *ptr = nullptr;
     size_t size = SIZE_4K;
     size_t alignment = 0;
 
     enum umf_result_t ret =
-        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
     UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
     UT_ASSERTne(ptr, nullptr);
 
     memset(ptr, 0xFF, size);
 
-    ret = umfMemoryProviderFree(provider, ptr, 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);
+}

test/memspaces/memspace_helpers.hpp

@@ -0,0 +1,111 @@
+// 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_MEMSPACE_HELPERS_HPP
+#define UMF_MEMSPACE_HELPERS_HPP
+
+#include "base.hpp"
+#include "memspace_internal.h"
+#include "memspaces/memspace_numa.h"
+
+#include <numa.h>
+#include <umf/providers/provider_os_memory.h>
+
+#define SIZE_4K (4096)
+
+struct numaNodesTest : ::umf_test::test {
+    void SetUp() override {
+        ::umf_test::test::SetUp();
+
+        if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
+            GTEST_SKIP() << "Failed to initialize libnuma";
+        }
+
+        int maxNode = numa_max_node();
+        if (maxNode < 0) {
+            GTEST_SKIP() << "No available numa nodes";
+        }
+
+        for (int i = 0; i <= maxNode; i++) {
+            if (numa_bitmask_isbitset(numa_all_nodes_ptr, i) == 1) {
+                nodeIds.emplace_back(i);
+            }
+        }
+    }
+
+    std::vector<size_t> nodeIds;
+};
+
+struct memspaceNumaTest : ::numaNodesTest {
+    void SetUp() override {
+        ::numaNodesTest::SetUp();
+
+        if (nodeIds.size()) {
+            enum umf_result_t ret = umfMemspaceCreateFromNumaArray(
+                nodeIds.data(), nodeIds.size(), &hMemspace);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+            ASSERT_NE(hMemspace, nullptr);
+        }
+    }
+
+    void TearDown() override {
+        ::numaNodesTest::TearDown();
+        if (hMemspace) {
+            umfMemspaceDestroy(hMemspace);
+        }
+    }
+
+    umf_memspace_handle_t hMemspace = nullptr;
+};
+
+struct memspaceNumaProviderTest : ::memspaceNumaTest {
+    void SetUp() override {
+        ::memspaceNumaTest::SetUp();
+
+        umf_result_t ret =
+            umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(hProvider, nullptr);
+    }
+
+    void TearDown() override {
+        ::memspaceNumaTest::TearDown();
+
+        umfMemoryProviderDestroy(hProvider);
+    }
+
+    umf_memory_provider_handle_t hProvider = nullptr;
+};
+
+struct memspaceDefaultTest : ::numaNodesTest {
+    void SetUp() override {
+        ::numaNodesTest::SetUp();
+
+        hMemspace = umfMemspaceDefaultGet();
+        ASSERT_NE(hMemspace, nullptr);
+    }
+
+    umf_memspace_handle_t hMemspace = nullptr;
+};
+
+struct memspaceDefaultProviderTest : ::memspaceDefaultTest {
+    void SetUp() override {
+        ::memspaceDefaultTest::SetUp();
+
+        umf_result_t ret =
+            umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(hProvider, nullptr);
+    }
+
+    void TearDown() override {
+        ::memspaceDefaultTest::TearDown();
+
+        umfMemoryProviderDestroy(hProvider);
+    }
+
+    umf_memory_provider_handle_t hProvider = nullptr;
+};
+
+#endif /* UMF_MEMSPACE_HELPERS_HPP */

test/memspaces/memspace_numa.cpp

@@ -2,81 +2,14 @@
 // 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_helpers.hpp"
 #include "memspace_internal.h"
-#include "memspaces/memspace_numa.h"
 
 #include <umf/providers/provider_os_memory.h>
 
-#include <numa.h>
-
-#define SIZE_4K (4096)
-
-struct numa_nodes_test : ::umf_test::test {
-    void SetUp() override {
-        ::umf_test::test::SetUp();
-
-        if (numa_available() == -1) {
-            GTEST_SKIP() << "Failed to initialize libnuma";
-        }
-
-        int numNodes = numa_max_node();
-        if (numNodes < 0) {
-            GTEST_SKIP() << "No available numa nodes";
-        }
-
-        for (int i = 0; i <= numNodes; i++) {
-            nodeIds.emplace_back(i);
-        }
-    }
-
-    std::vector<size_t> nodeIds;
-};
-
-struct numa_memspace_test : ::numa_nodes_test {
-    void SetUp() override {
-        ::numa_nodes_test::SetUp();
-        if (nodeIds.size()) {
-            enum umf_result_t ret = umfMemspaceCreateFromNumaArray(
-                nodeIds.data(), nodeIds.size(), &memspace);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            ASSERT_NE(memspace, nullptr);
-        }
-    }
-
-    void TearDown() override {
-        ::numa_nodes_test::TearDown();
-        if (memspace) {
-            umfMemspaceDestroy(memspace);
-        }
-    }
-
-    umf_memspace_handle_t memspace = nullptr;
-};
-
-struct numa_memspace_provider_test : ::numa_memspace_test {
-    void SetUp() override {
-        ::numa_memspace_test::SetUp();
-        if (nodeIds.size()) {
-            umf_result_t ret = umfMemoryProviderCreateFromMemspace(
-                memspace, nullptr, &provider);
-            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-            ASSERT_NE(provider, nullptr);
-        }
-    }
-
-    void TearDown() override {
-        ::numa_memspace_test::TearDown();
-        if (provider) {
-            umfMemoryProviderDestroy(provider);
-        }
-    }
-
-    umf_memory_provider_handle_t provider = nullptr;
-};
-
-TEST_F(numa_nodes_test, create_destroy) {
+TEST_F(numaNodesTest, createDestroy) {
     umf_memspace_handle_t hMemspace = nullptr;
     enum umf_result_t ret = umfMemspaceCreateFromNumaArray(
         nodeIds.data(), nodeIds.size(), &hMemspace);
@@ -86,49 +19,49 @@ TEST_F(numa_nodes_test, create_destroy) {
     umfMemspaceDestroy(hMemspace);
 }
 
-TEST_F(numa_nodes_test, create_null_array) {
+TEST_F(numaNodesTest, createNullArray) {
     umf_memspace_handle_t hMemspace = nullptr;
     enum umf_result_t ret = umfMemspaceCreateFromNumaArray(NULL, 0, &hMemspace);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(hMemspace, nullptr);
 }
 
-TEST_F(numa_nodes_test, create_zero_size) {
+TEST_F(numaNodesTest, createZeroSize) {
     umf_memspace_handle_t hMemspace = nullptr;
     enum umf_result_t ret =
         umfMemspaceCreateFromNumaArray(nodeIds.data(), 0, &hMemspace);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
     ASSERT_EQ(hMemspace, nullptr);
 }
 
-TEST_F(numa_nodes_test, create_null_handle) {
+TEST_F(numaNodesTest, createNullHandle) {
     enum umf_result_t ret =
         umfMemspaceCreateFromNumaArray(nodeIds.data(), nodeIds.size(), nullptr);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
-TEST_F(numa_memspace_test, provider_from_numa_memspace) {
-    umf_memory_provider_handle_t provider = nullptr;
+TEST_F(memspaceNumaTest, providerFromNumaMemspace) {
+    umf_memory_provider_handle_t hProvider = nullptr;
     enum umf_result_t ret =
-        umfMemoryProviderCreateFromMemspace(memspace, nullptr, &provider);
+        umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-    ASSERT_NE(provider, nullptr);
+    ASSERT_NE(hProvider, nullptr);
 
-    umfMemoryProviderDestroy(provider);
+    umfMemoryProviderDestroy(hProvider);
 }
 
-TEST_F(numa_memspace_provider_test, alloc_free) {
+TEST_F(memspaceNumaProviderTest, allocFree) {
     void *ptr = nullptr;
     size_t size = SIZE_4K;
     size_t alignment = 0;
 
     enum umf_result_t ret =
-        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+        umfMemoryProviderAlloc(hProvider, size, alignment, &ptr);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(ptr, nullptr);
 
     memset(ptr, 0xFF, size);
 
-    ret = umfMemoryProviderFree(provider, ptr, size);
+    ret = umfMemoryProviderFree(hProvider, ptr, size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }