[onedpl][ranges][productization] Range API productization, MVP plan, Part 1

.github/workflows/ci.yml

@@ -170,6 +170,24 @@ jobs:
             build_type: release
             backend: serial
             device_type: HOST
+          - os: ubuntu-latest
+            cxx_compiler: icpx
+            std: 20
+            build_type: release
+            backend: dpcpp
+            device_type: CPU
+          - os: ubuntu-latest
+            cxx_compiler: icpx
+            std: 20
+            build_type: release
+            backend: tbb
+            device_type: HOST
+          - os: ubuntu-latest
+            cxx_compiler: icpx
+            std: 20
+            build_type: release
+            backend: omp
+            device_type: HOST
     steps:
       - uses: actions/checkout@v4
       - name: Set up Intel APT repository
@@ -209,8 +227,8 @@ jobs:
           echo "::warning::Compiler: $(${{ matrix.cxx_compiler }} --version)"
 
           if [[ "${{ matrix.backend }}" == "dpcpp" ]]; then
-            make_targets="build-onedpl-sycl_iterator-tests"
-            ctest_flags="-R sycl_iterator_.*\.pass"
+            make_targets="build-onedpl-sycl_iterator-tests build-onedpl-ranges-tests"
+            ctest_flags="-R (sycl_iterator_.*)|(std_ranges_.*)\.pass"
             echo "::warning::dpcpp backend is set. Compile and run only sycl_iterator tests"
           else
             make_targets="build-onedpl-tests"

include/oneapi/dpl/algorithm

@@ -25,6 +25,7 @@
 #if !_ONEDPL_ALGORITHM_FORWARD_DECLARED
 // If not declared, pull in forward declarations
 #    include "oneapi/dpl/pstl/glue_algorithm_defs.h"
+#    include "oneapi/dpl/pstl/glue_algorithm_ranges_defs.h"
 #    include "oneapi/dpl/internal/by_segment_extension_defs.h"
 #    include "oneapi/dpl/internal/binary_search_extension_defs.h"
 #    include "oneapi/dpl/pstl/histogram_extension_defs.h"
@@ -34,6 +35,7 @@
 #if _ONEDPL_EXECUTION_POLICIES_DEFINED
 // If <execution> has already been included, pull in implementations
 #    include "oneapi/dpl/pstl/glue_algorithm_impl.h"
+#    include "oneapi/dpl/pstl/glue_algorithm_ranges_impl.h"
 #    include "oneapi/dpl/pstl/histogram_impl.h"
 
 #    include "oneapi/dpl/internal/exclusive_scan_by_segment_impl.h"

include/oneapi/dpl/execution

@@ -32,6 +32,7 @@
 // If the forward declarations have already been processed, pull the implementations
 #if _ONEDPL_ALGORITHM_FORWARD_DECLARED
 #    include "oneapi/dpl/pstl/glue_algorithm_impl.h"
+#    include "oneapi/dpl/pstl/glue_algorithm_ranges_impl.h"
 #    include "oneapi/dpl/pstl/histogram_impl.h"
 
 #    include "oneapi/dpl/internal/exclusive_scan_by_segment_impl.h"

include/oneapi/dpl/internal/reduce_by_segment_impl.h

@@ -57,7 +57,6 @@
 #include "../pstl/utils_ranges.h"
 #include "../pstl/hetero/dpcpp/utils_ranges_sycl.h"
 #include "../pstl/ranges_defs.h"
-#include "../pstl/glue_algorithm_ranges_defs.h"
 #include "../pstl/glue_algorithm_ranges_impl.h"
 #include "../pstl/hetero/dpcpp/sycl_traits.h" //SYCL traits specialization for some oneDPL types.
 #include "scan_by_segment_impl.h"

include/oneapi/dpl/pstl/algorithm_impl.h

@@ -756,8 +756,9 @@ __find_subrange(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _
     while (__first != __last && (__global_last - __first >= __n2))
     {
         // find position of *s_first in [first, last) (it can be start of subsequence)
-        __first = __internal::__brick_find_if(
-            __first, __last, __equal_value_by_pred<_ValueType, _BinaryPredicate&>(*__s_first, __pred), __is_vector);
+        auto __u_pred =
+            [__pred, __s_first](auto&& __val) mutable { return __pred(std::forward<decltype(__val)>(__val), *__s_first); };
+        __first = __internal::__brick_find_if(__first, __last, __u_pred, __is_vector);
 
         // if position that was found previously is the start of subsequence
         // then we can exit the loop (b_first == true) or keep the position
@@ -804,7 +805,8 @@ __find_subrange(_RandomAccessIterator __first, _RandomAccessIterator __last, _Ra
         return __last;
     }
 
-    auto __unary_pred = __equal_value_by_pred<_Tp, _BinaryPredicate&>(__value, __pred);
+    auto __unary_pred =
+        [__pred, &__value](auto&& __val) mutable { return __pred(std::forward<decltype(__val)>(__val), __value); };
     while (__first != __last && (static_cast<_Size>(__global_last - __first) >= __count))
     {
         __first = __internal::__brick_find_if(__first, __last, __unary_pred, __is_vector);
@@ -1021,9 +1023,9 @@ __pattern_search_n(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec, _
 {
     if (static_cast<_Size>(__last - __first) == __count)
     {
-        const bool __result =
-            !__internal::__pattern_any_of(__tag, ::std::forward<_ExecutionPolicy>(__exec), __first, __last,
-                                          [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); });
+        const bool __result = !__internal::__pattern_any_of(__tag, std::forward<_ExecutionPolicy>(__exec), __first,
+            __last, [&__value, __pred](auto&& __val) mutable { return !__pred(std::forward<decltype(__val)>(__val),
+            __value); });
         return __result ? __first : __last;
     }
     else

include/oneapi/dpl/pstl/algorithm_ranges_impl.h

@@ -0,0 +1,263 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// This file incorporates work covered by the following copyright and permission
+// notice:
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _ONEDPL_ALGORITHM_RANGES_IMPL_H
+#define _ONEDPL_ALGORITHM_RANGES_IMPL_H
+
+#if _ONEDPL_CPP20_RANGES_PRESENT
+
+#include <ranges>
+#include <utility>
+#include <functional>
+#include <type_traits>
+
+#include "algorithm_fwd.h"
+#include "execution_impl.h"
+
+namespace oneapi
+{
+namespace dpl
+{
+namespace __internal
+{
+namespace __ranges
+{
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_for_each
+//---------------------------------------------------------------------------------------------------------------------
+
+template <typename _Tag, typename _ExecutionPolicy, typename _R, typename _Proj, typename _Fun>
+void
+__pattern_for_each(_Tag __tag, _ExecutionPolicy&& __exec, _R&& __r, _Fun __f, _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __f_1 =
+        [__f, __proj](auto&& __val) { std::invoke(__f, std::invoke(__proj, std::forward<decltype(__val)>(__val)));};
+
+    oneapi::dpl::__internal::__pattern_walk1(__tag, std::forward<_ExecutionPolicy>(__exec), std::ranges::begin(__r),
+        std::ranges::begin(__r) + std::ranges::size(__r), __f_1);
+}
+
+template <typename _ExecutionPolicy, typename _R, typename _Proj, typename _Fun>
+void
+__pattern_for_each(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R&& __r, _Fun __f, _Proj __proj)
+{
+    std::ranges::for_each(std::forward<_R>(__r), __f, __proj);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_transform
+//---------------------------------------------------------------------------------------------------------------------
+
+template<typename _Tag, typename _ExecutionPolicy, typename _InRange, typename _OutRange, typename _F, typename _Proj>
+void
+__pattern_transform(_Tag __tag, _ExecutionPolicy&& __exec, _InRange&& __in_r, _OutRange&& __out_r, _F __op,
+                    _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+    assert(std::ranges::size(__in_r) <= std::ranges::size(__out_r));
+
+    auto __unary_op = [__op, __proj](auto&& __val) -> decltype(auto) {
+        return std::invoke(__op, std::invoke(__proj, std::forward<decltype(__val)>(__val)));};
+
+    oneapi::dpl::__internal::__pattern_walk2(__tag, std::forward<_ExecutionPolicy>(__exec), std::ranges::begin(__in_r),
+        std::ranges::begin(__in_r) + std::ranges::size(__in_r), std::ranges::begin(__out_r),
+        oneapi::dpl::__internal::__transform_functor<decltype(__unary_op)>{std::move(__unary_op)});
+}
+
+template<typename _ExecutionPolicy, typename _InRange, typename _OutRange, typename _F, typename _Proj>
+void
+__pattern_transform(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _InRange&& __in_r, _OutRange&& __out_r,
+                    _F __op, _Proj __proj)
+{
+    std::ranges::transform(std::forward<_InRange>(__in_r), std::ranges::begin(__out_r), __op, __proj);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_transform (binary vesrion)
+//---------------------------------------------------------------------------------------------------------------------
+
+template<typename _Tag, typename _ExecutionPolicy, typename _InRange1, typename _InRange2, typename _OutRange,
+         typename _F, typename _Proj1, typename _Proj2>
+void
+__pattern_transform(_Tag __tag, _ExecutionPolicy&& __exec, _InRange1&& __in_r1, _InRange2&& __in_r2,
+                    _OutRange&& __out_r, _F __binary_op, _Proj1 __proj1,_Proj2 __proj2)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __f = [__binary_op, __proj1, __proj2](auto&& __val1, auto&& __val2) -> decltype(auto) {
+        return std::invoke(__binary_op, std::invoke(__proj1, std::forward<decltype(__val1)>(__val1)),
+            std::invoke(__proj2, std::forward<decltype(__val2)>(__val2)));};
+
+    oneapi::dpl::__internal::__pattern_walk3(__tag, std::forward<_ExecutionPolicy>(__exec), std::ranges::begin(__in_r1),
+        std::ranges::begin(__in_r1) + std::ranges::size(__in_r1), std::ranges::begin(__in_r2),
+        std::ranges::begin(__out_r), oneapi::dpl::__internal::__transform_functor<decltype(__f)>{std::move(__f)});
+}
+
+template<typename _ExecutionPolicy, typename _InRange1, typename _InRange2, typename _OutRange, typename _F,
+         typename _Proj1, typename _Proj2>
+void
+__pattern_transform(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _InRange1&& __in_r1, _InRange2&& __in_r2, _OutRange&& __out_r,
+                    _F __binary_op, _Proj1 __proj1, _Proj2 __proj2)
+{
+    std::ranges::transform(std::forward<_InRange1>(__in_r1), std::forward<_InRange2>(__in_r2),
+                           std::ranges::begin(__out_r), __binary_op, __proj1, __proj2);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_find_if
+//---------------------------------------------------------------------------------------------------------------------
+
+template <typename _Tag, typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+auto
+__pattern_find_if(_Tag __tag, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred, _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __pred_1 = [__pred, __proj](auto&& __val) {
+        return std::invoke(__pred, std::invoke(__proj, std::forward<decltype(__val)>(__val)));};
+
+    return std::ranges::borrowed_iterator_t<_R>(oneapi::dpl::__internal::__pattern_find_if(__tag,
+        std::forward<_ExecutionPolicy>(__exec), std::ranges::begin(__r), std::ranges::begin(__r) +
+        std::ranges::size(__r), __pred_1));
+}
+
+template <typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+auto
+__pattern_find_if(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred, _Proj __proj)
+{
+    return std::ranges::find_if(std::forward<_R>(__r), __pred, __proj);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_any_of
+//---------------------------------------------------------------------------------------------------------------------
+
+template <typename _Tag, typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+bool
+__pattern_any_of(_Tag __tag, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred, _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __pred_1 = [__pred, __proj](auto&& __val) {
+        return std::invoke(__pred, std::invoke(__proj, std::forward<decltype(__val)>(__val)));};
+    return oneapi::dpl::__internal::__pattern_any_of(__tag, std::forward<_ExecutionPolicy>(__exec),
+        std::ranges::begin(__r), std::ranges::begin(__r) + std::ranges::size(__r), __pred_1);
+}
+
+template <typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+bool
+__pattern_any_of(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred, _Proj __proj)
+{
+    return std::ranges::any_of(std::forward<_R>(__r), __pred, __proj);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_adjacent_find
+//---------------------------------------------------------------------------------------------------------------------
+
+template <typename _Tag, typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+auto
+__pattern_adjacent_find_ranges(_Tag __tag, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred,
+                        _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __pred_2 = [__pred, __proj](auto&& __val, auto&& __next) { return std::invoke(__pred, std::invoke(__proj,
+        std::forward<decltype(__val)>(__val)), std::invoke(__proj, std::forward<decltype(__next)>(__next)));};
+
+    auto __res = oneapi::dpl::__internal::__pattern_adjacent_find(__tag, std::forward<_ExecutionPolicy>(__exec),
+        std::ranges::begin(__r), std::ranges::begin(__r) + std::ranges::size(__r), __pred_2,
+        oneapi::dpl::__internal::__first_semantic());
+    return std::ranges::borrowed_iterator_t<_R>(__res);
+}
+
+template <typename _ExecutionPolicy, typename _R, typename _Proj, typename _Pred>
+auto
+__pattern_adjacent_find_ranges(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R&& __r, _Pred __pred, _Proj __proj)
+{
+    return std::ranges::adjacent_find(std::forward<_R>(__r), __pred, __proj);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_search
+//---------------------------------------------------------------------------------------------------------------------
+
+template<typename _Tag, typename _ExecutionPolicy, typename _R1, typename _R2, typename _Pred, typename _Proj1,
+         typename _Proj2>
+auto
+__pattern_search(_Tag __tag, _ExecutionPolicy&& __exec, _R1&& __r1, _R2&& __r2, _Pred __pred,
+                 _Proj1 __proj1, _Proj2 __proj2)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __pred_2 = [__pred, __proj1, __proj2](auto&& __val1, auto&& __val2) { return std::invoke(__pred,
+        std::invoke(__proj1, std::forward<decltype(__val1)>(__val1)),
+        std::invoke(__proj2, std::forward<decltype(__val2)>(__val2)));};
+
+    auto __res = oneapi::dpl::__internal::__pattern_search(__tag, std::forward<_ExecutionPolicy>(__exec),
+        std::ranges::begin(__r1), std::ranges::begin(__r1) + std::ranges::size(__r1), std::ranges::begin(__r2),
+        std::ranges::begin(__r2) + std::ranges::size(__r2), __pred_2);
+
+    return std::ranges::borrowed_subrange_t<_R1>(__res, __res == std::ranges::end(__r1)
+        ? __res : __res + std::ranges::size(__r2));
+}
+
+template<typename _ExecutionPolicy, typename _R1, typename _R2, typename _Pred, typename _Proj1,
+         typename _Proj2>
+auto
+__pattern_search(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R1&& __r1, _R2&& __r2, _Pred __pred, _Proj1 __proj1, _Proj2 __proj2)
+{
+    return std::ranges::search(std::forward<_R1>(__r1), std::forward<_R2>(__r2), __pred, __proj1, __proj2);
+}
+
+//---------------------------------------------------------------------------------------------------------------------
+// pattern_search_n
+//---------------------------------------------------------------------------------------------------------------------
+
+template<typename _Tag, typename _ExecutionPolicy, typename _R, typename _T, typename _Pred, typename _Proj>
+auto
+__pattern_search_n(_Tag __tag, _ExecutionPolicy&& __exec, _R&& __r,
+                   std::ranges::range_difference_t<_R> __count, const _T& __value, _Pred __pred, _Proj __proj)
+{
+    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
+
+    auto __pred_2 = [__pred, __proj](auto&& __val1, auto&& __val2) { return std::invoke(__pred,
+        std::invoke(__proj, std::forward<decltype(__val1)>(__val1)), std::forward<decltype(__val2)>(__val2));};
+
+    auto __res = oneapi::dpl::__internal::__pattern_search_n(__tag, std::forward<_ExecutionPolicy>(__exec),
+        std::ranges::begin(__r), std::ranges::begin(__r) + std::ranges::size(__r), __count, __value, __pred_2);
+
+    return std::ranges::borrowed_subrange_t<_R>(__res, __res == std::ranges::end(__r) ? __res : __res + __count);
+}
+
+template<typename _ExecutionPolicy, typename _R, typename _T, typename _Pred, typename _Proj>
+auto
+__pattern_search_n(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R&& __r, std::ranges::range_difference_t<_R> __count, const _T& __value,
+                   _Pred __pred, _Proj __proj)
+{
+    return std::ranges::search_n(std::forward<_R>(__r), __count, __value, __pred, __proj);
+}
+
+} // namespace __ranges
+} // namespace __internal
+} // namespace dpl
+} // namespace oneapi
+
+#endif //_ONEDPL_CPP20_RANGES_PRESENT
+
+#endif // _ONEDPL_ALGORITHM_RANGES_IMPL_H

include/oneapi/dpl/pstl/execution_defs.h

@@ -82,6 +82,9 @@ inline constexpr bool is_execution_policy_v = oneapi::dpl::execution::is_executi
 } // namespace v1
 } // namespace execution
 
+using oneapi::dpl::execution::is_execution_policy;
+using oneapi::dpl::execution::is_execution_policy_v;
+
 namespace __internal
 {
 
@@ -110,7 +113,7 @@ struct __is_host_execution_policy<oneapi::dpl::execution::unsequenced_policy> :
 
 template <class _ExecPolicy, class _T = void>
 using __enable_if_execution_policy =
-    ::std::enable_if_t<oneapi::dpl::execution::is_execution_policy_v<::std::decay_t<_ExecPolicy>>, _T>;
+    std::enable_if_t<oneapi::dpl::is_execution_policy_v<std::decay_t<_ExecPolicy>>, _T>;
 
 template <typename _ExecPolicy, typename _T>
 struct __ref_or_copy_impl