Merge pull request #245 from kswiecicki/memspace-default-tests

Expand HOST ALL memspace tests

Author: bratpiorka

test/CMakeLists.txt

@@ -124,13 +124,13 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
                  SRCS provider_os_memory_multiple_numa_nodes.cpp
                  LIBS umf_utils ${LIBNUMA_LIBRARIES})
     add_umf_test(NAME memspace_numa
-                 SRCS memspace_numa.cpp
+                 SRCS memspaces/memspace_numa.cpp
                  LIBS ${LIBNUMA_LIBRARIES})
     add_umf_test(NAME provider_os_memory_config
                  SRCS provider_os_memory_config.cpp
                  LIBS umf_utils ${LIBNUMA_LIBRARIES})
     add_umf_test(NAME memspace_host_all
-                 SRCS memspace_host_all.cpp
+                 SRCS memspaces/memspace_host_all.cpp
                  LIBS ${LIBNUMA_LIBRARIES})
 endif()
 

test/memspace_host_all.cpp

@@ -0,0 +1,112 @@
+// 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 (4096UL)
+#define SIZE_4M (SIZE_4K * 1024UL)
+
+struct numaNodesTest : ::umf_test::test {
+    void SetUp() override {
+        ::umf_test::test::SetUp();
+
+        if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) {
+            GTEST_FAIL() << "Failed to initialize libnuma";
+        }
+
+        int maxNode = numa_max_node();
+        if (maxNode < 0) {
+            GTEST_FAIL() << "No available numa nodes";
+        }
+
+        for (int i = 0; i <= maxNode; i++) {
+            if (numa_bitmask_isbitset(numa_all_nodes_ptr, i)) {
+                nodeIds.emplace_back(i);
+                maxNodeId = i;
+            }
+        }
+    }
+
+    std::vector<size_t> nodeIds;
+    unsigned long maxNodeId = 0;
+};
+
+struct memspaceNumaTest : ::numaNodesTest {
+    void SetUp() override {
+        ::numaNodesTest::SetUp();
+
+        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 memspaceHostAllTest : ::numaNodesTest {
+    void SetUp() override {
+        ::numaNodesTest::SetUp();
+
+        hMemspace = umfMemspaceHostAllGet();
+        ASSERT_NE(hMemspace, nullptr);
+    }
+
+    umf_memspace_handle_t hMemspace = nullptr;
+};
+
+struct memspaceHostAllProviderTest : ::memspaceHostAllTest {
+    void SetUp() override {
+        ::memspaceHostAllTest::SetUp();
+
+        umf_result_t ret =
+            umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &hProvider);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(hProvider, nullptr);
+    }
+
+    void TearDown() override {
+        ::memspaceHostAllTest::TearDown();
+
+        umfMemoryProviderDestroy(hProvider);
+    }
+
+    umf_memory_provider_handle_t hProvider = nullptr;
+};
+
+#endif /* UMF_MEMSPACE_HELPERS_HPP */