Split MR_REF tests

cpp/tests/CMakeLists.txt

@@ -133,9 +133,27 @@ endfunction()
 
 # test sources
 
-# device mr_ref tests
-ConfigureTest(DEVICE_MR_REF_TEST mr/mr_ref_tests.cpp mr/mr_ref_multithreaded_tests.cpp GPUS 1
-              PERCENT 100)
+# device mr_ref tests - split by memory resource type for parallel execution PERCENT values based on
+# maximum memory allocation per test (assuming 16GB GPU)
+
+# Full test suites with multi-threading (~2GB max allocation = 15%)
+ConfigureTest(CUDA_MR_REF_TEST mr/mr_ref_cuda_tests.cpp GPUS 1 PERCENT 15)
+ConfigureTest(CUDA_ASYNC_MR_REF_TEST mr/mr_ref_cuda_async_tests.cpp GPUS 1 PERCENT 15)
+ConfigureTest(MANAGED_MR_REF_TEST mr/mr_ref_managed_tests.cpp GPUS 1 PERCENT 15)
+
+# Pre-allocating resources (50% of free device memory = 50%)
+ConfigureTest(POOL_MR_REF_TEST mr/mr_ref_pool_tests.cpp GPUS 1 PERCENT 50)
+ConfigureTest(ARENA_MR_REF_TEST mr/mr_ref_arena_tests.cpp GPUS 1 PERCENT 50)
+ConfigureTest(BINNING_MR_REF_TEST mr/mr_ref_binning_tests.cpp GPUS 1 PERCENT 50)
+
+# Partial test suites without multi-threading (~500MB max = 5%)
+ConfigureTest(SYSTEM_MR_REF_TEST mr/mr_ref_system_tests.cpp GPUS 1 PERCENT 5)
+ConfigureTest(PINNED_MR_REF_TEST mr/mr_ref_pinned_tests.cpp GPUS 1 PERCENT 5)
+ConfigureTest(PINNED_POOL_MR_REF_TEST mr/mr_ref_pinned_pool_tests.cpp GPUS 1 PERCENT 5)
+
+# Small test suites (minimal allocations = 5%)
+ConfigureTest(FIXED_SIZE_MR_REF_TEST mr/mr_ref_fixed_size_tests.cpp GPUS 1 PERCENT 5)
+ConfigureTest(DEFAULT_MR_REF_TEST mr/mr_ref_default_tests.cpp GPUS 1 PERCENT 5)
 
 # general adaptor tests
 ConfigureTest(ADAPTOR_TEST mr/adaptor_tests.cpp)

cpp/tests/mr/mr_ref_arena_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(ArenaResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Arena"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(ArenaResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("Arena"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(ArenaMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("Arena"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_binning_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(BinningResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Binning"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(BinningResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("Binning"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(BinningMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("Binning"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_cuda_async_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(CudaAsyncResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("CUDA_Async"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(CudaAsyncResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("CUDA_Async"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(CudaAsyncMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("CUDA_Async"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_cuda_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(CudaResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("CUDA"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(CudaResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("CUDA"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(CudaMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("CUDA"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_default_tests.cpp

@@ -0,0 +1,106 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test.hpp"
+
+#include <rmm/mr/cuda_memory_resource.hpp>
+#include <rmm/mr/per_device_resource.hpp>
+#include <rmm/resource_ref.hpp>
+
+#include <gtest/gtest.h>
+
+#include <thread>
+#include <vector>
+
+namespace rmm::test {
+namespace {
+
+// Helper functions for multi-threaded tests
+template <typename Task, typename... Arguments>
+void spawn_n(std::size_t num_threads, Task task, Arguments&&... args)
+{
+  std::vector<std::thread> threads;
+  threads.reserve(num_threads);
+  for (std::size_t i = 0; i < num_threads; ++i) {
+    threads.emplace_back(std::thread(task, std::forward<Arguments>(args)...));
+  }
+
+  for (auto& thread : threads) {
+    thread.join();
+  }
+}
+
+template <typename Task, typename... Arguments>
+void spawn(Task task, Arguments&&... args)
+{
+  spawn_n(4, task, std::forward<Arguments>(args)...);
+}
+
+// Single-threaded default resource tests
+
+TEST(DefaultTest, CurrentDeviceResourceIsCUDA)
+{
+  EXPECT_NE(nullptr, rmm::mr::get_current_device_resource());
+  EXPECT_TRUE(rmm::mr::get_current_device_resource()->is_equal(rmm::mr::cuda_memory_resource{}));
+}
+
+TEST(DefaultTest, UseCurrentDeviceResource) { test_get_current_device_resource(); }
+
+TEST(DefaultTest, UseCurrentDeviceResourceRef) { test_get_current_device_resource_ref(); }
+
+TEST(DefaultTest, GetCurrentDeviceResource)
+{
+  auto* mr = rmm::mr::get_current_device_resource();
+  EXPECT_NE(nullptr, mr);
+  EXPECT_TRUE(mr->is_equal(rmm::mr::cuda_memory_resource{}));
+}
+
+TEST(DefaultTest, GetCurrentDeviceResourceRef)
+{
+  auto mr = rmm::mr::get_current_device_resource_ref();
+  EXPECT_EQ(mr, rmm::device_async_resource_ref{rmm::mr::detail::initial_resource()});
+}
+
+// Multi-threaded default resource tests
+
+TEST(DefaultTest, UseCurrentDeviceResource_mt) { spawn(test_get_current_device_resource); }
+
+TEST(DefaultTest, UseCurrentDeviceResourceRef_mt) { spawn(test_get_current_device_resource_ref); }
+
+TEST(DefaultTest, CurrentDeviceResourceIsCUDA_mt)
+{
+  spawn([]() {
+    EXPECT_NE(nullptr, rmm::mr::get_current_device_resource());
+    EXPECT_TRUE(rmm::mr::get_current_device_resource()->is_equal(rmm::mr::cuda_memory_resource{}));
+  });
+}
+
+TEST(DefaultTest, CurrentDeviceResourceRefIsCUDA_mt)
+{
+  spawn([]() {
+    EXPECT_EQ(rmm::mr::get_current_device_resource_ref(),
+              rmm::device_async_resource_ref{rmm::mr::detail::initial_resource()});
+  });
+}
+
+TEST(DefaultTest, GetCurrentDeviceResource_mt)
+{
+  spawn([]() {
+    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource();
+    EXPECT_NE(nullptr, mr);
+    EXPECT_TRUE(mr->is_equal(rmm::mr::cuda_memory_resource{}));
+  });
+}
+
+TEST(DefaultTest, GetCurrentDeviceResourceRef_mt)
+{
+  spawn([]() {
+    auto mr = rmm::mr::get_current_device_resource_ref();
+    EXPECT_EQ(mr, rmm::device_async_resource_ref{rmm::mr::detail::initial_resource()});
+  });
+}
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_fixed_size_tests.cpp

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_basic.hpp"
+
+namespace rmm::test {
+namespace {
+
+// Note: Fixed_Size MR cannot handle dynamic allocation sizes, so only basic tests are included
+INSTANTIATE_TEST_SUITE_P(FixedSizeResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Fixed_Size"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_managed_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(ManagedResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Managed"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(ManagedResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("Managed"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(ManagedMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("Managed"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_pinned_pool_tests.cpp

@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(PinnedPoolResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("PinnedPool"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(PinnedPoolResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("PinnedPool"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_pinned_tests.cpp

@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(PinnedResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Pinned"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(PinnedResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("Pinned"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test

cpp/tests/mr/mr_ref_pool_tests.cpp

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "mr_ref_test_allocation.hpp"
+#include "mr_ref_test_basic.hpp"
+#include "mr_ref_test_mt.hpp"
+
+namespace rmm::test {
+namespace {
+
+INSTANTIATE_TEST_SUITE_P(PoolResourceTests,
+                         mr_ref_test,
+                         ::testing::Values("Pool"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(PoolResourceAllocationTests,
+                         mr_ref_allocation_test,
+                         ::testing::Values("Pool"),
+                         [](auto const& info) { return info.param; });
+
+INSTANTIATE_TEST_SUITE_P(PoolMultiThreadResourceTests,
+                         mr_ref_test_mt,
+                         ::testing::Values("Pool"),
+                         [](auto const& info) { return info.param; });
+
+}  // namespace
+}  // namespace rmm::test