Prototype __tuple_for_each and __tuple_apply for zip_view

include/oneapi/dpl/internal/binary_search_impl.h

@@ -62,17 +62,17 @@ struct __custom_brick
         using std::get;
         if constexpr (func == search_algorithm::lower_bound)
         {
-            get<2>(acc[idx]) = oneapi::dpl::__internal::__shars_lower_bound(get<0>(acc.tuple()), start_orig, end_orig,
+            get<2>(acc[idx]) = oneapi::dpl::__internal::__shars_lower_bound(get<0>(acc.base()), start_orig, end_orig,
                                                                             get<1>(acc[idx]), comp);
         }
         else if constexpr (func == search_algorithm::upper_bound)
         {
-            get<2>(acc[idx]) = oneapi::dpl::__internal::__shars_upper_bound(get<0>(acc.tuple()), start_orig, end_orig,
+            get<2>(acc[idx]) = oneapi::dpl::__internal::__shars_upper_bound(get<0>(acc.base()), start_orig, end_orig,
                                                                             get<1>(acc[idx]), comp);
         }
         else
         {
-            auto value = oneapi::dpl::__internal::__shars_lower_bound(get<0>(acc.tuple()), start_orig, end_orig,
+            auto value = oneapi::dpl::__internal::__shars_lower_bound(get<0>(acc.base()), start_orig, end_orig,
                                                                       get<1>(acc[idx]), comp);
             get<2>(acc[idx]) = (value != end_orig) && (get<1>(acc[idx]) == get<0>(acc[value]));
         }

include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl_reduce_then_scan.h

@@ -88,7 +88,7 @@ struct __extract_range_from_zip
     auto
     operator()(const _InRng& __in_rng) const
     {
-        return std::get<_EleId>(__in_rng.tuple());
+        return std::get<_EleId>(__in_rng.base());
     }
 };
 
@@ -186,7 +186,7 @@ struct __write_red_by_seg
         using std::get;
 
         // Get source tuple
-        auto&& __tuple = __out_rng.tuple();
+        auto&& __tuple = __out_rng.base();
 
         auto __out_keys = get<0>(__tuple);
         auto __out_values = get<1>(__tuple);
@@ -386,7 +386,7 @@ struct __gen_set_mask
     operator()(const _InRng& __in_rng, std::size_t __id) const
     {
         // Get tuple from source range
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         // First we must extract individual sequences from zip iterator because they may not have the same length,
         // dereferencing is dangerous
@@ -642,13 +642,13 @@ struct __get_bounds_partitioned
     operator()(const _Rng& __in_rng, const _IndexT __id) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         auto __rng_tmp_diag = std::get<2>(__tuple); // set a temp storage sequence
 
         using _SizeType = std::common_type_t<
-            std::make_unsigned_t<decltype(oneapi::dpl::__ranges::__size(std::get<0>(__in_rng.tuple())))>,
-            std::make_unsigned_t<decltype(oneapi::dpl::__ranges::__size(std::get<1>(__in_rng.tuple())))>,
+            std::make_unsigned_t<decltype(oneapi::dpl::__ranges::__size(std::get<0>(__in_rng.base())))>,
+            std::make_unsigned_t<decltype(oneapi::dpl::__ranges::__size(std::get<1>(__in_rng.base())))>,
             std::make_unsigned_t<decltype(oneapi::dpl::__ranges::__size(__rng_tmp_diag))>>;
 
         // Establish bounds of ranges for the tile from sparse partitioning pass kernel
@@ -677,7 +677,7 @@ struct __get_bounds_simple
     operator()(const _Rng& __in_rng, const _IndexT) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         const auto __rng1 = std::get<0>(__tuple); // first sequence
         const auto __rng2 = std::get<1>(__tuple); // second sequence
@@ -771,7 +771,7 @@ struct __gen_set_balanced_path
     calc_and_store_balanced_path(_InRng& __in_rng, _IndexT __id, _BoundsProviderLocal __get_bounds_local) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         // First we must extract individual sequences from zip iterator because they may not have the same length,
         // dereferencing is dangerous
@@ -819,7 +819,7 @@ struct __gen_set_balanced_path
     operator()(const _InRng& __in_rng, _IndexT __id, TempData& __temp_data) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         // First we must extract individual sequences from zip iterator because they may not have the same length,
         // dereferencing is dangerous
@@ -892,7 +892,7 @@ struct __gen_set_op_from_known_balanced_path
     operator()(const _InRng& __in_rng, _IndexT __id, _TempData& __output_data) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         // First we must extract individual sequences from zip iterator because they may not have the same length,
         // dereferencing is dangerous
@@ -973,7 +973,7 @@ struct __gen_red_by_seg_reduce_input
     operator()(const _InRng& __in_rng, std::size_t __id, TempData&) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         const auto __in_keys = std::get<0>(__tuple);
         const auto __in_vals = std::get<1>(__tuple);
@@ -1000,8 +1000,8 @@ struct __gen_scan_by_seg_reduce_input
     auto
     operator()(const _InRng& __in_rng, std::size_t __id, TempData&) const
     {
-        // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        // Get source base
+        auto&& __tuple = __in_rng.base();
 
         const auto __in_keys = std::get<0>(__tuple);
         const auto __in_vals = std::get<1>(__tuple);
@@ -1030,7 +1030,7 @@ struct __gen_red_by_seg_scan_input
     operator()(const _InRng& __in_rng, std::size_t __id, TempData&) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         const auto __in_keys = std::get<0>(__tuple);
         const auto __in_vals = std::get<1>(__tuple);
@@ -1083,7 +1083,7 @@ struct __gen_scan_by_seg_scan_input
     operator()(const _InRng& __in_rng, std::size_t __id, TempData&) const
     {
         // Get source tuple
-        auto&& __tuple = __in_rng.tuple();
+        auto&& __tuple = __in_rng.base();
 
         const auto __in_keys = std::get<0>(__tuple);
         const auto __in_vals = std::get<1>(__tuple);

include/oneapi/dpl/pstl/hetero/dpcpp/unseq_backend_sycl.h

@@ -691,7 +691,7 @@ struct __create_mask
     _ValueType
     operator()(const _Idx __idx, const oneapi::dpl::__ranges::zip_view<_Ranges...>& __input) const
     {
-        bool __mask_value = __pred(std::get<0>(__input.tuple()), __idx);
+        bool __mask_value = __pred(std::get<0>(__input.base()), __idx);
         std::get<1>(__input[__idx]) = __mask_value;
         return _ValueType(__mask_value);
     }
@@ -1279,7 +1279,7 @@ class __brick_set_op
         using std::get;
 
         // Get source tuple
-        auto&& __tuple = __inout_acc.tuple();
+        auto&& __tuple = __inout_acc.base();
 
         auto __a = get<0>(__tuple); // first sequence
         auto __b = get<1>(__tuple); // second sequence

include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h

@@ -253,6 +253,12 @@ using val_t = typename ::std::iterator_traits<_Iter>::value_type;
 
 //range/zip_view/all_view/ variadic utilities
 
+#if _ONEDPL_CPP20_RANGES_PRESENT
+namespace _dpl_ranges_zip = oneapi::dpl::ranges::__internal;
+#else
+namespace _dpl_ranges_zip = oneapi::dpl::__ranges;
+#endif //_ONEDPL_CPP20_RANGES_PRESENT
+
 //forward declaration required for _require_access_args
 template <typename _Range, typename... _Ranges>
 void
@@ -272,10 +278,10 @@ struct _require_access_args
 
 template <typename... _Ranges>
 void
-__require_access_zip(sycl::handler& __cgh, oneapi::dpl::__ranges::zip_view<_Ranges...>& __zip)
+__require_access_zip(sycl::handler& __cgh, _dpl_ranges_zip::zip_view<_Ranges...>& __zip)
 {
     const ::std::size_t __num_ranges = sizeof...(_Ranges);
-    oneapi::dpl::__ranges::invoke(__zip.tuple(), _require_access_args<decltype(__cgh)>{__cgh},
+    oneapi::dpl::__ranges::invoke(__zip.base(), _require_access_args<decltype(__cgh)>{__cgh},
                                   ::std::make_index_sequence<__num_ranges>());
 }
 
@@ -295,7 +301,7 @@ __require_access_range(sycl::handler& __cgh, oneapi::dpl::__ranges::all_view<T,
 
 template <typename... _Ranges>
 void
-__require_access_range(sycl::handler& __cgh, zip_view<_Ranges...>& zip_rng)
+__require_access_range(sycl::handler& __cgh, _dpl_ranges_zip::zip_view<_Ranges...>& zip_rng)
 {
     __require_access_zip(__cgh, zip_rng);
 }

include/oneapi/dpl/pstl/onedpl_config.h

@@ -292,6 +292,18 @@
 #    define _ONEDPL_CPP26_DEFAULT_VALUE_TYPE_PRESENT 0
 #endif
 
+// std::views::all on rvalue non-view ranges requires P2415R2 owning_view.
+// - libstdc++ (GCC or Clang+libstdc++): available since GCC 12
+// - libc++    (Clang+libc++):           available since LLVM 16
+// - MSVC STL:                           available since C++23
+#if defined(__GLIBCXX__)
+#    define _ONEDPL_CPP20_OWNING_VIEW_PRESENT (_GLIBCXX_RELEASE >= 12)
+#elif defined(_LIBCPP_VERSION)
+#    define _ONEDPL_CPP20_OWNING_VIEW_PRESENT (_LIBCPP_VERSION >= 16000)
+#else
+#    define _ONEDPL_CPP20_OWNING_VIEW_PRESENT (_ONEDPL___cplusplus >= 202302L)
+#endif
+
 // When C++20 concepts are available, we must use std::tuple as a proxy reference to satisfy iterator concepts, which
 // requires the changes to std::tuple in P2321R2 and the tuple-like basic_common_reference specialization in P2165R4.
 #define _ONEDPL_CAN_USE_STD_TUPLE_PROXY_ITERATOR                                                                       \

include/oneapi/dpl/pstl/ranges_defs.h

@@ -21,6 +21,8 @@
 
 #if _ONEDPL_CPP20_RANGES_PRESENT
 #include <ranges>
+//support zip_view (like in C++23) for C++20
+#include "zip_view_impl.h"
 #endif
 
 #include "utils_ranges.h"
@@ -43,7 +45,11 @@ namespace ranges
 using oneapi::dpl::__ranges::all_view;
 #endif // _ONEDPL_BACKEND_SYCL
 using oneapi::dpl::__ranges::guard_view;
+#if _ONEDPL_CPP20_RANGES_PRESENT
+using oneapi::dpl::ranges::__internal::zip_view;
+#else
 using oneapi::dpl::__ranges::zip_view;
+#endif //_ONEDPL_CPP20_RANGES_PRESENT
 
 //views
 using __nanorange::nano::ranges::drop_view;
@@ -72,9 +78,20 @@ using __nanorange::nano::views::take;
 using __nanorange::nano::views::transform;
 
 using __nanorange::nano::subrange;
+#if _ONEDPL_CPP20_RANGES_PRESENT
+using oneapi::dpl::ranges::__internal::zip;
+#endif //_ONEDPL_CPP20_RANGES_PRESENT
 } // namespace views
 
 } // namespace ranges
+
+#if _ONEDPL_CPP20_RANGES_PRESENT
+namespace views
+{
+using oneapi::dpl::ranges::__internal::zip;
+} // namespace views
+#endif //_ONEDPL_CPP20_RANGES_PRESENT
+
 } // namespace experimental
 } // namespace dpl
 } // namespace oneapi

include/oneapi/dpl/pstl/tuple_impl.h

@@ -416,7 +416,12 @@ struct tuple<T1, T...>
         return get_impl<I>()(::std::move(*this));
     }
 
-    tuple() = default;
+    template <typename _Tp = T1,
+              std::enable_if_t<
+                  std::conjunction_v<std::is_default_constructible<_Tp>, std::is_default_constructible<T>...>, int> = 0>
+    tuple() : holder{}, next{}
+    {
+    } //The std::tuple value-initializes all elements, so we also follow this.
     tuple(const tuple& other) = default;
     tuple(tuple&& other) = default;
     template <typename _U1, typename... _U, typename = ::std::enable_if_t<(sizeof...(_U) == sizeof...(T))>>
@@ -499,6 +504,15 @@ struct tuple<T1, T...>
         return *this;
     }
 
+    template <typename U1, typename... U>
+    const tuple&
+    operator=(const tuple<U1, U...>& other) const
+    {
+        holder.value = other.holder.value;
+        next = other.next;
+        return *this;
+    }
+
     // if T1 is deduced with reference, compiler generates deleted operator= and,
     // since "template operator=" is not considered as operator= overload
     // the deleted operator= has a preference during lookup
@@ -589,6 +603,11 @@ struct tuple<>
     operator=(const tuple&) = default;
     tuple&
     operator=(const ::std::tuple<>& /*other*/)
+    {
+        return *this;
+    }
+	const tuple&
+    operator=(const std::tuple<>&) const
     {
         return *this;
     }

include/oneapi/dpl/pstl/utils_ranges.h

@@ -381,7 +381,7 @@ class zip_view
     }
 
     _tuple_ranges_t
-    tuple() const
+    base() const
     {
         return __m_ranges;
     }