From f0234e94ab4c9a54b5fd4e3b49cfcbcbc1bff1c6 Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Tue, 3 Nov 2026 09:21:56 -0800 Subject: [PATCH 1/7] Disable large-memory join extent overflow tests --- cpp/tests/join/distinct_join_tests.cpp | 4 +++- cpp/tests/join/semi_anti_join_tests.cpp | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/cpp/tests/join/distinct_join_tests.cpp b/cpp/tests/join/distinct_join_tests.cpp index e43375cfe78d..a8e51871bce2 100644 --- a/cpp/tests/join/distinct_join_tests.cpp +++ b/cpp/tests/join/distinct_join_tests.cpp @@ -734,7 +734,9 @@ TEST_F(DistinctJoinTest, InvalidLoadFactor) std::invalid_argument); } -TEST_F(DistinctJoinTest, DistinctLargeExtentOverflowPrevention) +// Disabled since this requires about 20GB of device memory. +// Run with --gtest_also_run_disabled_tests to verify extent overflow prevention. +TEST_F(DistinctJoinTest, DISABLED_DistinctLargeExtentOverflowPrevention) { // Test that validates size_t extent can handle hash table sizes that would // overflow int32_t extent when load_factor < 1.0 diff --git a/cpp/tests/join/semi_anti_join_tests.cpp b/cpp/tests/join/semi_anti_join_tests.cpp index dd1786036eb1..0bb8c6a41f07 100644 --- a/cpp/tests/join/semi_anti_join_tests.cpp +++ b/cpp/tests/join/semi_anti_join_tests.cpp @@ -421,7 +421,9 @@ TEST_P(SemiAntiJoinTest, SemiJoinEmptyTables) } } -TEST_P(SemiAntiJoinTest, AntiSemiJoinLargeExtentOverflowPrevention) +// Disabled since this requires about 20GB of device memory. +// Run with --gtest_also_run_disabled_tests to verify extent overflow prevention. +TEST_P(SemiAntiJoinTest, DISABLED_AntiSemiJoinLargeExtentOverflowPrevention) { auto const implementation = GetParam(); if (use_mark_join(implementation)) { GTEST_SKIP(); } From d3931f3e9b4ac1dd8e01cb814386b9eea1032d50 Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Tue, 3 Nov 2026 10:42:29 -0800 Subject: [PATCH 2/7] Run disabled large-memory join tests in nightlies on large GPUs --- ci/test_cpp.sh | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/ci/test_cpp.sh b/ci/test_cpp.sh index 6839e82bbd4e..f34cfa4a5289 100755 --- a/ci/test_cpp.sh +++ b/ci/test_cpp.sh @@ -36,6 +36,17 @@ if [[ "${RUN_LIBCUDF_TESTS}" == "true" ]]; then SUITEERROR=$? fi +# Tests disabled for needing ~20GB of device memory only run in nightlies on GPUs that can hold them. +large_memory_test_min_mib=24576 +gpu_memory_mib=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -n1 | tr -d '[:space:]') +if (( SUITEERROR == 0 )) && [[ "${RUN_LIBCUDF_TESTS}" == "true" ]] && \ + [[ "${RAPIDS_BUILD_TYPE:-}" == "nightly" ]] && (( gpu_memory_mib >= large_memory_test_min_mib )); then + rapids-logger "Run large-memory libcudf gtests" + timeout 10m "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ + --gtest_also_run_disabled_tests --gtest_filter='*DISABLED_*LargeExtentOverflowPrevention*' + SUITEERROR=$? +fi + if (( SUITEERROR == 0 )) && [[ "${RUN_EXAMPLES_TESTS}" == "true" ]]; then rapids-logger "Run libcudf examples" timeout "${examples_timeout}" ./ci/run_cudf_examples.sh From 090325bdd6255fd55a980b4716dd60c8b42f0a82 Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Tue, 3 Nov 2026 10:44:41 -0800 Subject: [PATCH 3/7] Simplify nightly large-memory test step --- ci/test_cpp.sh | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/ci/test_cpp.sh b/ci/test_cpp.sh index f34cfa4a5289..8904019cc2da 100755 --- a/ci/test_cpp.sh +++ b/ci/test_cpp.sh @@ -36,15 +36,15 @@ if [[ "${RUN_LIBCUDF_TESTS}" == "true" ]]; then SUITEERROR=$? fi -# Tests disabled for needing ~20GB of device memory only run in nightlies on GPUs that can hold them. -large_memory_test_min_mib=24576 -gpu_memory_mib=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -n1 | tr -d '[:space:]') -if (( SUITEERROR == 0 )) && [[ "${RUN_LIBCUDF_TESTS}" == "true" ]] && \ - [[ "${RAPIDS_BUILD_TYPE:-}" == "nightly" ]] && (( gpu_memory_mib >= large_memory_test_min_mib )); then - rapids-logger "Run large-memory libcudf gtests" - timeout 10m "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ - --gtest_also_run_disabled_tests --gtest_filter='*DISABLED_*LargeExtentOverflowPrevention*' - SUITEERROR=$? +# Run the ~20GB tests that are DISABLED_ by default, in nightlies on GPUs that can hold them +if (( SUITEERROR == 0 )) && [[ "${RUN_LIBCUDF_TESTS}" == "true" && "${RAPIDS_BUILD_TYPE:-}" == "nightly" ]]; then + gpu_mib=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -n1) + if (( gpu_mib >= 24576 )); then + rapids-logger "Run large-memory libcudf gtests" + "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ + --gtest_also_run_disabled_tests --gtest_filter='*DISABLED_*LargeExtentOverflowPrevention*' + SUITEERROR=$? + fi fi if (( SUITEERROR == 0 )) && [[ "${RUN_EXAMPLES_TESTS}" == "true" ]]; then From 26c0dd9c7d96879f707b8072af586ad2400a8658 Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Tue, 3 Nov 2026 10:52:53 -0800 Subject: [PATCH 4/7] Add a timeout to the nightly large-memory test step --- ci/test_cpp.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/test_cpp.sh b/ci/test_cpp.sh index 8904019cc2da..d81691d82dcf 100755 --- a/ci/test_cpp.sh +++ b/ci/test_cpp.sh @@ -41,7 +41,7 @@ if (( SUITEERROR == 0 )) && [[ "${RUN_LIBCUDF_TESTS}" == "true" && "${RAPIDS_BUI gpu_mib=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -n1) if (( gpu_mib >= 24576 )); then rapids-logger "Run large-memory libcudf gtests" - "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ + timeout 10m "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ --gtest_also_run_disabled_tests --gtest_filter='*DISABLED_*LargeExtentOverflowPrevention*' SUITEERROR=$? fi From 66d2171b36ea9183ad3bf76fea3c41419c2cdcdf Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Wed, 4 Nov 2026 15:48:21 -0800 Subject: [PATCH 5/7] Skip large-memory tests unless enabled and the device is big enough --- ci/test_cpp.sh | 16 +++----- cpp/include/cudf_test/byte_literals.hpp | 15 +++++++ cpp/include/cudf_test/large_memory.hpp | 52 +++++++++++++++++++++++++ cpp/tests/copying/split_tests.cpp | 17 +++++--- cpp/tests/join/distinct_join_tests.cpp | 8 ++-- cpp/tests/join/semi_anti_join_tests.cpp | 8 ++-- cpp/tests/large_strings/bpe_tests.cpp | 8 ++-- 7 files changed, 98 insertions(+), 26 deletions(-) create mode 100644 cpp/include/cudf_test/byte_literals.hpp create mode 100644 cpp/include/cudf_test/large_memory.hpp diff --git a/ci/test_cpp.sh b/ci/test_cpp.sh index d81691d82dcf..e8014e656a7f 100755 --- a/ci/test_cpp.sh +++ b/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}/ @@ -36,17 +41,6 @@ if [[ "${RUN_LIBCUDF_TESTS}" == "true" ]]; then SUITEERROR=$? fi -# Run the ~20GB tests that are DISABLED_ by default, in nightlies on GPUs that can hold them -if (( SUITEERROR == 0 )) && [[ "${RUN_LIBCUDF_TESTS}" == "true" && "${RAPIDS_BUILD_TYPE:-}" == "nightly" ]]; then - gpu_mib=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -n1) - if (( gpu_mib >= 24576 )); then - rapids-logger "Run large-memory libcudf gtests" - timeout 10m "${INSTALL_PREFIX:-${CONDA_PREFIX:-/usr}}/bin/gtests/libcudf/JOIN_TEST" \ - --gtest_also_run_disabled_tests --gtest_filter='*DISABLED_*LargeExtentOverflowPrevention*' - SUITEERROR=$? - fi -fi - if (( SUITEERROR == 0 )) && [[ "${RUN_EXAMPLES_TESTS}" == "true" ]]; then rapids-logger "Run libcudf examples" timeout "${examples_timeout}" ./ci/run_cudf_examples.sh diff --git a/cpp/include/cudf_test/byte_literals.hpp b/cpp/include/cudf_test/byte_literals.hpp new file mode 100644 index 000000000000..86b7c2991abd --- /dev/null +++ b/cpp/include/cudf_test/byte_literals.hpp @@ -0,0 +1,15 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include + +namespace cudf::test::literals { + +constexpr std::size_t operator""_MiB(unsigned long long val) { return val << 20; } +constexpr std::size_t operator""_GiB(unsigned long long val) { return val << 30; } + +} // namespace cudf::test::literals diff --git a/cpp/include/cudf_test/large_memory.hpp b/cpp/include/cudf_test/large_memory.hpp new file mode 100644 index 000000000000..8dcc5488c971 --- /dev/null +++ b/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 + +#include + +#include + +#include +#include +#include + +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(bytes) \ + do { \ + if (auto const skip_reason_ = cudf::test::large_memory_skip_reason(bytes); \ + not skip_reason_.empty()) { \ + GTEST_SKIP() << skip_reason_; \ + } \ + } while (0) diff --git a/cpp/tests/copying/split_tests.cpp b/cpp/tests/copying/split_tests.cpp index 3a00cfe30dfc..97e386a3e8ee 100644 --- a/cpp/tests/copying/split_tests.cpp +++ b/cpp/tests/copying/split_tests.cpp @@ -6,9 +6,11 @@ #include #include +#include #include #include #include +#include #include #include #include @@ -1776,9 +1778,10 @@ 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(25_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); @@ -1786,9 +1789,10 @@ TEST_F(ContiguousSplitUntypedTest, DISABLED_VeryLargeColumnTest) 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(25_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); @@ -1796,10 +1800,11 @@ TEST_F(ContiguousSplitUntypedTest, DISABLED_VeryLargeColumnTestChunked) 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(7_GiB); auto const mr = cudf::get_current_device_resource_ref(); // 270M INT64 elements = 270 * 1024 * 1024 * 8 = 2,264,924,160 bytes > INT32_MAX diff --git a/cpp/tests/join/distinct_join_tests.cpp b/cpp/tests/join/distinct_join_tests.cpp index a8e51871bce2..9ece0767112c 100644 --- a/cpp/tests/join/distinct_join_tests.cpp +++ b/cpp/tests/join/distinct_join_tests.cpp @@ -4,7 +4,9 @@ */ #include +#include #include +#include #include #include @@ -734,10 +736,10 @@ TEST_F(DistinctJoinTest, InvalidLoadFactor) std::invalid_argument); } -// Disabled since this requires about 20GB of device memory. -// Run with --gtest_also_run_disabled_tests to verify extent overflow prevention. -TEST_F(DistinctJoinTest, DISABLED_DistinctLargeExtentOverflowPrevention) +TEST_F(DistinctJoinTest, DistinctLargeExtentOverflowPrevention) { + using namespace cudf::test::literals; + CUDF_TEST_REQUIRE_DEVICE_MEMORY(24_GiB); // Test that validates size_t extent can handle hash table sizes that would // overflow int32_t extent when load_factor < 1.0 diff --git a/cpp/tests/join/semi_anti_join_tests.cpp b/cpp/tests/join/semi_anti_join_tests.cpp index 0bb8c6a41f07..20f80903b22f 100644 --- a/cpp/tests/join/semi_anti_join_tests.cpp +++ b/cpp/tests/join/semi_anti_join_tests.cpp @@ -4,9 +4,11 @@ */ #include +#include #include #include #include +#include #include #include @@ -421,10 +423,10 @@ TEST_P(SemiAntiJoinTest, SemiJoinEmptyTables) } } -// Disabled since this requires about 20GB of device memory. -// Run with --gtest_also_run_disabled_tests to verify extent overflow prevention. -TEST_P(SemiAntiJoinTest, DISABLED_AntiSemiJoinLargeExtentOverflowPrevention) +TEST_P(SemiAntiJoinTest, AntiSemiJoinLargeExtentOverflowPrevention) { + using namespace cudf::test::literals; + CUDF_TEST_REQUIRE_DEVICE_MEMORY(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 diff --git a/cpp/tests/large_strings/bpe_tests.cpp b/cpp/tests/large_strings/bpe_tests.cpp index 8257d89cb0b3..e90e49a391d1 100644 --- a/cpp/tests/large_strings/bpe_tests.cpp +++ b/cpp/tests/large_strings/bpe_tests.cpp @@ -7,8 +7,10 @@ #include +#include #include #include +#include #include #include @@ -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(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"}); From 35e4b845d6a84070786430a440ad12ade70e2e3d Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Wed, 4 Nov 2026 16:27:50 -0800 Subject: [PATCH 6/7] Clone RMM byte literals and rename the skip macro to say it skips --- cpp/include/cudf_test/byte_literals.hpp | 19 +++++++++++++++---- cpp/include/cudf_test/large_memory.hpp | 2 +- cpp/tests/copying/split_tests.cpp | 6 +++--- cpp/tests/join/distinct_join_tests.cpp | 2 +- cpp/tests/join/semi_anti_join_tests.cpp | 2 +- cpp/tests/large_strings/bpe_tests.cpp | 2 +- 6 files changed, 22 insertions(+), 11 deletions(-) diff --git a/cpp/include/cudf_test/byte_literals.hpp b/cpp/include/cudf_test/byte_literals.hpp index 86b7c2991abd..abb955539408 100644 --- a/cpp/include/cudf_test/byte_literals.hpp +++ b/cpp/include/cudf_test/byte_literals.hpp @@ -1,15 +1,26 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ #pragma once -#include +#include namespace cudf::test::literals { -constexpr std::size_t operator""_MiB(unsigned long long val) { return val << 20; } -constexpr std::size_t operator""_GiB(unsigned long long val) { return val << 30; } +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 diff --git a/cpp/include/cudf_test/large_memory.hpp b/cpp/include/cudf_test/large_memory.hpp index 8dcc5488c971..1c47bbcf733c 100644 --- a/cpp/include/cudf_test/large_memory.hpp +++ b/cpp/include/cudf_test/large_memory.hpp @@ -43,7 +43,7 @@ inline std::string large_memory_skip_reason(std::size_t bytes) } // 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(bytes) \ +#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()) { \ diff --git a/cpp/tests/copying/split_tests.cpp b/cpp/tests/copying/split_tests.cpp index 97e386a3e8ee..9e0c9ff5fdd0 100644 --- a/cpp/tests/copying/split_tests.cpp +++ b/cpp/tests/copying/split_tests.cpp @@ -1781,7 +1781,7 @@ TEST_F(ContiguousSplitUntypedTest, ManyBuffersPreserveValidity) TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTest) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(25_GiB); + CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(25_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); @@ -1792,7 +1792,7 @@ TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTest) TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTestChunked) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(25_GiB); + CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(25_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); @@ -1804,7 +1804,7 @@ TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTestChunked) TEST_F(ContiguousSplitUntypedTest, ChunkedPackNextReturnValueOver2GB) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(7_GiB); + CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(7_GiB); auto const mr = cudf::get_current_device_resource_ref(); // 270M INT64 elements = 270 * 1024 * 1024 * 8 = 2,264,924,160 bytes > INT32_MAX diff --git a/cpp/tests/join/distinct_join_tests.cpp b/cpp/tests/join/distinct_join_tests.cpp index 9ece0767112c..afa4f7e6b549 100644 --- a/cpp/tests/join/distinct_join_tests.cpp +++ b/cpp/tests/join/distinct_join_tests.cpp @@ -739,7 +739,7 @@ TEST_F(DistinctJoinTest, InvalidLoadFactor) TEST_F(DistinctJoinTest, DistinctLargeExtentOverflowPrevention) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(24_GiB); + 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 diff --git a/cpp/tests/join/semi_anti_join_tests.cpp b/cpp/tests/join/semi_anti_join_tests.cpp index 20f80903b22f..785f84bc55f8 100644 --- a/cpp/tests/join/semi_anti_join_tests.cpp +++ b/cpp/tests/join/semi_anti_join_tests.cpp @@ -426,7 +426,7 @@ TEST_P(SemiAntiJoinTest, SemiJoinEmptyTables) TEST_P(SemiAntiJoinTest, AntiSemiJoinLargeExtentOverflowPrevention) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(24_GiB); + 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 diff --git a/cpp/tests/large_strings/bpe_tests.cpp b/cpp/tests/large_strings/bpe_tests.cpp index e90e49a391d1..5fecd9309e02 100644 --- a/cpp/tests/large_strings/bpe_tests.cpp +++ b/cpp/tests/large_strings/bpe_tests.cpp @@ -83,7 +83,7 @@ TEST_F(BPETest, LargeOutput) TEST_F(BPETest, ManySegments) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY(40_GiB); + 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"}); From 673ccd3079a439a62db2ee56103460234a5a893a Mon Sep 17 00:00:00 2001 From: Yunsong Wang Date: Wed, 4 Nov 2026 16:49:08 -0800 Subject: [PATCH 7/7] Lower the split test memory requirements measured with the async allocator --- cpp/tests/copying/split_tests.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/tests/copying/split_tests.cpp b/cpp/tests/copying/split_tests.cpp index 9e0c9ff5fdd0..f4664a9a3e65 100644 --- a/cpp/tests/copying/split_tests.cpp +++ b/cpp/tests/copying/split_tests.cpp @@ -1781,7 +1781,7 @@ TEST_F(ContiguousSplitUntypedTest, ManyBuffersPreserveValidity) TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTest) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(25_GiB); + 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); @@ -1792,7 +1792,7 @@ TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTest) TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTestChunked) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(25_GiB); + 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); @@ -1804,7 +1804,7 @@ TEST_F(ContiguousSplitUntypedTest, VeryLargeColumnTestChunked) TEST_F(ContiguousSplitUntypedTest, ChunkedPackNextReturnValueOver2GB) { using namespace cudf::test::literals; - CUDF_TEST_REQUIRE_DEVICE_MEMORY_OR_SKIP(7_GiB); + 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