Add OS provider tests for different bind modes

Author: Damian Duy

test/provider_os_memory_multiple_numa_nodes.cpp

@@ -6,7 +6,9 @@
 
 #include <numa.h>
 #include <numaif.h>
+#include <sched.h>
 
+#include "test_helpers.h"
 #include <umf/providers/provider_os_memory.h>
 
 static umf_os_memory_provider_params_t UMF_OS_MEMORY_PROVIDER_PARAMS_TEST =
@@ -28,7 +30,17 @@ std::vector<int> get_available_numa_nodes_numbers() {
     return available_numa_nodes_numbers;
 }
 
-struct testNumaNodes : public testing::TestWithParam<int> {
+void set_all_available_nodemask_bits(bitmask *nodemask) {
+    UT_ASSERTne(numa_available(), -1);
+    UT_ASSERTne(numa_all_nodes_ptr, nullptr);
+
+    numa_bitmask_clearall(nodemask);
+
+    // Set all available NUMA nodes numbers.
+    copy_bitmask_to_bitmask(numa_all_nodes_ptr, nodemask);
+}
+
+struct testNuma : testing::Test {
     void SetUp() override {
         if (numa_available() == -1) {
             GTEST_SKIP() << "Test skipped, NUMA not available";
@@ -56,10 +68,22 @@ struct testNumaNodes : public testing::TestWithParam<int> {
         int numa_node;
         int ret = get_mempolicy(&numa_node, nullptr, 0, addr,
                                 MPOL_F_NODE | MPOL_F_ADDR);
-        EXPECT_EQ(ret, 0);
+        UT_ASSERTeq(ret, 0);
         return numa_node;
     }
 
+    long unsigned int retrieve_nodemask(void *addr) {
+        struct bitmask *retrieved_nodemask = numa_allocate_nodemask();
+        UT_ASSERTne(nodemask, nullptr);
+        int ret = get_mempolicy(nullptr, retrieved_nodemask->maskp,
+                                nodemask->size, addr, MPOL_F_ADDR);
+        UT_ASSERTeq(ret, 0);
+        long unsigned int retrieved_nodemask_value =
+            *(retrieved_nodemask->maskp);
+        numa_bitmask_free(retrieved_nodemask);
+        return retrieved_nodemask_value;
+    }
+
     void TearDown() override {
         umf_result_t umf_result;
         if (ptr) {
@@ -82,14 +106,16 @@ struct testNumaNodes : public testing::TestWithParam<int> {
     umf_memory_provider_handle_t os_memory_provider = nullptr;
 };
 
+struct testNumaOnAllNodes : testNuma, testing::WithParamInterface<int> {};
+
 INSTANTIATE_TEST_SUITE_P(
-    testNumaNodesAllocations, testNumaNodes,
+    testNumaNodesAllocations, testNumaOnAllNodes,
     ::testing::ValuesIn(get_available_numa_nodes_numbers()));
 
 // Test for allocations on numa nodes. This test will be executed for all numa nodes
 // available on the system. The available nodes are returned in vector from the
 // get_available_numa_nodes_numbers() function and passed to test as parameters.
-TEST_P(testNumaNodes, checkNumaNodesAllocations) {
+TEST_P(testNumaOnAllNodes, checkNumaNodesAllocations) {
     int numa_node_number = GetParam();
     umf_os_memory_provider_params_t os_memory_provider_params =
         UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
@@ -111,3 +137,99 @@ TEST_P(testNumaNodes, checkNumaNodesAllocations) {
     int retrieved_numa_node_number = retrieve_numa_node_number(ptr);
     ASSERT_EQ(retrieved_numa_node_number, numa_node_number);
 }
+
+// Test for allocations on numa nodes with mode preferred. It runs for all available
+// numa nodes obtained from the get_available_numa_nodes_numbers() function.
+TEST_P(testNumaOnAllNodes, checkModePreferred) {
+    int numa_node_number = GetParam();
+    umf_os_memory_provider_params_t os_memory_provider_params =
+        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    os_memory_provider_params.maxnode = numa_node_number + 1;
+    numa_bitmask_setbit(nodemask, numa_node_number);
+    os_memory_provider_params.nodemask = nodemask->maskp;
+    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_PREFERRED;
+    initOsProvider(os_memory_provider_params);
+
+    umf_result_t umf_result;
+    umf_result =
+        umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    // 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);
+    ASSERT_EQ(retrieved_numa_node_number, numa_node_number);
+}
+
+// Test for allocation on numa node with local mode enabled. The memory is
+// allocated on the node of the CPU that triggered the allocation.
+TEST_F(testNuma, checkModeLocal) {
+    int cpu = sched_getcpu();
+    int numa_node_number = numa_node_of_cpu(cpu);
+    umf_os_memory_provider_params_t os_memory_provider_params =
+        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_LOCAL;
+    initOsProvider(os_memory_provider_params);
+
+    umf_result_t umf_result;
+    umf_result =
+        umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    // 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);
+    ASSERT_EQ(retrieved_numa_node_number, numa_node_number);
+}
+
+// Test for allocation on numa node with default mode enabled.
+// Since no policy is set by the set_mempolicy function, it should
+// default to the system-wide default policy, which allocates pages
+// on the node of the CPU that triggers the allocation.
+TEST_F(testNuma, checkModeDefault) {
+    int cpu = sched_getcpu();
+    int numa_node_number = numa_node_of_cpu(cpu);
+    umf_os_memory_provider_params_t os_memory_provider_params =
+        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    initOsProvider(os_memory_provider_params);
+
+    umf_result_t umf_result;
+    umf_result =
+        umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    // 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);
+    ASSERT_EQ(retrieved_numa_node_number, numa_node_number);
+}
+
+// Test for allocations on numa nodes with interleave mode enabled.
+// The page allocations are interleaved across the set of nodes specified in nodemask.
+TEST_F(testNuma, checkModeInterleave) {
+    umf_os_memory_provider_params_t os_memory_provider_params =
+        UMF_OS_MEMORY_PROVIDER_PARAMS_TEST;
+    os_memory_provider_params.maxnode = numa_max_node();
+    set_all_available_nodemask_bits(nodemask);
+    os_memory_provider_params.nodemask = nodemask->maskp;
+    os_memory_provider_params.numa_mode = UMF_NUMA_MODE_INTERLEAVE;
+    initOsProvider(os_memory_provider_params);
+
+    umf_result_t umf_result;
+    umf_result =
+        umfMemoryProviderAlloc(os_memory_provider, alloc_size, 0, &ptr);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(ptr, nullptr);
+
+    // 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);
+    long unsigned int retrieved_nodemask_value = retrieve_nodemask(ptr);
+    ASSERT_EQ(retrieved_nodemask_value, *(nodemask->maskp));
+}