[parallel] Add projection support to hpx::is_sorted, hpx::is_sorted_until, and hpx::is_partitioned CPOs by aneek22112007-tech · Pull Request #7220 · TheHPXProject/hpx

aneek22112007-tech · 2026-04-22T21:44:29Z

Summary

This PR enhances the hpx::is_sorted, hpx::is_sorted_until, and hpx::is_partitioned algorithms by exposing projection support at the CPO level. While the underlying parallel implementations already supported projections through the Proj template parameter, the user-facing hpx:: namespace CPOs lacked the necessary tag_fallback_invoke overloads to forward these arguments.

Changes

Algorithm Headers
- libs/core/algorithms/include/hpx/parallel/algorithms/is_sorted.hpp
  - Added new overloads for hpx::is_sorted_t and hpx::is_sorted_until_t that accept an optional Proj parameter.
  - Updated SFINAE constraints to use hpx::parallel::traits::is_projected_v and hpx::util::invoke_result_t for robust type checking.
  - Added #include <hpx/algorithms/traits/projected.hpp> for required traits.
- libs/core/algorithms/include/hpx/parallel/algorithms/is_partitioned.hpp
  - Added overloads for hpx::is_partitioned_t that forward the projection to the internal implementation.
  - Standardized the CPO dispatch to match current HPX patterns for projection-aware algorithms.
Test Suite
- libs/core/algorithms/tests/unit/algorithms/is_sorted_projection.cpp (new)
  - Implemented a comprehensive test suite using std::pair and custom lambda projections.
  - Validates sequential dispatch, hpx::execution::seq, hpx::execution::par, and hpx::execution::par(task).
  - Covers edge cases including empty ranges and single-element ranges to ensure no regression in algorithm logic.
- libs/core/algorithms/tests/unit/algorithms/CMakeLists.txt
  - Registered the new unit test target.

Technical Rationale

Previously, calling hpx::is_sorted(first, last, comp, proj) would fail to compile because the CPO only recognized overloads with up to three arguments (iterators and predicate). Since HPX's internal parallel algorithms are already projection-aware (via invoke_projected), this fix simply involves threading the projection argument from the user-facing CPO down to the algorithm dispatcher. This aligns the hpx:: namespace API with the hpx::ranges:: API, improving consistency for users who prefer iterator-based overloads.

Testing

New Regression Test: is_sorted_projection passes across all execution policies.
Backward Compatibility: Verified that existing calls to is_sorted, is_sorted_until, and is_partitioned (without projections) continue to compile and run correctly, as the new overloads are purely additive and use default arguments for the projection.
Trait Validation: Confirmed that the requires clauses correctly handle invalid projections via SFINAE.

StellarBot · 2026-04-22T21:45:04Z

Can one of the admins verify this patch?

codacy-production · 2026-04-22T21:49:04Z

Up to standards ✅

🟢 Issues 0 issues

Results:
0 new issues

View in Codacy

_{NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer}
_{TIP This summary will be updated as you push new changes.}

hkaiser

Thanks for your work on this.

We generally try to stay as close to the C++ Standard as possible. For this reason I don't think that we should go ahead with adding projections to the algorithms in namespace hpx.

Does this PR add anything in addition to the API extensions that would be worth keeping?

…ntil, and hpx::is_partitioned CPOs The hpx:: (non-ranges) CPOs for is_sorted, is_sorted_until, and is_partitioned did not expose a Proj parameter in their tag_fallback_invoke overloads, despite the internal algorithm implementations (hpx::parallel::detail::is_sorted, is_sorted_until, is_partitioned) fully supporting projections via the Proj template parameter. This adds new tag_fallback_invoke overloads with Proj defaulting to hpx::identity alongside the existing overloads (which are unchanged for full backward compatibility). The constraint uses hpx::parallel::traits::is_projected_v<Proj, FwdIter> to maintain proper SFINAE behavior. Also adds hpx/algorithms/traits/projected.hpp include to both headers and a new regression test is_sorted_projection.cpp that exercises seq, par, and par(task) policies with all three algorithms. Closes: projection gap between hpx:: and hpx::ranges:: algorithm APIs

…aits

…nd is_partitioned

… sequential

hkaiser · 2026-04-23T19:51:56Z

                    bool fst_bool = HPX_INVOKE(pred_projected, *part_begin);
                    if (part_count == 1)
-                        return fst_bool;
+                        return fst_bool ? 1 : 0;


Please use an enum class for this.

Fixed. I've introduced enum class partition_status to handle the different partitioning states clearly.

hkaiser · 2026-04-23T19:52:29Z

+            return hpx::parallel::detail::is_partitioned<FwdIter, FwdIter>()
+                .call(HPX_FORWARD(ExPolicy, policy), first, last,
+                    HPX_MOVE(pred), HPX_MOVE(proj));
+        }


Please revert the API changes.

hkaiser · 2026-04-23T19:52:59Z

-        FwdIter>::type
-    is_sorted_until(
-        ExPolicy&& policy, FwdIter first, FwdIter last, Pred&& pred = Pred());
-}    // namespace hpx


WHy have you removed the documentation?

hkaiser · 2026-04-23T19:53:31Z

-#include <hpx/modules/iterator_support.hpp>
-#include <hpx/parallel/algorithms/detail/dispatch.hpp>
+
+#include <hpx/algorithms/traits/projected.hpp>


Please always use the generated module headers to avoid problems with C++ modules.

hkaiser · 2026-04-23T19:54:22Z

                    -> intermediate_result_t {
                    FwdIter_ trail = part_begin++;
-                    util::loop_n<std::decay_t<ExPolicy>>(part_begin,
+                    util::loop_n<hpx::execution::sequenced_policy>(part_begin,


This may lose context (such like vectorization, etc.)

hkaiser · 2026-04-23T19:55:02Z

                auto f2 = [](auto&& results) {
                    return std::all_of(hpx::util::begin(results),
-                        hpx::util::end(results), hpx::functional::unwrap{});
+                        hpx::util::end(results), [](auto x) { return x; });


What is the rationale of this change, please explain. Did some tests fail?

hkaiser · 2026-04-23T19:56:21Z

-                using partitioner_type =
-                    util::partitioner<policy_type, FwdIter_, void>;
-                return partitioner_type::call_with_index(
+                return util::partitioner<ExPolicy, FwdIter_>::call_with_index(


This will again lose context.

hkaiser · 2026-04-23T19:56:41Z

+            return hpx::parallel::detail::is_sorted<FwdIter, FwdIter>().call(
+                HPX_FORWARD(ExPolicy, policy), first, last, HPX_MOVE(pred),
+                HPX_MOVE(proj));
+        }


Please roll back all API changes.

hkaiser · 2026-04-23T19:58:01Z

                iterator_type>()
-                .call(hpx::execution::seq, std::begin(rng), std::end(rng),
-                    HPX_MOVE(pred), HPX_MOVE(proj));
+                .call(hpx::execution::seq, hpx::util::begin(rng),


What's the rationale of this change? I'd have expected to see changes the other way around (i.e., moving towards the standard, not away from it).

…or is_sorted and is_partitioned Standardized iterator and reference deduction using hpx::traits and corrected CRTP base class initialization to resolve dispatch errors in segmented contexts. Verified fixes with partitioned_vector test suite.

1. Reintroduced enum class for partition_status. 2. Restored module-style headers. 3. Reverted to std::begin/end for ranges. 4. Fixed execution context loss in local loops by using conditional unsequenced_policy. 5. Restored clear_container in results aggregation.

hkaiser · 2026-04-26T15:55:36Z

    namespace detail {
+        enum class partition_status : std::uint8_t
+        {
+            false_ = 0,


Could you come up with slightly more descriptive names, please? What is false_, what is true_? Does it refer to whether a given chunk is partitioned? Why not call it is_partitioned and is_not_partitioned in this case?

hkaiser · 2026-04-26T15:56:17Z

+                        hpx::is_unsequenced_execution_policy_v<
+                            std::decay_t<ExPolicy>>,
+                        hpx::execution::unsequenced_policy,
+                        hpx::execution::sequenced_policy>;


Why is this needed?

aneek22112007-tech requested a review from hkaiser as a code owner April 22, 2026 21:44

hkaiser added type: enhancement type: compatibility issue category: algorithms labels Apr 22, 2026

hkaiser reviewed Apr 22, 2026

View reviewed changes

aneek22112007-tech force-pushed the fix/is-sorted-is-partitioned-projection branch from 53efabd to aab602f Compare April 22, 2026 22:33

dasaneek007-cpu added 6 commits April 23, 2026 23:09

Remove inline comments from is_sorted_projection test

01e66d6

Fix is_sorted_until cross-chunk cancellation indexing bug

118ce13

Fix clang-format issues in test file

b1223a9

Fix ambiguity in is_sorted and is_partitioned overloads and update tr…

4e02198

…aits

Apply clang-format

aba2785

aneek22112007-tech force-pushed the fix/is-sorted-is-partitioned-projection branch from 4ae69b8 to aba2785 Compare April 23, 2026 17:41

dasaneek007-cpu added 2 commits April 23, 2026 23:50

Fix formatting, missing templates, and parallel logic for is_sorted a…

ccca6a4

…nd is_partitioned

Fix data races in parallel algorithms by ensuring per-chunk loops are…

4809671

… sequential

aneek22112007-tech force-pushed the fix/is-sorted-is-partitioned-projection branch from f25e11d to 4809671 Compare April 23, 2026 18:26

Fix iterator vs value type mismatch in util::loop_n callbacks

0bf482f

hkaiser reviewed Apr 23, 2026

View reviewed changes

dasaneek007-cpu and others added 3 commits April 24, 2026 15:50

Merge branch 'master' into fix/is-sorted-is-partitioned-projection

eccc0e0

hkaiser reviewed Apr 26, 2026

View reviewed changes

Uh oh!

Conversation

aneek22112007-tech commented Apr 22, 2026

Summary

Changes

Technical Rationale

Testing

Uh oh!

StellarBot commented Apr 22, 2026

Uh oh!

codacy-production Bot commented Apr 22, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Up to standards ✅

Uh oh!

hkaiser left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

codacy-production Bot commented Apr 22, 2026 •

edited

Loading