Add OS memory provider config tests

Testing a single NUMA node:
- tests for protection flags except the UMF_PROTECTION_EXEC flag,
- tests for numa modes except unsupported values,
- tests for visibility.

Author: PatKamin

.github/workflows/basic.yml

@@ -103,7 +103,7 @@ jobs:
       - name: Run tests
         working-directory: ${{env.BUILD_DIR}}
         run: |
-          ctest --output-on-failure
+          ctest --output-on-failure --verbose
 
       - name: Test make install
         working-directory: ${{env.BUILD_DIR}}

test/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2022-2023 Intel Corporation
+# Copyright (C) 2022-2024 Intel Corporation
 # Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
@@ -105,4 +105,7 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
     add_umf_test(NAME memspace_numa
                  SRCS memspace_numa.cpp
                  LIBS numa)
+    add_umf_test(NAME provider_os_memory_config
+                 SRCS provider_os_memory_config.cpp
+                 LIBS umf_utils numa)
 endif()

test/provider_os_memory_config.cpp

@@ -0,0 +1,192 @@
+/*
+ *
+ * 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 "base.hpp"
+#include "provider_os_memory_internal.h"
+#include "umf/providers/provider_os_memory.h"
+
+#include <numa.h>
+#include <numaif.h>
+#include <unistd.h>
+
+struct providerConfigTest : testing::Test {
+    umf_result_t res;
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_os_memory_provider_params_t params = {
+        /* .protection = */ UMF_PROTECTION_READ | UMF_PROTECTION_WRITE,
+        /* .visibility = */ UMF_VISIBILITY_PRIVATE,
+
+        // NUMA config
+        /* .nodemask = */ NULL,
+        /* .maxnode = */ 0,
+        /* .numa_mode = */ UMF_NUMA_MODE_DEFAULT,
+        /* .numa_flags = */ 0,
+
+        // others
+        /* .traces = */ 1,
+    };
+    size_t size = 128;
+    void *ptr = nullptr;
+    char *dest = nullptr;
+
+    void SetUp() override {
+        int ret = numa_available();
+        if (ret) {
+            GTEST_SKIP() << "Test skipped, NUMA not available";
+        }
+        dest = (char *)malloc(size);
+    }
+
+    void TearDown() override {
+        if (ptr) {
+            umfMemoryProviderFree(provider, ptr, size);
+        }
+        free(dest);
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+        }
+    }
+
+    void create_provider(umf_os_memory_provider_params_t *params) {
+        res = umfMemoryProviderCreate(&UMF_OS_MEMORY_PROVIDER_OPS, params,
+                                      &provider);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(provider, nullptr);
+    }
+
+    void allocate_memory() {
+        res = umfMemoryProviderAlloc(provider, size, os_get_page_size(), &ptr);
+        ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+        ASSERT_NE(ptr, nullptr);
+    }
+
+    void copy_ptr_data() {
+        *dest = 'B';
+        memcpy(dest, ptr, size);
+    }
+
+    void read_memory() {
+        copy_ptr_data();
+        EXPECT_EQ(*static_cast<char *>(ptr), *dest);
+    }
+
+    void write_memory(char c) {
+        memset(ptr, c, size);
+        EXPECT_EQ(static_cast<char *>(ptr)[0], c);
+    }
+};
+
+TEST_F(providerConfigTest, protection_flag_none) {
+    // pages may not be accessed - PROT_NONE
+    params.protection = UMF_PROTECTION_NONE;
+    create_provider(&params);
+    allocate_memory();
+
+    // read failure
+    EXPECT_DEATH(copy_ptr_data(), "");
+
+    // write failure
+    EXPECT_DEATH(memset(ptr, 'A', size), "");
+}
+
+TEST_F(providerConfigTest, protection_flag_read) {
+    // pages may be read - PROT_READ
+    params.protection = UMF_PROTECTION_READ;
+    create_provider(&params);
+    allocate_memory();
+
+    // read success
+    read_memory();
+
+    // write failure
+    EXPECT_DEATH(memset(ptr, 'A', size), "");
+}
+
+TEST_F(providerConfigTest, protection_flag_write) {
+    // pages may be written to - PROT_WRITE
+    params.protection = UMF_PROTECTION_WRITE;
+    create_provider(&params);
+    allocate_memory();
+
+    // write success
+    write_memory('A');
+}
+
+struct providerConfigTestNumaMode
+    : providerConfigTest,
+      testing::WithParamInterface<umf_numa_mode_t> {
+    void SetUp() override {
+        providerConfigTest::SetUp();
+        params.numa_mode = GetParam();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(numa_modes, providerConfigTestNumaMode,
+                         testing::Values(UMF_NUMA_MODE_DEFAULT,
+                                         UMF_NUMA_MODE_BIND,
+                                         UMF_NUMA_MODE_INTERLEAVE,
+                                         UMF_NUMA_MODE_PREFERRED,
+                                         UMF_NUMA_MODE_LOCAL));
+
+TEST_P(providerConfigTestNumaMode, numa_modes) {
+    if (params.numa_mode != UMF_NUMA_MODE_DEFAULT &&
+        params.numa_mode != UMF_NUMA_MODE_LOCAL) {
+        struct bitmask *allowed_nodes = numa_get_mems_allowed();
+        params.nodemask = allowed_nodes->maskp;
+        params.maxnode = allowed_nodes->size;
+    }
+
+    create_provider(&params);
+    allocate_memory();
+    write_memory('A');
+
+    int actual_mode = -1;
+    long ret = get_mempolicy(&actual_mode, nullptr, 0, ptr, MPOL_F_ADDR);
+    ASSERT_EQ(ret, 0);
+    ASSERT_EQ(os_translate_numa_mode(params.numa_mode), actual_mode);
+}
+
+struct providerConfigTestVisibility
+    : providerConfigTest,
+      testing::WithParamInterface<umf_mem_visibility_t> {
+    const char primary_char = 'A';
+    const char new_char = 'B';
+    char expected_char;
+    void SetUp() override {
+        params.visibility = GetParam();
+        if (params.visibility == UMF_VISIBILITY_PRIVATE) {
+            expected_char = primary_char;
+        } else if (params.visibility == UMF_VISIBILITY_SHARED) {
+            expected_char = new_char;
+        }
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(visibility, providerConfigTestVisibility,
+                         testing::Values(UMF_VISIBILITY_PRIVATE,
+                                         UMF_VISIBILITY_SHARED));
+
+TEST_P(providerConfigTestVisibility, visibility) {
+    create_provider(&params);
+    allocate_memory();
+    write_memory(primary_char);
+
+    int pid = fork();
+    if (pid == 0) {
+        // child process
+        write_memory('B');
+    } else if (pid > 0) {
+        // main process
+        int status;
+        while (-1 == waitpid(0, &status, 0)) {
+            // wait for the child process to complete
+        }
+        EXPECT_EQ(static_cast<char *>(ptr)[0], expected_char);
+    }
+}