[oneDPL][ranges][merge] support size limit for output; fixes and rafactoring

MikeDvorskiy · MikeDvorskiy · commit 6ec465c1b06a · 2024-11-27T18:45:33.000+01:00
diff --git a/include/oneapi/dpl/pstl/algorithm_impl.h b/include/oneapi/dpl/pstl/algorithm_impl.h
@@ -2950,7 +2950,8 @@ __pattern_remove_if(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec,
 
 template<std::random_access_iterator It1, std::random_access_iterator It2, std::random_access_iterator ItOut, typename _Comp>
 std::pair<It1, It2>
-__brick_merge(It1 __it_1, It1 __it_1_e, It2 __it_2, It2 __it_2_e, ItOut __it_out, ItOut __it_out_e, _Comp __comp)
+__brick_merge_2(It1 __it_1, It1 __it_1_e, It2 __it_2, It2 __it_2_e, ItOut __it_out, ItOut __it_out_e, _Comp __comp,
+              /* __is_vector = */ std::false_type)
 {
     while(__it_1 != __it_1_e && __it_2 != __it_2_e)
     {
@@ -2982,6 +2983,14 @@ __brick_merge(It1 __it_1, It1 __it_1_e, It2 __it_2, It2 __it_2_e, ItOut __it_out
     return {__it_1, __it_2};
 }
 
+template<std::random_access_iterator It1, std::random_access_iterator It2, std::random_access_iterator ItOut, typename _Comp>
+std::pair<It1, It2>
+__brick_merge_2(It1 __it_1, It1 __it_1_e, It2 __it_2, It2 __it_2_e, ItOut __it_out, ItOut __it_out_e, _Comp __comp,
+              /* __is_vector = */ std::true_type)
+{
+    return __unseq_backend::__simd_merge(__it_1, __it_1_e, __it_2, __it_2_e, __it_out, __it_out_e, __comp);
+}
+
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 __brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
@@ -3014,6 +3023,16 @@ __pattern_merge(_Tag, _ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIt
                                      typename _Tag::__is_vector{});
 }
 
+template<class _Tag, typename _ExecutionPolicy, typename _It1, typename _Index1, typename _It2,
+         typename _Index2, typename _OutIt, typename _Index3, typename _Comp>
+std::pair<_It1, _It2>
+__pattern_merge_2(_Tag, _ExecutionPolicy&& __exec, _It1 __it_1, _Index1 __n_1, _It2 __it_2,
+                _Index2 __n_2, _OutIt __it_out, _Index3 __n_out, _Comp __comp)
+{
+    return __brick_merge_2(__it_1, __it_1 + __n_1, __it_2, __it_2 + __n_2, __it_out, __it_out + __n_out, __comp,
+                           typename _Tag::__is_vector{});
+}
+
 template<typename _IsVector, typename _ExecutionPolicy, typename _It1, typename _Index1, typename _It2,
          typename _Index2, typename _OutIt, typename _Index3, typename _Comp>
 std::pair<_It1, _It2>
@@ -3062,16 +3081,16 @@ __pattern_merge_2(__parallel_tag<_IsVector>, _ExecutionPolicy&& __exec, _It1 __i
                                             }
 
                                             //serial merge n elements, starting from input x and y, to [i, j) output range
-                                            auto __res = __brick_merge(__it_1 + __r, __it_1 + __n_1,
+                                            auto __res = __brick_merge_2(__it_1 + __r, __it_1 + __n_1,
                                                                        __it_2 + __c, __it_2 + __n_2,
-                                                                       __it_out + __i, __it_out + __j, __comp);
+                                                                       __it_out + __i, __it_out + __j, __comp, _IsVector{});
 
                                             if(__j == __n_out)
                                             {
                                                 __it_res_1 = __res.first;
                                                 __it_res_2 = __res.second;
                                             }
-                                      }, _ONEDPL_MERGE_CUT_OFF);
+                                      }, _ONEDPL_MERGE_CUT_OFF); //grainsize
     });
 
     return {__it_res_1, __it_res_2};
@@ -3084,7 +3103,6 @@ __pattern_merge(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec, _Ran
                 _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2,
                 _RandomAccessIterator3 __d_first, _Compare __comp)
 {
-#if 0
     using __backend_tag = typename __parallel_tag<_IsVector>::__backend_tag;
 
     return __internal::__except_handler([&]() {
@@ -3097,13 +3115,6 @@ __pattern_merge(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec, _Ran
             });
         return __d_first + (__last1 - __first1) + (__last2 - __first2);
     });
-#else
-    auto __n_1 = __last1 - __first1;
-    auto __n_2 = __last2 - __first2;
-    auto __n_3 = __n_1 + __n_2;
-    __pattern_merge_2(__tag, std::forward<_ExecutionPolicy>(__exec), __first2, __n_2, __first1, __n_1, __d_first, __n_3, __comp);
-    return __d_first + __n_3;
-#endif
 }
 
 //------------------------------------------------------------------------
diff --git a/include/oneapi/dpl/pstl/algorithm_ranges_impl.h b/include/oneapi/dpl/pstl/algorithm_ranges_impl.h
@@ -447,29 +447,6 @@ template<typename _Tag, typename _ExecutionPolicy, typename _R1, typename _R2, t
 auto
 __pattern_merge(_Tag __tag, _ExecutionPolicy&& __exec, _R1&& __r1, _R2&& __r2, _OutRange&& __out_r, _Comp __comp,
                 _Proj1 __proj1, _Proj2 __proj2)
-{
-    static_assert(__is_parallel_tag_v<_Tag> || typename _Tag::__is_vector{});
-    assert(std::ranges::size(__r1) + std::ranges::size(__r2) <= std::ranges::size(__out_r)); // for debug purposes only
-
-    auto __comp_2 = [__comp, __proj1, __proj2](auto&& __val1, auto&& __val2) { return std::invoke(__comp,
-        std::invoke(__proj1, std::forward<decltype(__val1)>(__val1)), std::invoke(__proj2,
-        std::forward<decltype(__val2)>(__val2)));};
-
-    auto __res = oneapi::dpl::__internal::__pattern_merge(__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), std::ranges::begin(__out_r), __comp_2);
-
-    using __return_type = std::ranges::merge_result<std::ranges::borrowed_iterator_t<_R1>, std::ranges::borrowed_iterator_t<_R2>,
-        std::ranges::borrowed_iterator_t<_OutRange>>;
-
-    return __return_type{std::ranges::begin(__r1) + std::ranges::size(__r1), std::ranges::begin(__r2) + std::ranges::size(__r2), __res};
-}
-
-template<typename _IsVector, typename _ExecutionPolicy, typename _R1, typename _R2, typename _OutRange, typename _Comp,
-         typename _Proj1, typename _Proj2>
-auto
-__pattern_merge(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec, _R1&& __r1, _R2&& __r2, _OutRange&& __out_r, _Comp __comp,
-                _Proj1 __proj1, _Proj2 __proj2)
 {
     auto __comp_2 = [__comp, __proj1, __proj2](auto&& __val1, auto&& __val2) { return std::invoke(__comp,
         std::invoke(__proj1, std::forward<decltype(__val1)>(__val1)), std::invoke(__proj2,
@@ -495,48 +472,6 @@ __pattern_merge(__parallel_tag<_IsVector> __tag, _ExecutionPolicy&& __exec, _R1&
     return __return_type{__res.second, __res.first, __it_out + __n_out};
 }
 
-template<typename _ExecutionPolicy, typename _R1, typename _R2, typename _OutRange, typename _Comp,
-         typename _Proj1, typename _Proj2>
-auto
-__pattern_merge(__serial_tag</*IsVector*/std::false_type>, _ExecutionPolicy&& __exec, _R1&& __r1, _R2&& __r2, _OutRange&& __out_r, _Comp __comp,
-                _Proj1 __proj1, _Proj2 __proj2)
-{
-    using __return_type = std::ranges::merge_result<std::ranges::borrowed_iterator_t<_R1>, std::ranges::borrowed_iterator_t<_R2>,
-        std::ranges::borrowed_iterator_t<_OutRange>>;
-
-    auto __it_1 = std::ranges::begin(__r1);
-    auto __it_2 = std::ranges::begin(__r2);
-    auto __it_out = std::ranges::begin(__out_r);
-    while(__it_1 != std::ranges::end(__r1) && __it_2 != std::ranges::end(__r2))
-    {
-         if (std::invoke(__comp, std::invoke(__proj1, *__it_1), std::invoke(__proj2, *__it_2)))
-         {
-             *__it_out = *__it_1;
-             ++__it_out, ++__it_1;
-         }
-         else
-         {
-             *__it_out = *__it_2;
-             ++__it_out, ++__it_2;
-         }
-         if(__it_out == std::ranges::end(__out_r))
-            return __return_type{__it_1, __it_2, __it_out};
-    }
-
-    if(__it_1 == std::ranges::end(__r1))
-    {
-        for(; __it_2 != std::ranges::end(__r2) && __it_out != std::ranges::end(__out_r); ++__it_2, ++__it_out)
-            *__it_out = *__it_2;
-    }
-    else
-    {
-        //assert(__it_2 == std::ranges::end(__r2);
-        for(; __it_1 != std::ranges::end(__r1) && __it_out != std::ranges::end(__out_r); ++__it_1, ++__it_out)
-            *__it_out = *__it_1;
-    }
-    return __return_type{__it_1, __it_2, __it_out};
-}
-
 } // namespace __ranges
 } // namespace __internal
 } // namespace dpl
diff --git a/include/oneapi/dpl/pstl/unseq_backend_simd.h b/include/oneapi/dpl/pstl/unseq_backend_simd.h
@@ -880,34 +880,33 @@ __simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredi
     return __current + __cnt;
 }
 
-template<typename _Index1, typename _Index2, typename _Index3, typename _A, typename _B, typename _C>
-std::pair<_Index1, _Index2>
-__simd_merge(_Index1 __x, _Index1 __x_e, _Index2 __y, _Index2 __y_e, _Index3 __i, _Index3 __j,
-             _A&& __a, _B&& __b, _C&& __c)
+template<typename _Iterator1, typename _Iterator2, typename _Iterator3, typename _Comp>
+std::pair<_Iterator1, _Iterator2>
+__simd_merge(_Iterator1 __x, _Iterator1 __x_e, _Iterator2 __y, _Iterator2 __y_e, _Iterator3 __i, _Iterator3 __j, _Comp __comp)
 {
     _ONEDPL_PRAGMA_SIMD
-    for(_Index3 __k = __i; __k < __j; ++__k)
+    for(_Iterator3 __k = __i; __k < __j; ++__k)
     {
         if(__x >= __x_e)
         {
             assert(__y < __y_e);
-            __c[__k] = __b[__y];
+            *__k = *__y;
             ++__y;
         }
         else if(__y >= __y_e)
         {
             assert(__x < __x_e);
-            __c[__k] = __a[__x];
+            *__k = *__x;
             ++__x;
         }
-        else if(__a[__x] < __b[__y])
+        else if(std::invoke(__comp, *__x, *__y))
         {
-            __c[__k] = __a[__x];
+            *__k = *__x;
             ++__x;
         }
         else
         {
-            __c[__k] = __b[__y];
+            *__k = *__y;
             ++__y;
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -880,34 +880,33 @@ __simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredi`
`880`	`880`	`return __current + __cnt;`
`881`	`881`	`}`
`882`	`882`
`883`		`-template<typename _Index1, typename _Index2, typename _Index3, typename _A, typename _B, typename _C>`
`884`		`-std::pair<_Index1, _Index2>`
`885`		`-__simd_merge(_Index1 __x, _Index1 __x_e, _Index2 __y, _Index2 __y_e, _Index3 __i, _Index3 __j,`
`886`		`- _A&& __a, _B&& __b, _C&& __c)`
	`883`	`+template<typename _Iterator1, typename _Iterator2, typename _Iterator3, typename _Comp>`
	`884`	`+std::pair<_Iterator1, _Iterator2>`
	`885`	`+__simd_merge(_Iterator1 __x, _Iterator1 __x_e, _Iterator2 __y, _Iterator2 __y_e, _Iterator3 __i, _Iterator3 __j, _Comp __comp)`
`887`	`886`	`{`
`888`	`887`	`_ONEDPL_PRAGMA_SIMD`
`889`		`- for(_Index3 __k = __i; __k < __j; ++__k)`
	`888`	`+ for(_Iterator3 __k = __i; __k < __j; ++__k)`
`890`	`889`	`{`
`891`	`890`	`if(__x >= __x_e)`
`892`	`891`	`{`
`893`	`892`	`assert(__y < __y_e);`
`894`		`- __c[__k] = __b[__y];`
	`893`	`+ __k = __y;`
`895`	`894`	`++__y;`
`896`	`895`	`}`
`897`	`896`	`else if(__y >= __y_e)`
`898`	`897`	`{`
`899`	`898`	`assert(__x < __x_e);`
`900`		`- __c[__k] = __a[__x];`
	`899`	`+ __k = __x;`
`901`	`900`	`++__x;`
`902`	`901`	`}`
`903`		`- else if(__a[__x] < __b[__y])`
	`902`	`+ else if(std::invoke(__comp, __x, __y))`
`904`	`903`	`{`
`905`		`- __c[__k] = __a[__x];`
	`904`	`+ __k = __x;`
`906`	`905`	`++__x;`
`907`	`906`	`}`
`908`	`907`	`else`
`909`	`908`	`{`
`910`		`- __c[__k] = __b[__y];`
	`909`	`+ __k = __y;`
`911`	`910`	`++__y;`
`912`	`911`	`}`
`913`	`912`	`}`