<execution>: parallel scans should avoid passing output values to the binary (reduce) operation (#4701)

Andor233 · StephanTLavavej · CaseyCarter · web-flow · commit 041f5846eaa9 · 2024-08-15T10:31:39.000-07:00
Co-authored-by: Stephan T. Lavavej &lt;stl@nuwen.net&gt;
Co-authored-by: Casey Carter &lt;cacarter@microsoft.com&gt;
diff --git a/stl/inc/execution b/stl/inc/execution
diff --git a/stl/inc/vector b/stl/inc/vector
@@ -788,7 +788,7 @@ private:
         if constexpr (conjunction_v<is_nothrow_constructible<_Ty, _Valty...>,
                           _Uses_default_construct<_Alloc, _Ty*, _Valty...>>) {
             _ASAN_VECTOR_MODIFY(1);
-            _Construct_in_place(*_Mylast, _STD forward<_Valty>(_Val)...);
+            _STD _Construct_in_place(*_Mylast, _STD forward<_Valty>(_Val)...);
         } else {
             _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Mylast - _My_data._Myfirst) + 1);
             _Alty_traits::construct(_Getal(), _Unfancy(_Mylast), _STD forward<_Valty>(_Val)...);
@@ -822,27 +822,27 @@ private:
         const size_type _Newsize = _Oldsize + 1;
         size_type _Newcapacity   = _Calculate_growth(_Newsize);
 
-        const pointer _Newvec           = _Allocate_at_least_helper(_Al, _Newcapacity);
+        const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
         const pointer _Constructed_last = _Newvec + _Whereoff + 1;
         pointer _Constructed_first      = _Constructed_last;
 
         _TRY_BEGIN
-        _Alty_traits::construct(_Al, _Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
+        _Alty_traits::construct(_Al, _STD _Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
         _Constructed_first = _Newvec + _Whereoff;
 
         if (_Whereptr == _Mylast) { // at back, provide strong guarantee
             if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
-                _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+                _STD _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
             } else {
-                _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+                _STD _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
             }
         } else { // provide basic guarantee
-            _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
+            _STD _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
             _Constructed_first = _Newvec;
-            _Uninitialized_move(_Whereptr, _Mylast, _Newvec + _Whereoff + 1, _Al);
+            _STD _Uninitialized_move(_Whereptr, _Mylast, _Newvec + _Whereoff + 1, _Al);
         }
         _CATCH_ALL
-        _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+        _STD _Destroy_range(_Constructed_first, _Constructed_last, _Al);
         _Al.deallocate(_Newvec, _Newcapacity);
         _RERAISE;
         _CATCH_END
@@ -2024,7 +2024,7 @@ private:
         _My_data._Orphan_all();
 
         if (_Myfirst) { // destroy and deallocate old array
-            _Destroy_range(_Myfirst, _Mylast, _Al);
+            _STD _Destroy_range(_Myfirst, _Mylast, _Al);
             _ASAN_VECTOR_REMOVE;
             _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
         }
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
@@ -1905,15 +1905,15 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_move(
     // move [_First, _Last) to raw _Dest, using _Al
     // note: only called internally from elsewhere in the STL
     using _Ptrval     = typename _Alloc::value_type*;
-    auto _UFirst      = _Get_unwrapped(_First);
-    const auto _ULast = _Get_unwrapped(_Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
     if constexpr (conjunction_v<bool_constant<_Iter_move_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
                       _Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {
 #if _HAS_CXX20
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
+            _STD _Copy_memmove(_UFirst, _ULast, _STD _Unfancy(_Dest));
             return _Dest + (_ULast - _UFirst);
         }
     }
diff --git a/tests/std/tests/P0024R2_parallel_algorithms_exclusive_scan/test.cpp b/tests/std/tests/P0024R2_parallel_algorithms_exclusive_scan/test.cpp
@@ -184,11 +184,6 @@ struct typesBop {
     bopResult operator()(intermediateType&&, intermediateType&&) {
         return 0;
     }
-
-    // *result = binary_op(tmp, move(*result))
-    bopResult operator()(intermediateType&, outputType&&) {
-        return 0;
-    }
 };
 
 void test_case_exclusive_scan_init_writes_intermediate_type() {
diff --git a/tests/std/tests/P0024R2_parallel_algorithms_inclusive_scan/test.cpp b/tests/std/tests/P0024R2_parallel_algorithms_inclusive_scan/test.cpp
@@ -193,11 +193,6 @@ struct typesBop {
     bopResult operator()(intermediateType&&, intermediateType&&) {
         return 0;
     }
-
-    // *result = binary_op(tmp, move(*result))
-    bopResult operator()(intermediateType&, outputType&&) {
-        return 0;
-    }
 };
 
 void test_case_inclusive_scan_init_writes_intermediate_type() {
diff --git a/tests/std/tests/P0024R2_parallel_algorithms_transform_exclusive_scan/test.cpp b/tests/std/tests/P0024R2_parallel_algorithms_transform_exclusive_scan/test.cpp
@@ -179,11 +179,6 @@ struct typesBop {
     bopResult operator()(intermediateType&&, intermediateType&&) {
         return 0;
     }
-
-    // *result = binary_op(tmp, move(*result))
-    bopResult operator()(intermediateType&, outputType&&) {
-        return 0;
-    }
 };
 
 void test_case_transform_exclusive_scan_init_writes_intermediate_type() {
diff --git a/tests/std/tests/P0024R2_parallel_algorithms_transform_inclusive_scan/test.cpp b/tests/std/tests/P0024R2_parallel_algorithms_transform_inclusive_scan/test.cpp
@@ -203,11 +203,6 @@ struct typesBop {
     bopResult operator()(intermediateType&&, intermediateType&&) {
         return 0;
     }
-
-    // *result = binary_op(tmp, move(*result))
-    bopResult operator()(intermediateType&, outputType&&) {
-        return 0;
-    }
 };
 
 void test_case_transform_inclusive_scan_init_writes_intermediate_type() {

Original file line number	Diff line number	Diff line change
`@@ -1905,15 +1905,15 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_move(`
`1905`	`1905`	`// move [_First, _Last) to raw _Dest, using _Al`
`1906`	`1906`	`// note: only called internally from elsewhere in the STL`
`1907`	`1907`	`using _Ptrval = typename _Alloc::value_type*;`
`1908`		`- auto _UFirst = _Get_unwrapped(_First);`
`1909`		`- const auto _ULast = _Get_unwrapped(_Last);`
	`1908`	`+ auto _UFirst = _STD _Get_unwrapped(_First);`
	`1909`	`+ const auto _ULast = _STD _Get_unwrapped(_Last);`
`1910`	`1910`	`if constexpr (conjunction_v<bool_constant<_Iter_move_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,`
`1911`	`1911`	`_Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {`
`1912`	`1912`	`#if _HAS_CXX20`
`1913`	`1913`	`if (!_STD is_constant_evaluated())`
`1914`	`1914`	`#endif // _HAS_CXX20`
`1915`	`1915`	`{`
`1916`		`- _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));`
	`1916`	`+ _STD _Copy_memmove(_UFirst, _ULast, _STD _Unfancy(_Dest));`
`1917`	`1917`	`return _Dest + (_ULast - _UFirst);`
`1918`	`1918`	`}`
`1919`	`1919`	`}`