Add OS provider tests for different bind modes

Author: Damian Duy

test/provider_os_memory_multiple_numa_nodes.cpp

@@ -6,6 +6,7 @@
 
 #include <numa.h>
 #include <numaif.h>
+#include <sched.h>
 
 #include <umf/providers/provider_os_memory.h>
 
@@ -60,6 +61,30 @@ struct testNumaNodes : public testing::TestWithParam<int> {
         return numa_node;
     }
 
+    long unsigned int retrieve_nodemask(void *addr) {
+        struct bitmask *retrieved_nodemask = numa_allocate_nodemask();
+        EXPECT_NE(nodemask, nullptr);
+        int ret = get_mempolicy(nullptr, retrieved_nodemask->maskp,
+                                numa_max_possible_node(), addr, MPOL_F_ADDR);
+        EXPECT_EQ(ret, 0);
+        long unsigned int retrieved_nodemask_value =
+            *(retrieved_nodemask->maskp);
+        numa_bitmask_free(retrieved_nodemask);
+        return retrieved_nodemask_value;
+    }
+
+    void set_all_available_nodemask_bits() {
+        ASSERT_NE(numa_available(), -1);
+        ASSERT_NE(numa_all_nodes_ptr, nullptr);
+
+        // Set all available NUMA nodes numbers.
+        for (size_t i = 0; i < (size_t)numa_max_node() + 1; ++i) {
+            if (numa_bitmask_isbitset(numa_all_nodes_ptr, i) == 1) {
+                numa_bitmask_setbit(nodemask, i);
+            }
+        }
+    }
+
     void TearDown() override {
         umf_result_t umf_result;
         if (ptr) {
@@ -111,3 +136,102 @@ 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(testNumaNodes, 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.
+// This test is run multiple times (depending on how many numa nodes
+// are on the system) just to make sure it works, which I'm not sure makes
+// sense so possible TODO: change it to TEST_F.
+TEST_P(testNumaNodes, 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_P(testNumaNodes, 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_P(testNumaNodes, 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() + 1;
+    set_all_available_nodemask_bits();
+    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));
+}