Add SUM_OVERFLOW in sort groupby

[PointKernel]

Description

Closes #22576

This PR adds support for SUM_OVERFLOW (previously SUM_WITH_OVERFLOW) in the sort-based groupby execution path.

Checklist

• I am familiar with the Contributing Guidelines.
• New or existing tests cover these changes.
• The documentation is up to date with these changes.

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

📝 Walkthrough

Walkthrough

Adds SUM_OVERFLOW as the overflow-sum kind, keeps SUM_WITH_OVERFLOW as a deprecated alias, wires sort-based groupby support through shared overflow helpers, and updates C++/Java tests.

Changes

Overflow-sum sort-path support

Layer / File(s)	Summary
Public overflow-sum contract cpp/include/cudf/aggregation.hpp, cpp/include/cudf/detail/aggregation/aggregation.hpp, cpp/src/aggregation/aggregation.cpp, cpp/include/cudf/reduction/detail/sum_overflow.cuh	Adds SUM_OVERFLOW, deprecates SUM_WITH_OVERFLOW as an alias, adds make_sum_overflow_aggregation(), centralizes the supported-type constraint, and introduces the overflow accumulator helpers.
Scalar sum-with-overflow dispatch cpp/src/reductions/reductions.cpp, cpp/src/reductions/sum_with_overflow.cu	Rewrites the scalar reduction specialization constraint to use sum_overflow_supported and switches the null-handling path to null_replaced_to_sum_overflow.
Sort-groupby implementation cpp/src/groupby/sort/group_reductions.hpp, cpp/src/groupby/sort/group_sum_overflow.cu, cpp/src/groupby/sort/aggregate.cpp, cpp/CMakeLists.txt	Declares and implements group_sum_overflow, routes SUM_WITH_OVERFLOW through sort aggregation, removes the sort-path rejection, and compiles the new CUDA source.
Sort-path tests cpp/tests/groupby/sum_with_overflow_tests.cpp, java/src/test/java/ai/rapids/cudf/TableTest.java	C++ and Java tests now assert successful sort-based SUM_WITH_OVERFLOW execution, overflow detection, and STRUCT child outputs.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• rapidsai/cudf#22465: Adjusts supported Source constraints for SUM_WITH_OVERFLOW, which is the shared dispatch surface used here.
• rapidsai/cudf#22696: Modifies cpp/src/reductions/sum_with_overflow.cu, the same scalar reduction implementation file updated here.
• rapidsai/cudf#22404: Adds Java/JNI plumbing for make_sum_with_overflow_aggregation(), overlapping with the API and Java test surface touched here.

Suggested reviewers

• pmattione-nvidia
• mythrocks
• bdice
• ttnghia

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (2 warnings)

Check name	Status	Explanation	Resolution
Out of Scope Changes check	⚠️ Warning	The PR also adds a new SUM_OVERFLOW public API and deprecates SUM_WITH_OVERFLOW, which is broader than fixing sort-groupby support.	Move the API rename/deprecation to a separate PR, or document it as part of the issue scope if it is intended to ship together.
Docstring Coverage	⚠️ Warning	Docstring coverage is 3.33% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (3 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	The PR satisfies #22576 by removing the sort-path restriction, adding the implementation, and covering the new behavior with tests.
Title check	✅ Passed	The title is concise and related to the main change: adding overflow-sum support in sort-based groupby.
Description check	✅ Passed	The description clearly matches the changes by stating that sort-based groupby support for SUM_OVERFLOW/SUM_WITH_OVERFLOW is being added.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch enable-sum-with-overflow-sort-groupby

---

_{Comment @coderabbitai help to get the list of available commands.}

[ttnghia]

Can we combine two reduce_by_key together, using zip_iterator input/output? They are operating on the same keys.

[ttnghia]

We need to do some benchmark to see how that combination will change performance.

[PointKernel]

I noticed this also and realized that the sort-based regular SUM follows the same pattern. I originally tried using a single reduce_by_key invocation, but ran into issues that I mistakenly attributed to the single-pass approach. Now that we know the root cause is a bug elsewhere, let me take a quick look and see whether we can apply the same change to the regular SUM path as well.

[PointKernel]

Benchmarked + profiled it: fusing the two reduce_by_key into one zip pass is consistently ~1.45x slower.

100M int64 rows, 90% valid, average of 50 iters:

groups	two passes	fused one pass
1	3.77 ms	5.52 ms
100	3.76 ms	5.51 ms
10K	3.78 ms	5.55 ms
1M	3.65 ms	5.36 ms
10M	3.93 ms	5.42 ms

Root cause is register pressure: carrying tuple<{int64 sum, int32 wraps}, valid> through the CUB scan pushes registers from 71 to 89, which drops occupancy from 37% to 24% and slows the kernel. It's not bandwidth, the fused kernel actually reads fewer bytes. Keeping the two passes.

[mhaseeb123]

Optional suggestion about using C++ concepts. Looks good otherwise

[PointKernel]

@ttnghia Can you please take another pass at this? I've made some additional Java changes since it was last approved. Thanks!

[PointKernel]

/merge