[libcxx-commits] [libcxx] [[libc++][pstl] Implementation of parallel std::uninitialized_(copy|move)(_n) based on parallel __for_each (PR #223229)
Michael G. Kazakov via libcxx-commits
libcxx-commits at lists.llvm.org
Sun Sep 13 04:41:24 PDT 2026
https://github.com/mikekazakov updated https://github.com/llvm/llvm-project/pull/223229
>From e7db02892763bcc883430557d6bbe2a58bca0b85 Mon Sep 17 00:00:00 2001
From: Michael Kazakov <mike.kazakov at gmail.com>
Date: Sun, 13 Sep 2026 11:55:18 +0100
Subject: [PATCH 1/2] Implementation of parallel uninitialized_(copy|move)(_n)
---
libcxx/include/CMakeLists.txt | 1 +
libcxx/include/__memory/pstl.h | 60 +++++++
libcxx/include/__pstl/backend_fwd.h | 28 ++++
libcxx/include/__pstl/backends/default.h | 52 ++++++
libcxx/include/__pstl/backends/libdispatch.h | 9 ++
libcxx/include/__pstl/backends/serial.h | 19 +++
libcxx/include/__pstl/backends/std_thread.h | 9 ++
libcxx/include/__pstl/cpu_algos/for_each.h | 18 +++
.../cpu_algos/uninitialized_algorithms.h | 97 +++++++++++
libcxx/include/module.modulemap.in | 3 +
.../pstl.iterator-requirements.verify.cpp | 21 ++-
.../pstl.exception_handling.pass.cpp | 22 +++
.../pstl.uninitialized_copy.pass.cpp | 145 +++++++++++++++++
.../pstl.uninitialized_copy_n.pass.cpp | 146 +++++++++++++++++
.../pstl.uninitialized_move.pass.cpp | 150 +++++++++++++++++
.../pstl.uninitialized_move_n.pass.cpp | 153 ++++++++++++++++++
16 files changed, 932 insertions(+), 1 deletion(-)
create mode 100644 libcxx/include/__pstl/cpu_algos/uninitialized_algorithms.h
create mode 100644 libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy.pass.cpp
create mode 100644 libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy_n.pass.cpp
create mode 100644 libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move.pass.cpp
create mode 100644 libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move_n.pass.cpp
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 113d4fde7ca59..2ec3881db7774 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -711,6 +711,7 @@ set(files
__pstl/cpu_algos/stable_sort.h
__pstl/cpu_algos/transform.h
__pstl/cpu_algos/transform_reduce.h
+ __pstl/cpu_algos/uninitialized_algorithms.h
__pstl/dispatch.h
__pstl/handle_exception.h
__random/bernoulli_distribution.h
diff --git a/libcxx/include/__memory/pstl.h b/libcxx/include/__memory/pstl.h
index c06f53bed7206..2b4011bd158cb 100644
--- a/libcxx/include/__memory/pstl.h
+++ b/libcxx/include/__memory/pstl.h
@@ -82,6 +82,36 @@ uninitialized_default_construct_n(_ExecutionPolicy&& __policy, _ForwardIterator
__pstl::__handle_exception<_Implementation>(std::forward<_ExecutionPolicy>(__policy), std::move(__first), __n);
}
+template <class _ExecutionPolicy,
+ class _InputIterator,
+ class _ForwardIterator,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_copy(
+ _ExecutionPolicy&& __policy, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) {
+ _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(_InputIterator, "uninitialized_copy requires InputIterators");
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "uninitialized_copy requires ForwardIterators");
+ using _Implementation = __pstl::__dispatch<__pstl::__uninitialized_copy, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+ class _InputIterator,
+ class _Size,
+ class _ForwardIterator,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+uninitialized_copy_n(_ExecutionPolicy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) {
+ _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(_InputIterator, "uninitialized_copy_n requires InputIterators");
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "uninitialized_copy_n requires ForwardIterators");
+ using _Implementation =
+ __pstl::__dispatch<__pstl::__uninitialized_copy_n, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy), std::move(__first), __n, std::move(__result));
+}
+
template <class _ExecutionPolicy,
class _ForwardIterator,
class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
@@ -136,6 +166,36 @@ uninitialized_fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Siz
std::forward<_ExecutionPolicy>(__policy), std::move(__first), __n, __value);
}
+template <class _ExecutionPolicy,
+ class _InputIterator,
+ class _ForwardIterator,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_move(
+ _ExecutionPolicy&& __policy, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) {
+ _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(_InputIterator, "uninitialized_move requires InputIterators");
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "uninitialized_move requires ForwardIterators");
+ using _Implementation = __pstl::__dispatch<__pstl::__uninitialized_move, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+ class _InputIterator,
+ class _Size,
+ class _ForwardIterator,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+uninitialized_move_n(_ExecutionPolicy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) {
+ _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(_InputIterator, "uninitialized_move_n requires InputIterators");
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "uninitialized_move_n requires ForwardIterators");
+ using _Implementation =
+ __pstl::__dispatch<__pstl::__uninitialized_move_n, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy), std::move(__first), __n, std::move(__result));
+}
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
diff --git a/libcxx/include/__pstl/backend_fwd.h b/libcxx/include/__pstl/backend_fwd.h
index 40a335ae1f2ad..570afef8a8a34 100644
--- a/libcxx/include/__pstl/backend_fwd.h
+++ b/libcxx/include/__pstl/backend_fwd.h
@@ -430,6 +430,20 @@ struct __destroy_n;
// optional<__empty>
// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
+template <class _Backend, class _ExecutionPolicy>
+struct __uninitialized_copy;
+// template <class _Policy, class _InputIterator, class _ForwardIterator>
+// optional<_ForwardIterator>
+// operator()(_Policy&& __policy, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const
+// noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __uninitialized_copy_n;
+// template <class _Policy, class _InputIterator, class _Size, class _ForwardIterator>
+// optional<_ForwardIterator>
+// operator()(_Policy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) const
+// noexcept;
+
template <class _Backend, class _ExecutionPolicy>
struct __uninitialized_default_construct;
// template <class _Policy, class _ForwardIterator>
@@ -442,6 +456,20 @@ struct __uninitialized_default_construct_n;
// optional<__empty>
// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
+template <class _Backend, class _ExecutionPolicy>
+struct __uninitialized_move;
+// template <class _Policy, class _InputIterator, class _ForwardIterator>
+// optional<_ForwardIterator>
+// operator()(_Policy&& __policy, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const
+// noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __uninitialized_move_n;
+// template <class _Policy, class _InputIterator, class _Size, class _ForwardIterator>
+// optional<pair<_InputIterator, _ForwardIterator>>
+// operator()(_Policy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) const
+// noexcept;
+
template <class _Backend, class _ExecutionPolicy>
struct __uninitialized_value_construct;
// template <class _Policy, class _ForwardIterator>
diff --git a/libcxx/include/__pstl/backends/default.h b/libcxx/include/__pstl/backends/default.h
index b5d7045bbb9b8..dd67d5fcc84e4 100644
--- a/libcxx/include/__pstl/backends/default.h
+++ b/libcxx/include/__pstl/backends/default.h
@@ -29,6 +29,7 @@
#include <__iterator/reverse_iterator.h>
#include <__memory/addressof.h>
#include <__memory/construct_at.h>
+#include <__memory/uninitialized_algorithms.h>
#include <__optional/comparison.h>
#include <__optional/nullopt_t.h>
#include <__optional/optional.h>
@@ -151,6 +152,14 @@ namespace __pstl {
// - reverse_copy
// - rotate_copy
//
+// uninitialized_copy family
+// -------------------------------------
+// - uninitialized_copy_n
+//
+// uninitialized_move family
+// -------------------------------------
+// - uninitialized_move_n
+//
//////////////////////////////////////////////////////////////
// find_if family
@@ -906,6 +915,49 @@ struct __adjacent_difference<__default_backend_tag, _ExecutionPolicy> {
}
};
+//////////////////////////////////////////////////////////////
+// uninitialized_copy family
+//////////////////////////////////////////////////////////////
+
+template <class _ExecutionPolicy>
+struct __uninitialized_copy_n<__default_backend_tag, _ExecutionPolicy> {
+ template <class _Policy, class _InputIterator, class _Size, class _ForwardIterator>
+ optional<_ForwardIterator>
+ operator()(_Policy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) const noexcept {
+ if constexpr (__has_random_access_iterator_category_or_concept<_InputIterator>::value &&
+ __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+ using _UninitializedCopy = __dispatch<__uninitialized_copy, __current_configuration, _ExecutionPolicy>;
+ _InputIterator __last = __first + __n;
+ return _UninitializedCopy()(__policy, std::move(__first), std::move(__last), std::move(__result));
+ } else {
+ return std::uninitialized_copy_n(std::move(__first), __n, std::move(__result));
+ }
+ }
+};
+
+//////////////////////////////////////////////////////////////
+// uninitialized_move family
+//////////////////////////////////////////////////////////////
+
+template <class _ExecutionPolicy>
+struct __uninitialized_move_n<__default_backend_tag, _ExecutionPolicy> {
+ template <class _Policy, class _InputIterator, class _Size, class _ForwardIterator>
+ optional<pair<_InputIterator, _ForwardIterator>>
+ operator()(_Policy&& __policy, _InputIterator __first, _Size __n, _ForwardIterator __result) const noexcept {
+ if constexpr (__has_random_access_iterator_category_or_concept<_InputIterator>::value &&
+ __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+ using _UninitializedMove = __dispatch<__uninitialized_move, __current_configuration, _ExecutionPolicy>;
+ _InputIterator __last = __first + __n;
+ auto __res = _UninitializedMove()(__policy, std::move(__first), __last, std::move(__result));
+ if (!__res)
+ return nullopt; // Failed to run the parallel algorithm, propagate the failure
+ return pair{__last, *__res};
+ } else {
+ return std::uninitialized_move_n(std::move(__first), __n, std::move(__result));
+ }
+ }
+};
+
} // namespace __pstl
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__pstl/backends/libdispatch.h b/libcxx/include/__pstl/backends/libdispatch.h
index dbd9fa34e1f87..5b245373eb16b 100644
--- a/libcxx/include/__pstl/backends/libdispatch.h
+++ b/libcxx/include/__pstl/backends/libdispatch.h
@@ -51,6 +51,7 @@
#include <__pstl/cpu_algos/stable_sort.h>
#include <__pstl/cpu_algos/transform.h>
#include <__pstl/cpu_algos/transform_reduce.h>
+#include <__pstl/cpu_algos/uninitialized_algorithms.h>
#include <__utility/empty.h>
#include <__utility/exception_guard.h>
#include <__utility/move.h>
@@ -439,6 +440,14 @@ template <class _ExecutionPolicy>
struct __fill<__libdispatch_backend_tag, _ExecutionPolicy>
: __cpu_parallel_fill<__libdispatch_backend_tag, _ExecutionPolicy> {};
+template <class _ExecutionPolicy>
+struct __uninitialized_copy<__libdispatch_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_uninitialized_copy<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __uninitialized_move<__libdispatch_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_uninitialized_move<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
} // namespace __pstl
_LIBCPP_END_EXPLICIT_ABI_ANNOTATIONS
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__pstl/backends/serial.h b/libcxx/include/__pstl/backends/serial.h
index 85c73b0f15db5..c779d583089d2 100644
--- a/libcxx/include/__pstl/backends/serial.h
+++ b/libcxx/include/__pstl/backends/serial.h
@@ -24,6 +24,7 @@
#include <__algorithm/stable_sort.h>
#include <__algorithm/transform.h>
#include <__config>
+#include <__memory/uninitialized_algorithms.h>
#include <__numeric/transform_reduce.h>
#include <__optional/optional.h>
#include <__pstl/backend_fwd.h>
@@ -284,6 +285,24 @@ struct __transform_reduce_binary<__serial_backend_tag, _ExecutionPolicy> {
}
};
+template <class _ExecutionPolicy>
+struct __uninitialized_copy<__serial_backend_tag, _ExecutionPolicy> {
+ template <class _Policy, class _InputIterator, class _ForwardIterator>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const noexcept {
+ return std::uninitialized_copy(std::move(__first), std::move(__last), std::move(__result));
+ }
+};
+
+template <class _ExecutionPolicy>
+struct __uninitialized_move<__serial_backend_tag, _ExecutionPolicy> {
+ template <class _Policy, class _InputIterator, class _ForwardIterator>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const noexcept {
+ return std::uninitialized_move(std::move(__first), std::move(__last), std::move(__result));
+ }
+};
+
} // namespace __pstl
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__pstl/backends/std_thread.h b/libcxx/include/__pstl/backends/std_thread.h
index bc7fc020867f8..bdbddb9d36300 100644
--- a/libcxx/include/__pstl/backends/std_thread.h
+++ b/libcxx/include/__pstl/backends/std_thread.h
@@ -30,6 +30,7 @@
#include <__pstl/cpu_algos/stable_sort.h>
#include <__pstl/cpu_algos/transform.h>
#include <__pstl/cpu_algos/transform_reduce.h>
+#include <__pstl/cpu_algos/uninitialized_algorithms.h>
#include <__utility/empty.h>
#include <__utility/move.h>
@@ -170,6 +171,14 @@ template <class _ExecutionPolicy>
struct __fill<__std_thread_backend_tag, _ExecutionPolicy>
: __cpu_parallel_fill<__std_thread_backend_tag, _ExecutionPolicy> {};
+template <class _ExecutionPolicy>
+struct __uninitialized_copy<__std_thread_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_uninitialized_copy<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __uninitialized_move<__std_thread_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_uninitialized_move<__std_thread_backend_tag, _ExecutionPolicy> {};
+
} // namespace __pstl
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__pstl/cpu_algos/for_each.h b/libcxx/include/__pstl/cpu_algos/for_each.h
index 908f82f01e6c8..bc29fa4e3da44 100644
--- a/libcxx/include/__pstl/cpu_algos/for_each.h
+++ b/libcxx/include/__pstl/cpu_algos/for_each.h
@@ -37,6 +37,24 @@ _LIBCPP_HIDE_FROM_ABI _Iterator __simd_for_each(_Iterator __first, _DifferenceTy
return __first + __n;
}
+// Applies the 3-legged function to sub-ranges of the input ranges in parallel:
+// f(sub_range1_first, sub_range1_last, sub_range2_first)
+template <class _Backend, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BrickFunction>
+_LIBCPP_HIDE_FROM_ABI optional<__empty> __parallel_for_each_iter_pair(
+ _RandomAccessIterator1 __first1,
+ _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2,
+ _BrickFunction __f) {
+ return __cpu_traits<_Backend>::__for_each(
+ __first1,
+ __last1,
+ [__first1, __first2, __f = std::move(__f)](
+ _RandomAccessIterator1 __brick_first1, _RandomAccessIterator1 __brick_last1) {
+ _RandomAccessIterator2 __brick_first2 = __first2 + (__brick_first1 - __first1);
+ __f(__brick_first1, __brick_last1, __brick_first2);
+ });
+}
+
template <class _Backend, class _RawExecutionPolicy>
struct __cpu_parallel_for_each {
template <class _Policy, class _ForwardIterator, class _Function>
diff --git a/libcxx/include/__pstl/cpu_algos/uninitialized_algorithms.h b/libcxx/include/__pstl/cpu_algos/uninitialized_algorithms.h
new file mode 100644
index 0000000000000..41ee8bc3b7a53
--- /dev/null
+++ b/libcxx/include/__pstl/cpu_algos/uninitialized_algorithms.h
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_UNINITIALIZED_ALGORITHMS_H
+#define _LIBCPP___PSTL_CPU_ALGOS_UNINITIALIZED_ALGORITHMS_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/uninitialized_algorithms.h>
+#include <__optional/nullopt_t.h>
+#include <__optional/optional.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__pstl/cpu_algos/for_each.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __pstl {
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_uninitialized_copy {
+ template <class _Policy, class _InputIterator, class _ForwardIterator>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const noexcept {
+ if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+ __has_random_access_iterator_category_or_concept<_InputIterator>::value &&
+ __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+ auto __res = __parallel_for_each_iter_pair<_Backend>(
+ __first,
+ __last,
+ __result,
+ [](_InputIterator __brick_first, _InputIterator __brick_last, _ForwardIterator __brick_result) {
+ std::uninitialized_copy(std::move(__brick_first), std::move(__brick_last), std::move(__brick_result));
+ });
+ if (!__res) {
+ return std::nullopt; // Failed to run the algorithm, propagate the error.
+ }
+ return __result + (__last - __first);
+ } else {
+ // Non-random access iterators cannot be processed in parallel, fall back to the sequential implementation.
+ return std::uninitialized_copy(std::move(__first), std::move(__last), std::move(__result));
+ }
+ }
+};
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_uninitialized_move {
+ template <class _Policy, class _InputIterator, class _ForwardIterator>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) const noexcept {
+ if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+ __has_random_access_iterator_category_or_concept<_InputIterator>::value &&
+ __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+ auto __res = __parallel_for_each_iter_pair<_Backend>(
+ __first,
+ __last,
+ __result,
+ [](_InputIterator __brick_first, _InputIterator __brick_last, _ForwardIterator __brick_result) {
+ std::uninitialized_move(std::move(__brick_first), std::move(__brick_last), std::move(__brick_result));
+ });
+ if (!__res) {
+ return std::nullopt; // Failed to run the algorithm, propagate the error.
+ }
+ return __result + (__last - __first);
+ } else {
+ // Non-random access iterators cannot be processed in parallel, fall back to the sequential implementation.
+ return std::uninitialized_move(std::move(__first), std::move(__last), std::move(__result));
+ }
+ }
+};
+
+} // namespace __pstl
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_UNINITIALIZED_ALGORITHMS_H
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index d22a9ce36d02c..ccd011a3c00e5 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -2474,6 +2474,9 @@ module std {
module transform_reduce {
header "__pstl/cpu_algos/transform_reduce.h"
}
+ module uninitialized_algorithms {
+ header "__pstl/cpu_algos/uninitialized_algorithms.h"
+ }
}
module dispatch { header "__pstl/dispatch.h" }
module handle_exception { header "__pstl/handle_exception.h" }
diff --git a/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp b/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
index f12d5bdcb3121..bbc669bfdc554 100644
--- a/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
+++ b/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
@@ -32,6 +32,7 @@
#include "test_iterators.h"
+using non_input_iterator = cpp17_output_iterator<int*>;
using non_forward_iterator = cpp17_input_iterator<int*>;
using non_bidirectional_iterator = forward_iterator<int*>;
using non_randomaccess_iterator = bidirectional_iterator<int*>;
@@ -39,7 +40,8 @@ struct non_output_iterator : forward_iterator<int*> {
constexpr int const& operator*() const; // prevent it from being an output iterator
};
-void f(non_forward_iterator non_fwd,
+void f(non_input_iterator non_input,
+ non_forward_iterator non_fwd,
non_output_iterator non_output,
non_bidirectional_iterator non_bidir,
non_randomaccess_iterator non_random,
@@ -338,4 +340,21 @@ void f(non_forward_iterator non_fwd,
std::uninitialized_fill_n(
pol, non_fwd, n, val); // expected-error@*:* {{static assertion failed: uninitialized_fill_n}}
}
+
+ {
+ std::uninitialized_copy(
+ pol, non_input, non_input, it); // expected-error@*:* {{static assertion failed: uninitialized_copy}}
+ std::uninitialized_copy(pol, it, it, non_fwd); // expected-error@*:* {{static assertion failed: uninitialized_copy}}
+ std::uninitialized_copy_n(
+ pol, non_input, n, it); // expected-error@*:* {{static assertion failed: uninitialized_copy_n}}
+ std::uninitialized_copy_n(
+ pol, it, n, non_fwd); // expected-error@*:* {{static assertion failed: uninitialized_copy_n}}
+ std::uninitialized_move(
+ pol, non_input, non_input, it); // expected-error@*:* {{static assertion failed: uninitialized_move}}
+ std::uninitialized_move(pol, it, it, non_fwd); // expected-error@*:* {{static assertion failed: uninitialized_move}}
+ std::uninitialized_move_n(
+ pol, non_input, n, it); // expected-error@*:* {{static assertion failed: uninitialized_move_n}}
+ std::uninitialized_move_n(
+ pol, it, n, non_fwd); // expected-error@*:* {{static assertion failed: uninitialized_move_n}}
+ }
}
diff --git a/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp b/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
index b85cc984d969d..f6aeaf68eb96b 100644
--- a/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
+++ b/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
@@ -566,6 +566,28 @@ int main(int, char**) {
// uninitialized_fill_n(first, n, val)
assert_non_throwing([=, &policy] { std::uninitialized_fill_n(policy, std::move(first1), n, val); });
}
+
+ {
+ // uninitialized_copy(first, last, dest)
+ assert_non_throwing([=, &policy] {
+ (void)std::uninitialized_copy(policy, std::move(first1), std::move(last1), std::move(dest));
+ });
+
+ // uninitialized_copy_n(first, n, dest)
+ assert_non_throwing([=, &policy] {
+ (void)std::uninitialized_copy_n(policy, std::move(first1), n, std::move(dest));
+ });
+
+ // uninitialized_move(first, last, dest)
+ assert_non_throwing([=, &policy] {
+ (void)std::uninitialized_move(policy, std::move(first1), std::move(last1), std::move(dest));
+ });
+
+ // uninitialized_move_n(first, n, dest)
+ assert_non_throwing([=, &policy] {
+ (void)std::uninitialized_move_n(policy, std::move(first1), n, std::move(dest));
+ });
+ }
}
});
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy.pass.cpp
new file mode 100644
index 0000000000000..d2f8c4cd66a47
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy.pass.cpp
@@ -0,0 +1,145 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++17
+
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
+
+// <memory>
+
+// template <class ExecutionPolicy,
+// class InputIterator,
+// class ForwardIterator>
+// ForwardIterator uninitialized_copy(ExecutionPolicy&& exec,
+// InputIterator first, InputIterator last,
+// ForwardIterator result);
+
+#include <atomic>
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <numeric>
+
+#include "test_execution_policies.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "runway_sample.h"
+
+EXECUTION_POLICY_SFINAE_TEST(uninitialized_copy);
+
+static_assert(sfinae_test_uninitialized_copy<int, int*, int*, int*>);
+static_assert(!sfinae_test_uninitialized_copy<std::execution::parallel_policy, int*, int*, int*>);
+
+// Source type
+struct Src {
+ Src(int v) : value_(v) {}
+ Src(const Src&) = delete;
+ Src& operator=(const Src&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+// Destination type
+struct Dst {
+ Dst(const Src& x) : value_(x.value()) {} // Can only be constructed from Src
+ Dst(const Dst&) = delete;
+ ~Dst() { value_ = 0; };
+ Dst& operator=(const Dst&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+template <class Iter1, class Iter2>
+struct TestCustomTypes {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ constexpr size_t n = 1073;
+ std::allocator<Src> alloc_src;
+ std::allocator<Dst> alloc_dst;
+ Src* source = alloc_src.allocate(n);
+ Dst* dest = alloc_dst.allocate(n);
+
+ // Source is Src(1), Src(2), Src(3), ...
+ for (size_t i = 0; i < n; ++i) {
+ std::construct_at(source + i, static_cast<int>(i + 1));
+ }
+
+ // Copy-construct different ranges of Y [0..size) from the source X array
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_copy(policy, Iter1(source), Iter1(source + size), Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(dest[i].value() == source[i].value()); // Dest is Dst(1), Dst(2), Dst(3), ...
+ }
+
+ std::destroy_n(dest, size); // Clear dest for the next iteration
+ });
+
+ std::destroy_n(source, n);
+ alloc_src.deallocate(source, n);
+ alloc_dst.deallocate(dest, n);
+ }
+};
+
+template <class Iter1, class Iter2>
+struct TestInt {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ {
+ constexpr size_t n = 1073;
+ std::allocator<int> alloc;
+ int* source = alloc.allocate(n);
+ int* dest = alloc.allocate(n);
+
+ std::iota(source, source + n, 1); // Source is 1 2 3 4 ...
+ std::fill(dest, dest + n, 0); // Dest is 0 0 0 0 ...
+
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_copy(policy, Iter1(source), Iter1(source + size), Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(dest[i] == source[i]); // Dest is 1 2 3 4 ...
+ }
+
+ std::fill(dest, dest + size, 0); // Clear dest for the next iteration
+ });
+
+ alloc.deallocate(source, n);
+ alloc.deallocate(dest, n);
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(
+ types::cpp17_input_iterator_list<const Src*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<Dst*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestCustomTypes, Iter>::template apply>{});
+ }});
+ types::for_each(types::cpp17_input_iterator_list<const int*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<int*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestInt, Iter>::template apply>{});
+ }});
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy_n.pass.cpp
new file mode 100644
index 0000000000000..4a373fc1924fd
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/pstl.uninitialized_copy_n.pass.cpp
@@ -0,0 +1,146 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++17
+
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
+
+// <memory>
+
+// template <class ExecutionPolicy,
+// class InputIterator,
+// class Size,
+// class ForwardIterator>
+// ForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec,
+// InputIterator first, Size n,
+// ForwardIterator result);
+
+#include <atomic>
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <numeric>
+
+#include "test_execution_policies.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "runway_sample.h"
+
+EXECUTION_POLICY_SFINAE_TEST(uninitialized_copy_n);
+
+static_assert(sfinae_test_uninitialized_copy_n<int, int*, int, int*>);
+static_assert(!sfinae_test_uninitialized_copy_n<std::execution::parallel_policy, int*, int, int*>);
+
+// Source type
+struct Src {
+ Src(int v) : value_(v) {}
+ Src(const Src&) = delete;
+ Src& operator=(const Src&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+// Destination type
+struct Dst {
+ Dst(const Src& x) : value_(x.value()) {} // Can only be constructed from Src
+ Dst(const Dst&) = delete;
+ ~Dst() { value_ = 0; };
+ Dst& operator=(const Dst&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+template <class Iter1, class Iter2>
+struct TestCustomTypes {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ constexpr size_t n = 1073;
+ std::allocator<Src> alloc_src;
+ std::allocator<Dst> alloc_dst;
+ Src* source = alloc_src.allocate(n);
+ Dst* dest = alloc_dst.allocate(n);
+
+ // Source is Src(1), Src(2), Src(3), ...
+ for (size_t i = 0; i < n; ++i) {
+ std::construct_at(source + i, static_cast<int>(i + 1));
+ }
+
+ // Copy-construct different ranges of Y [0..size) from the source X array
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_copy_n(policy, Iter1(source), size, Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(dest[i].value() == source[i].value()); // Dest is Dst(1), Dst(2), Dst(3), ...
+ }
+
+ std::destroy_n(dest, size); // Clear dest for the next iteration
+ });
+
+ std::destroy_n(source, n);
+ alloc_src.deallocate(source, n);
+ alloc_dst.deallocate(dest, n);
+ }
+};
+
+template <class Iter1, class Iter2>
+struct TestInt {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ {
+ constexpr size_t n = 1073;
+ std::allocator<int> alloc;
+ int* source = alloc.allocate(n);
+ int* dest = alloc.allocate(n);
+
+ std::iota(source, source + n, 1); // Source is 1 2 3 4 ...
+ std::fill(dest, dest + n, 0); // Dest is 0 0 0 0 ...
+
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_copy_n(policy, Iter1(source), size, Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(dest[i] == source[i]); // Dest is 1 2 3 4 ...
+ }
+
+ std::fill(dest, dest + size, 0); // Clear dest for the next iteration
+ });
+
+ alloc.deallocate(source, n);
+ alloc.deallocate(dest, n);
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(
+ types::cpp17_input_iterator_list<const Src*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<Dst*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestCustomTypes, Iter>::template apply>{});
+ }});
+ types::for_each(types::cpp17_input_iterator_list<const int*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<int*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestInt, Iter>::template apply>{});
+ }});
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move.pass.cpp
new file mode 100644
index 0000000000000..f90f06654835f
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move.pass.cpp
@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++17
+
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
+
+// <memory>
+
+// template <class ExecutionPolicy,
+// class InputIterator,
+// class ForwardIterator>
+// ForwardIterator uninitialized_move(ExecutionPolicy&& exec,
+// InputIterator first, InputIterator last,
+// ForwardIterator result);
+
+#include <atomic>
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <numeric>
+
+#include "test_execution_policies.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "runway_sample.h"
+
+EXECUTION_POLICY_SFINAE_TEST(uninitialized_move);
+
+static_assert(sfinae_test_uninitialized_move<int, int*, int*, int*>);
+static_assert(!sfinae_test_uninitialized_move<std::execution::parallel_policy, int*, int*, int*>);
+
+// Source type
+struct Src {
+ Src(int v) : value_(v) {}
+ Src(const Src&) = delete;
+ Src& operator=(const Src&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+ friend struct Dst;
+};
+
+// Destination type
+struct Dst {
+ Dst(const Src&) { assert(0); }
+ Dst(Src&& x) : value_(x.value()) { x.value_ = 0; } // Destructive move-construct
+ Dst(const Dst&) = delete;
+ ~Dst() { value_ = 0; };
+ Dst& operator=(const Dst&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+template <class Iter1, class Iter2>
+struct TestCustomTypes {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ constexpr size_t n = 1073;
+ std::allocator<Src> alloc_src;
+ std::allocator<Dst> alloc_dst;
+ Src* source = alloc_src.allocate(n);
+ Dst* dest = alloc_dst.allocate(n);
+
+ // Move-construct different ranges of Y [0..size) from the source X array
+ runway_sample(n + 1, [&](size_t size) {
+ // Construct the source array for this iteration: X(1), X(2), X(3), ...
+ for (size_t i = 0; i < size; ++i) {
+ std::construct_at(source + i, static_cast<int>(i + 1));
+ }
+
+ auto ret = std::uninitialized_move(policy, Iter1(source), Iter1(source + size), Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(source[i].value() == 0); // Source is X(0), X(0), X(0), ...
+ assert(dest[i].value() == static_cast<int>(i + 1)); // Dest is Y(1), Y(2), Y(3), ...
+ }
+
+ std::destroy_n(source, size); // Clear source for the next iteration
+ std::destroy_n(dest, size); // Clear dest for the next iteration
+ });
+
+ alloc_src.deallocate(source, n);
+ alloc_dst.deallocate(dest, n);
+ }
+};
+
+template <class Iter1, class Iter2>
+struct TestInt {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ {
+ constexpr size_t n = 1073;
+ std::allocator<int> alloc;
+ int* source = alloc.allocate(n);
+ int* dest = alloc.allocate(n);
+
+ std::iota(source, source + n, 1); // Source is 1 2 3 4 ...
+ std::fill(dest, dest + n, 0); // Dest is 0 0 0 0 ...
+
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_move(policy, Iter1(source), Iter1(source + size), Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), Iter2);
+ assert(ret == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ // For trivial types, move is the same as copy
+ assert(dest[i] == static_cast<int>(i + 1));
+ assert(dest[i] == source[i]); // Both source and dest are 1 2 3 4 ...
+ }
+
+ std::fill(dest, dest + size, 0); // Clear dest for the next iteration
+ });
+
+ alloc.deallocate(source, n);
+ alloc.deallocate(dest, n);
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(
+ types::cpp17_input_iterator_list<Src*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<Dst*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestCustomTypes, Iter>::template apply>{});
+ }});
+ types::for_each(types::cpp17_input_iterator_list<int*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<int*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestInt, Iter>::template apply>{});
+ }});
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move_n.pass.cpp
new file mode 100644
index 0000000000000..df7eed353881c
--- /dev/null
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/pstl.uninitialized_move_n.pass.cpp
@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++17
+
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
+
+// <memory>
+
+// template <class ExecutionPolicy,
+// class InputIterator,
+// class Size,
+// class ForwardIterator>
+// ForwardIterator uninitialized_move_n(ExecutionPolicy&& exec,
+// InputIterator first, Size n,
+// ForwardIterator result);
+
+#include <atomic>
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <numeric>
+
+#include "test_execution_policies.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "runway_sample.h"
+
+EXECUTION_POLICY_SFINAE_TEST(uninitialized_move_n);
+
+static_assert(sfinae_test_uninitialized_move_n<int, int*, int, int*>);
+static_assert(!sfinae_test_uninitialized_move_n<std::execution::parallel_policy, int*, int, int*>);
+
+// Source type
+struct Src {
+ Src(int v) : value_(v) {}
+ Src(const Src&) = delete;
+ Src& operator=(const Src&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+ friend struct Dst;
+};
+
+// Destination type
+struct Dst {
+ Dst(const Src&) { assert(0); }
+ Dst(Src&& x) : value_(x.value()) { x.value_ = 0; } // Destructive move-construct
+ Dst(const Dst&) = delete;
+ ~Dst() { value_ = 0; };
+ Dst& operator=(const Dst&) = delete;
+ int value() const { return value_; }
+
+private:
+ int value_;
+};
+
+template <class Iter1, class Iter2>
+struct TestCustomTypes {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ constexpr size_t n = 1073;
+ std::allocator<Src> alloc_src;
+ std::allocator<Dst> alloc_dst;
+ Src* source = alloc_src.allocate(n);
+ Dst* dest = alloc_dst.allocate(n);
+
+ // Move-construct different ranges of Y [0..size) from the source X array
+ runway_sample(n + 1, [&](size_t size) {
+ // Construct the source array for this iteration: X(1), X(2), X(3), ...
+ for (size_t i = 0; i < size; ++i) {
+ std::construct_at(source + i, static_cast<int>(i + 1));
+ }
+
+ auto ret = std::uninitialized_move_n(policy, Iter1(source), size, Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), std::pair<Iter1, Iter2>);
+ assert(ret.first == Iter1(source + size));
+ assert(ret.second == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ assert(source[i].value() == 0); // Source is X(0), X(0), X(0), ...
+ assert(dest[i].value() == static_cast<int>(i + 1)); // Dest is Y(1), Y(2), Y(3), ...
+ }
+
+ std::destroy_n(source, size); // Clear source for the next iteration
+ std::destroy_n(dest, size); // Clear dest for the next iteration
+ });
+
+ alloc_src.deallocate(source, n);
+ alloc_dst.deallocate(dest, n);
+ }
+};
+
+template <class Iter1, class Iter2>
+struct TestInt {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ {
+ constexpr size_t n = 1073;
+ std::allocator<int> alloc;
+ int* source = alloc.allocate(n);
+ int* dest = alloc.allocate(n);
+
+ std::iota(source, source + n, 1); // Source is 1 2 3 4 ...
+ std::fill(dest, dest + n, 0); // Dest is 0 0 0 0 ...
+
+ runway_sample(n + 1, [&](size_t size) {
+ auto ret = std::uninitialized_move_n(policy, Iter1(source), size, Iter2(dest));
+ ASSERT_SAME_TYPE(decltype(ret), std::pair<Iter1, Iter2>);
+ assert(ret.first == Iter1(source + size));
+ assert(ret.second == Iter2(dest + size));
+
+ for (size_t i = 0; i < size; ++i) {
+ // For trivial types, move is the same as copy
+ assert(dest[i] == static_cast<int>(i + 1));
+ assert(dest[i] == source[i]); // Both source and dest are 1 2 3 4 ...
+ }
+
+ std::fill(dest, dest + size, 0); // Clear dest for the next iteration
+ });
+
+ alloc.deallocate(source, n);
+ alloc.deallocate(dest, n);
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(
+ types::cpp17_input_iterator_list<Src*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<Dst*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestCustomTypes, Iter>::template apply>{});
+ }});
+ types::for_each(types::cpp17_input_iterator_list<int*>{}, types::apply_type_identity{[](auto v) {
+ using Iter = typename decltype(v)::type;
+ types::for_each(
+ types::forward_iterator_list<int*>{},
+ TestIteratorWithPolicies<types::partial_instantiation<TestInt, Iter>::template apply>{});
+ }});
+ return 0;
+}
>From 2e9f4788985eb25a204cf0bb8a4de3781e1c46c0 Mon Sep 17 00:00:00 2001
From: Michael Kazakov <mike.kazakov at gmail.com>
Date: Sun, 13 Sep 2026 12:41:13 +0100
Subject: [PATCH 2/2] Missed includes
---
libcxx/include/__memory/pstl.h | 1 +
libcxx/include/__pstl/cpu_algos/for_each.h | 1 +
2 files changed, 2 insertions(+)
diff --git a/libcxx/include/__memory/pstl.h b/libcxx/include/__memory/pstl.h
index 2b4011bd158cb..6c1fd6f10ee23 100644
--- a/libcxx/include/__memory/pstl.h
+++ b/libcxx/include/__memory/pstl.h
@@ -30,6 +30,7 @@ _LIBCPP_PUSH_MACROS
# include <__type_traits/remove_cvref.h>
# include <__utility/forward.h>
# include <__utility/move.h>
+# include <__utility/pair.h>
_LIBCPP_BEGIN_NAMESPACE_STD
diff --git a/libcxx/include/__pstl/cpu_algos/for_each.h b/libcxx/include/__pstl/cpu_algos/for_each.h
index bc29fa4e3da44..91ec0dfdc59f3 100644
--- a/libcxx/include/__pstl/cpu_algos/for_each.h
+++ b/libcxx/include/__pstl/cpu_algos/for_each.h
@@ -18,6 +18,7 @@
#include <__pstl/cpu_algos/cpu_traits.h>
#include <__type_traits/is_execution_policy.h>
#include <__utility/empty.h>
+#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
More information about the libcxx-commits
mailing list