Skip large-memory tests unless enabled on a large enough GPU

ci/test_cpp.sh

@@ -25,6 +25,11 @@ EXITCODE=0
 trap "EXITCODE=1" ERR
 set +e
 
+# Run the large-memory tests (skipped by default) in nightlies; they skip themselves on small GPUs
+if [[ "${RAPIDS_BUILD_TYPE:-}" == "nightly" ]]; then
+    export GTEST_CUDF_LARGE_MEMORY_TESTS=1
+fi
+
 # Run gtests from the libcudf-tests and libcudf-streaming-tests packages
 export GTEST_OUTPUT=xml:${RAPIDS_TESTS_DIR}/
 

cpp/include/cudf_test/byte_literals.hpp

@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace cudf::test::literals {
+
+constexpr auto kilo{long{1} << 10};
+constexpr auto mega{long{1} << 20};
+constexpr auto giga{long{1} << 30};
+constexpr auto tera{long{1} << 40};
+constexpr auto peta{long{1} << 50};
+
+// user-defined Byte literals
+constexpr unsigned long long operator""_B(unsigned long long val) { return val; }
+constexpr unsigned long long operator""_KiB(unsigned long long const val) { return kilo * val; }
+constexpr unsigned long long operator""_MiB(unsigned long long const val) { return mega * val; }
+constexpr unsigned long long operator""_GiB(unsigned long long const val) { return giga * val; }
+constexpr unsigned long long operator""_TiB(unsigned long long const val) { return tera * val; }
+constexpr unsigned long long operator""_PiB(unsigned long long const val) { return peta * val; }
+
+}  // namespace cudf::test::literals

cpp/include/cudf_test/large_memory.hpp

@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cudf/utilities/error.hpp>
+
+#include <cuda_runtime_api.h>
+
+#include <gtest/gtest.h>
+
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+
+namespace cudf::test {
+
+/**
+ * @brief Returns why a test needing `bytes` of device memory should be skipped, or an empty string
+ * if it can run.
+ *
+ * Large-memory tests are skipped unless `GTEST_CUDF_LARGE_MEMORY_TESTS=1`, and then only run if
+ * the current CUDA device has at least `bytes` of total memory.
+ */
+inline std::string large_memory_skip_reason(std::size_t bytes)
+{
+  auto const* env = std::getenv("GTEST_CUDF_LARGE_MEMORY_TESTS");
+  if (env == nullptr or std::string{env} != "1") {
+    return "Large-memory tests are disabled, set GTEST_CUDF_LARGE_MEMORY_TESTS=1 to enable";
+  }
+  std::size_t free{};
+  std::size_t total{};
+  CUDF_CUDA_TRY(cudaMemGetInfo(&free, &total));
+  if (total < bytes) {
+    return "Requires " + std::to_string(bytes >> 20) +
+           " MiB of device memory, but the device has " + std::to_string(total >> 20) + " MiB";
+  }
+  return {};
+}
+
+}  // namespace cudf::test
+
+/// Skips the current test unless large-memory tests are enabled and the device has `bytes` memory.
+#define CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(bytes)                         \
+  do {                                                                         \
+    if (auto const skip_reason_ = cudf::test::large_memory_skip_reason(bytes); \
+        not skip_reason_.empty()) {                                            \
+      GTEST_SKIP() << skip_reason_;                                            \
+    }                                                                          \
+  } while (0)

cpp/tests/copying/split_tests.cpp

@@ -6,9 +6,11 @@
 #include <tests/copying/slice_tests.cuh>
 
 #include <cudf_test/base_fixture.hpp>
+#include <cudf_test/byte_literals.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
+#include <cudf_test/large_memory.hpp>
 #include <cudf_test/table_utilities.hpp>
 #include <cudf_test/type_list_utilities.hpp>
 #include <cudf_test/type_lists.hpp>
@@ -1817,30 +1819,33 @@ TEST_F(ContiguousSplitUntypedTest, ManyBuffersPreserveValidity)
   CUDF_TEST_EXPECT_TABLES_EQUAL(input, result.back().table);
 }
 
-// This test requires about 25GB of device memory when used with the arena allocator
-TEST_F(ContiguousSplitUntypedTest, DISABLED_VeryLargeColumnTest)
+TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTest)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(16_GiB);
   // tests an edge case where buf.elements * buf.element_size overflows an INT32.
   auto col = cudf::make_fixed_width_column(
     cudf::data_type{cudf::type_id::INT64}, 400 * 1024 * 1024, cudf::mask_state::UNALLOCATED);
   auto result = cudf::contiguous_split(cudf::table_view{{*col}}, {});
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*col, result[0].table.column(0));
 }
 
-// This test requires about 25GB of device memory when used with the arena allocator
-TEST_F(ContiguousSplitUntypedTest, DISABLED_VeryLargeColumnTestChunked)
+TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTestChunked)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(16_GiB);
   // tests an edge case where buf.elements * buf.element_size overflows an INT32.
   auto col = cudf::make_fixed_width_column(
     cudf::data_type{cudf::type_id::INT64}, 400 * 1024 * 1024, cudf::mask_state::UNALLOCATED);
   auto result = do_chunked_pack(cudf::table_view{{*col}});
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*col, result[0].table.column(0));
 }
 
-// Disabled as this test requires about 7GB of device memory.
 // See https://github.com/NVIDIA/cudf/issues/20876 for more info.
-TEST_F(ContiguousSplitUntypedTest, DISABLED_ChunkedPackNextReturnValueOver2GB)
+TEST_F(ContiguousSplitUntypedTest, ChunkedPackNextReturnValueOver2GB)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(8_GiB);
   auto const mr = cudf::get_current_device_resource_ref();
 
   // 270M INT64 elements = 270 * 1024 * 1024 * 8 = 2,264,924,160 bytes > INT32_MAX

cpp/tests/join/distinct_join_tests.cpp

@@ -4,7 +4,9 @@
  */
 
 #include <cudf_test/base_fixture.hpp>
+#include <cudf_test/byte_literals.hpp>
 #include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/large_memory.hpp>
 #include <cudf_test/table_utilities.hpp>
 
 #include <cudf/column/column.hpp>
@@ -736,6 +738,8 @@ TEST_F(DistinctJoinTest, InvalidLoadFactor)
 
 TEST_F(DistinctJoinTest, DistinctLargeExtentOverflowPrevention)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(24_GiB);
   // Test that validates size_t extent can handle hash table sizes that would
   // overflow int32_t extent when load_factor < 1.0
 

cpp/tests/join/semi_anti_join_tests.cpp

@@ -4,9 +4,11 @@
  */
 
 #include <cudf_test/base_fixture.hpp>
+#include <cudf_test/byte_literals.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
+#include <cudf_test/large_memory.hpp>
 #include <cudf_test/table_utilities.hpp>
 
 #include <cudf/column/column.hpp>
@@ -423,6 +425,8 @@ TEST_P(SemiAntiJoinTest, SemiJoinEmptyTables)
 
 TEST_P(SemiAntiJoinTest, AntiSemiJoinLargeExtentOverflowPrevention)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(24_GiB);
   auto const implementation = GetParam();
   if (use_mark_join(implementation)) { GTEST_SKIP(); }
   // Test validates size_t extent can handle bucket storage sizes that would

cpp/tests/large_strings/bpe_tests.cpp

@@ -7,8 +7,10 @@
 
 #include <tests/text/bpe_data_generator.hpp>
 
+#include <cudf_test/byte_literals.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/large_memory.hpp>
 
 #include <cudf/column/column_factories.hpp>
 #include <cudf/concatenate.hpp>
@@ -78,10 +80,10 @@ TEST_F(BPETest, LargeOutput)
   }
 }
 
-// Disabled since this requires about 40GB of device memory.
-// Run with --gtest_also_run_disabled_tests to verify more than max size_type segments.
-TEST_F(BPETest, DISABLED_ManySegments)
+TEST_F(BPETest, ManySegments)
 {
+  using namespace cudf::test::literals;
+  CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(40_GiB);
   // every character is its own (unpairable) segment so the number
   // of segments exceeds max size_type
   auto const mpt = cudf::test::strings_column_wrapper({"a b", "ab c"});