Fix memspace_highest_capacity test

The test was using get_mempolicy to verify whether allocation
was done on a specific node but params to get_mem_policy were wrong.

Instead of returning the nodeId, get_mempolicy was returning a policy
associated with the address which was always: all nodes set.

Author: igchor

.github/workflows/qemu.yml

@@ -73,11 +73,11 @@ jobs:
         -machine q35,usb=off,hmat=on \
         -enable-kvm \
         -net nic -net user,hostfwd=tcp::2222-:22 \
-        -m 3G \
+        -m 3500M \
         -smp 4 \
-        -object memory-backend-ram,size=1G,id=ram0 \
-        -object memory-backend-ram,size=1G,id=ram1 \
-        -object memory-backend-ram,size=1G,id=ram2 \
+        -object memory-backend-ram,size=1100M,id=ram0 \
+        -object memory-backend-ram,size=1200M,id=ram1 \
+        -object memory-backend-ram,size=1200M,id=ram2 \
         -numa node,nodeid=0,memdev=ram0,cpus=0-1 \
         -numa node,nodeid=1,memdev=ram1,cpus=2-3 \
         -numa node,nodeid=2,memdev=ram2,initiator=0 \

scripts/qemu/run-build.sh

@@ -36,3 +36,6 @@ make -j $(nproc)
 
 ctest --output-on-failure
 
+# run tests bound to a numa node
+numactl -N 0 ctest --output-on-failure
+numactl -N 1 ctest --output-on-failure

test/common/numa_helpers.h

@@ -0,0 +1,33 @@
+// 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
+// This file contains helpers for tests for UMF pool API
+
+#ifndef UMF_NUMA_HELPERS_H
+#define UMF_NUMA_HELPERS_H 1
+
+#include <numa.h>
+#include <numaif.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "test_helpers.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// returns the node where page starting at 'ptr' resides
+int getNumaNodeByPtr(void *ptr) {
+    int nodeId;
+    int retm =
+        get_mempolicy(&nodeId, nullptr, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
+    UT_ASSERTeq(retm, 0);
+    return nodeId;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_NUMA_HELPERS_H */

test/memspaces/memspace_highest_capacity.cpp

@@ -5,6 +5,7 @@
 #include "memory_target_numa.h"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "numa_helpers.h"
 #include "test_helpers.h"
 #include "utils_sanitizers.h"
 
@@ -40,28 +41,29 @@ TEST_F(memspaceHighestCapacityProviderTest, highestCapacityVerify) {
     static constexpr size_t alloc_size = 1024;
 
     long long maxCapacity = 0;
-    int maxCapacityNode = -1;
+    std::vector<int> maxCapacityNodes{};
     for (auto nodeId : nodeIds) {
         if (numa_node_size64(nodeId, nullptr) > maxCapacity) {
-            maxCapacityNode = nodeId;
             maxCapacity = numa_node_size64(nodeId, nullptr);
         }
     }
 
+    for (auto nodeId : nodeIds) {
+        if (numa_node_size64(nodeId, nullptr) == maxCapacity) {
+            maxCapacityNodes.push_back(nodeId);
+        }
+    }
+
     // Confirm that the HighestCapacity memspace indeed has highest capacity
     void *ptr;
     auto ret = umfMemoryProviderAlloc(hProvider, alloc_size, 0, &ptr);
+    memset(ptr, 0, alloc_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
-    struct bitmask *nodemask = numa_allocate_nodemask();
-    UT_ASSERTne(nodemask, nullptr);
-    int retm = get_mempolicy(nullptr, nodemask->maskp, nodemask->size, ptr,
-                             MPOL_F_ADDR);
-    UT_ASSERTeq(retm, 0);
-    UT_ASSERT(numa_bitmask_isbitset(nodemask, maxCapacityNode));
+    auto nodeId = getNumaNodeByPtr(ptr);
+    ASSERT_TRUE(std::any_of(maxCapacityNodes.begin(), maxCapacityNodes.end(),
+                            [nodeId](int node) { return nodeId == node; }));
 
     ret = umfMemoryProviderFree(hProvider, ptr, alloc_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
-
-    numa_bitmask_free(nodemask);
 }

test/memspaces/memspace_host_all.cpp

@@ -5,6 +5,7 @@
 #include "memory_target_numa.h"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "numa_helpers.h"
 #include "test_helpers.h"
 #include "utils_sanitizers.h"
 
@@ -91,9 +92,7 @@ static void getAllocationPolicy(void *ptr, unsigned long maxNodeId, int &mode,
     }
 
     // Get the node that allocated the memory at 'ptr'.
-    int nodeId = -1;
-    ret = get_mempolicy(&nodeId, nullptr, 0, ptr, MPOL_F_ADDR | MPOL_F_NODE);
-    UT_ASSERTeq(ret, 0);
+    int nodeId = getNumaNodeByPtr(ptr);
     allocNodeId = static_cast<size_t>(nodeId);
 }
 

test/provider_os_memory_multiple_numa_nodes.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "base.hpp"
+#include "numa_helpers.h"
 
 #include <numa.h>
 #include <numaif.h>
@@ -52,14 +53,6 @@ struct testNumaNodes : public testing::TestWithParam<int> {
         ASSERT_NE(os_memory_provider, nullptr);
     }
 
-    int retrieve_numa_node_number(void *addr) {
-        int numa_node;
-        int ret = get_mempolicy(&numa_node, nullptr, 0, addr,
-                                MPOL_F_NODE | MPOL_F_ADDR);
-        EXPECT_EQ(ret, 0);
-        return numa_node;
-    }
-
     void TearDown() override {
         umf_result_t umf_result;
         if (ptr) {
@@ -108,6 +101,6 @@ TEST_P(testNumaNodes, checkNumaNodesAllocations) {
     // This pointer must point to an initialized value before retrieving a number of
     // the numa node that the pointer was allocated on (calling get_mempolicy).
     memset(ptr, 0xFF, alloc_size);
-    int retrieved_numa_node_number = retrieve_numa_node_number(ptr);
+    int retrieved_numa_node_number = getNumaNodeByPtr(ptr);
     ASSERT_EQ(retrieved_numa_node_number, numa_node_number);
 }