[libcxx-commits] [libcxx] c8027b4 - [libc++][pstl] Implementation of parallel std::search_n() based on __parallel_find() (#214069)
via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Aug 13 03:17:23 PDT 2026
Author: Michael G. Kazakov
Date: 2026-08-13T11:17:18+01:00
New Revision: c8027b4e95d509d2019a50186ecf8ec62535b765
URL: https://github.com/llvm/llvm-project/commit/c8027b4e95d509d2019a50186ecf8ec62535b765
DIFF: https://github.com/llvm/llvm-project/commit/c8027b4e95d509d2019a50186ecf8ec62535b765.diff
LOG: [libc++][pstl] Implementation of parallel std::search_n() based on __parallel_find() (#214069)
This PR implements a parallel version of `std::search_n()` based on
`__parallel_find()`.
The algorithm crops the input range to a range where a potential match
can start and runs a chunked parallel find on the cropped range.
Inside each chunk potential matches are looked for and the first one
found is returned.
Since it's based on `__parallel_find()`, the algorithm supports early
termination.
Added:
libcxx/include/__pstl/cpu_algos/search_n.h
libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n.pass.cpp
libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n_pred.pass.cpp
Modified:
libcxx/include/CMakeLists.txt
libcxx/include/__algorithm/pstl.h
libcxx/include/__pstl/backend_fwd.h
libcxx/include/__pstl/backends/default.h
libcxx/include/__pstl/backends/libdispatch.h
libcxx/include/__pstl/backends/serial.h
libcxx/include/__pstl/backends/std_thread.h
libcxx/include/module.modulemap.in
libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
libcxx/test/libcxx/algorithms/pstl.nodiscard.verify.cpp
libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
Removed:
################################################################################
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index a56613451a13d..9001afad89fb9 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -699,6 +699,7 @@ set(files
__pstl/cpu_algos/merge.h
__pstl/cpu_algos/mismatch.h
__pstl/cpu_algos/reverse.h
+ __pstl/cpu_algos/search_n.h
__pstl/cpu_algos/stable_sort.h
__pstl/cpu_algos/transform.h
__pstl/cpu_algos/transform_reduce.h
diff --git a/libcxx/include/__algorithm/pstl.h b/libcxx/include/__algorithm/pstl.h
index d27044ecdc8b9..9a9eb8905f2dd 100644
--- a/libcxx/include/__algorithm/pstl.h
+++ b/libcxx/include/__algorithm/pstl.h
@@ -792,6 +792,50 @@ _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy(
std::move(__result));
}
+template <class _ExecutionPolicy,
+ class _ForwardIterator,
+ class _Size,
+ class _Tp,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator search_n(
+ _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
+ using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy),
+ std::move(__first),
+ std::move(__last),
+ std::move(__count),
+ __value,
+ equal_to<>{});
+}
+
+template <class _ExecutionPolicy,
+ class _ForwardIterator,
+ class _Size,
+ class _Tp,
+ class _BinaryPredicate,
+ class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
+ enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator search_n(
+ _ExecutionPolicy&& __policy,
+ _ForwardIterator __first,
+ _ForwardIterator __last,
+ _Size __count,
+ const _Tp& __value,
+ _BinaryPredicate __pred) {
+ _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
+ using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
+ return __pstl::__handle_exception<_Implementation>(
+ std::forward<_ExecutionPolicy>(__policy),
+ std::move(__first),
+ std::move(__last),
+ std::move(__count),
+ __value,
+ std::move(__pred));
+}
+
template <class _ExecutionPolicy,
class _RandomAccessIterator,
class _Comp,
diff --git a/libcxx/include/__pstl/backend_fwd.h b/libcxx/include/__pstl/backend_fwd.h
index c5a219fb59db2..eb0c8123507d8 100644
--- a/libcxx/include/__pstl/backend_fwd.h
+++ b/libcxx/include/__pstl/backend_fwd.h
@@ -187,6 +187,13 @@ struct __merge;
// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
// _ForwardOutIterator __result, _Comp __comp) const noexcept;
+template <class _Backend, class _ExecutionPolicy>
+struct __search_n;
+// template <class _Policy, class _ForwardIterator, class _Size, class _T, class _Predicate>
+// optional<_ForwardIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+// _Size __count, const _T& __value, _Predicate __pred) const noexcept;
+
template <class _Backend, class _ExecutionPolicy>
struct __stable_sort;
// template <class _Policy, class _RandomAccessIterator, class _Comp>
diff --git a/libcxx/include/__pstl/backends/default.h b/libcxx/include/__pstl/backends/default.h
index 43bac357efd95..443fd5a35eb02 100644
--- a/libcxx/include/__pstl/backends/default.h
+++ b/libcxx/include/__pstl/backends/default.h
@@ -98,6 +98,10 @@ namespace __pstl {
// ------------
// No other algorithms based on reverse
//
+// search_n family
+// ------------------
+// No other algorithms based on search_n
+//
// stable_sort family
// ------------------
// - sort
diff --git a/libcxx/include/__pstl/backends/libdispatch.h b/libcxx/include/__pstl/backends/libdispatch.h
index ee698742152f3..11df83cd9fd7a 100644
--- a/libcxx/include/__pstl/backends/libdispatch.h
+++ b/libcxx/include/__pstl/backends/libdispatch.h
@@ -42,6 +42,7 @@
#include <__pstl/cpu_algos/merge.h>
#include <__pstl/cpu_algos/mismatch.h>
#include <__pstl/cpu_algos/reverse.h>
+#include <__pstl/cpu_algos/search_n.h>
#include <__pstl/cpu_algos/stable_sort.h>
#include <__pstl/cpu_algos/transform.h>
#include <__pstl/cpu_algos/transform_reduce.h>
@@ -380,6 +381,10 @@ template <class _ExecutionPolicy>
struct __reverse<__libdispatch_backend_tag, _ExecutionPolicy>
: __cpu_parallel_reverse<__libdispatch_backend_tag, _ExecutionPolicy> {};
+template <class _ExecutionPolicy>
+struct __search_n<__libdispatch_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_search_n<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
template <class _ExecutionPolicy>
struct __stable_sort<__libdispatch_backend_tag, _ExecutionPolicy>
: __cpu_parallel_stable_sort<__libdispatch_backend_tag, _ExecutionPolicy> {};
diff --git a/libcxx/include/__pstl/backends/serial.h b/libcxx/include/__pstl/backends/serial.h
index 13c515b356608..4294224268e44 100644
--- a/libcxx/include/__pstl/backends/serial.h
+++ b/libcxx/include/__pstl/backends/serial.h
@@ -15,6 +15,7 @@
#include <__algorithm/merge.h>
#include <__algorithm/mismatch.h>
#include <__algorithm/reverse.h>
+#include <__algorithm/search_n.h>
#include <__algorithm/stable_sort.h>
#include <__algorithm/transform.h>
#include <__config>
@@ -117,6 +118,20 @@ struct __reverse<__serial_backend_tag, _ExecutionPolicy> {
}
};
+template <class _ExecutionPolicy>
+struct __search_n<__serial_backend_tag, _ExecutionPolicy> {
+ template <class _Policy, class _ForwardIterator, class _Size, class _Tp, class _Predicate>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&,
+ _ForwardIterator __first,
+ _ForwardIterator __last,
+ _Size __count,
+ const _Tp& __value,
+ _Predicate __pred) const noexcept {
+ return std::search_n(std::move(__first), std::move(__last), __count, __value, std::move(__pred));
+ }
+};
+
template <class _ExecutionPolicy>
struct __stable_sort<__serial_backend_tag, _ExecutionPolicy> {
template <class _Policy, class _RandomAccessIterator, class _Comp>
diff --git a/libcxx/include/__pstl/backends/std_thread.h b/libcxx/include/__pstl/backends/std_thread.h
index d0b15c8ed1f00..850956a34d7c7 100644
--- a/libcxx/include/__pstl/backends/std_thread.h
+++ b/libcxx/include/__pstl/backends/std_thread.h
@@ -21,6 +21,7 @@
#include <__pstl/cpu_algos/merge.h>
#include <__pstl/cpu_algos/mismatch.h>
#include <__pstl/cpu_algos/reverse.h>
+#include <__pstl/cpu_algos/search_n.h>
#include <__pstl/cpu_algos/stable_sort.h>
#include <__pstl/cpu_algos/transform.h>
#include <__pstl/cpu_algos/transform_reduce.h>
@@ -111,6 +112,10 @@ template <class _ExecutionPolicy>
struct __reverse<__std_thread_backend_tag, _ExecutionPolicy>
: __cpu_parallel_reverse<__std_thread_backend_tag, _ExecutionPolicy> {};
+template <class _ExecutionPolicy>
+struct __search_n<__std_thread_backend_tag, _ExecutionPolicy>
+ : __cpu_parallel_search_n<__std_thread_backend_tag, _ExecutionPolicy> {};
+
template <class _ExecutionPolicy>
struct __stable_sort<__std_thread_backend_tag, _ExecutionPolicy>
: __cpu_parallel_stable_sort<__std_thread_backend_tag, _ExecutionPolicy> {};
diff --git a/libcxx/include/__pstl/cpu_algos/search_n.h b/libcxx/include/__pstl/cpu_algos/search_n.h
new file mode 100644
index 0000000000000..4fd2bef73ff7f
--- /dev/null
+++ b/libcxx/include/__pstl/cpu_algos/search_n.h
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_SEARCH_N_H
+#define _LIBCPP___PSTL_CPU_ALGOS_SEARCH_N_H
+
+#include <__algorithm/search_n.h>
+#include <__config>
+#include <__functional/operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.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/find_if.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/convert_to_integral.h>
+#include <__utility/move.h>
+#include <__utility/pair.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_search_n {
+ template <class _Policy, class _ForwardIterator, class _Size, class _Tp, class _Predicate>
+ _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+ operator()(_Policy&&,
+ _ForwardIterator __first,
+ _ForwardIterator __last,
+ _Size __count,
+ const _Tp& __value,
+ _Predicate __pred) const noexcept {
+ if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+ __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+ typedef typename std::iterator_traits<_ForwardIterator>::
diff erence_type _DifferenceType;
+ _DifferenceType __integral_count = std::__convert_to_integral(__count);
+ if (__integral_count <= 0) {
+ return __first; // If the count is non-positive, the first iterator is returned.
+ }
+ _DifferenceType __size = __last - __first;
+ if (__size < __integral_count) {
+ return __last; // The range is too small to contain the requested number of consecutive elements.
+ }
+ // Calculate the length of the tail where a potential match cannot start by definition.
+ _DifferenceType __crop = __integral_count - 1;
+ // We're only interested in the range where a potential match can start: [first, last - crop)
+ _ForwardIterator __last2 = __last - __crop;
+ // Run a parallel chunked find_if, covering the range where a potential match can start.
+ auto __res = __pstl::__parallel_find<_Backend>(
+ __first,
+ __last2,
+ [__integral_count, __crop, &__value, &__pred](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+ // Uncrop the range to allow std::search_n to find a full match, which can go beyond __brick_last.
+ _ForwardIterator __brick_last_uncropped = __brick_last + __crop;
+ // Run a serial std::search_n inside each of the chunks in parallel.
+ _ForwardIterator __ret =
+ std::search_n(__brick_first, __brick_last_uncropped, __integral_count, __value, __pred);
+ // The returned iterator is either a match inside [__brick_first, __brick_last) or a miss encoded as
+ // __brick_last_uncropped. Return the miss as __brick_last to conform to expectations of __parallel_find().
+ return __ret == __brick_last_uncropped ? __brick_last : __ret;
+ },
+ less<>{}, // `less` here means the lowest index among the matches
+ true // `true` here means we want the first match, not the last
+ );
+ if (!__res) {
+ return std::nullopt; // Failed to run the algorithm, propagate the error.
+ }
+ if (*__res == __last2) {
+ return __last; // No match was found in the range.
+ }
+ return *__res; // Return the successful match.
+ } else {
+ // Non-random access iterators cannot be processed in parallel, fall back to the sequential implementation.
+ return std::search_n(std::move(__first), std::move(__last), __count, __value, std::move(__pred));
+ }
+ }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_SEARCH_N_H
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index a5eac9fc149f0..a5944dbb8ec9a 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -2437,6 +2437,9 @@ module std {
module reverse {
header "__pstl/cpu_algos/reverse.h"
}
+ module search_n {
+ header "__pstl/cpu_algos/search_n.h"
+ }
module stable_sort {
header "__pstl/cpu_algos/stable_sort.h"
export std_core.utility_core.empty
diff --git a/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp b/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
index 2d510be58e164..84996de9d9298 100644
--- a/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
+++ b/libcxx/test/libcxx/algorithms/pstl.iterator-requirements.verify.cpp
@@ -223,6 +223,11 @@ void f(non_forward_iterator non_fwd,
(void)std::rotate_copy(pol, it, it, it, non_output); // expected-error@*:* {{static assertion failed: rotate_copy}}
}
+ {
+ (void)std::search_n(pol, non_fwd, non_fwd, 1, 1); // expected-error@*:* {{static assertion failed: search_n}}
+ (void)std::search_n(pol, non_fwd, non_fwd, 1, 1, pred); // expected-error@*:* {{static assertion failed: search_n}}
+ }
+
{
(void)std::sort(pol, non_fwd, non_fwd); // expected-error@*:* {{static assertion failed: sort}}
(void)std::sort(pol, non_fwd, non_fwd, pred); // expected-error@*:* {{static assertion failed: sort}}
diff --git a/libcxx/test/libcxx/algorithms/pstl.nodiscard.verify.cpp b/libcxx/test/libcxx/algorithms/pstl.nodiscard.verify.cpp
index 37e843eb90fe1..44e8acfcb877e 100644
--- a/libcxx/test/libcxx/algorithms/pstl.nodiscard.verify.cpp
+++ b/libcxx/test/libcxx/algorithms/pstl.nodiscard.verify.cpp
@@ -83,4 +83,8 @@ void test() {
std::lexicographical_compare(std::execution::par, std::begin(a), std::end(a), std::begin(b), std::end(b));
// expected-warning at +1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::lexicographical_compare(std::execution::par, std::begin(a), std::end(a), std::begin(b), std::end(b), pred2);
+ // expected-warning at +1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::search_n(std::execution::par, std::begin(a), std::end(a), 1, 1);
+ // expected-warning at +1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::search_n(std::execution::par, std::begin(a), std::end(a), 1, 1, pred2);
}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n.pass.cpp
new file mode 100644
index 0000000000000..b5896a05c359c
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n.pass.cpp
@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <algorithm>
+
+// template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
+// ForwardIterator
+// search_n(ExecutionPolicy&& exec,
+// ForwardIterator first, ForwardIterator last,
+// Size count, const T& value);
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+
+#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(search_n);
+
+static_assert(sfinae_test_search_n<int, int*, int*, int, int>);
+static_assert(!sfinae_test_search_n<std::execution::parallel_policy, int*, int*, int, int>);
+
+template <class Iter>
+struct Test {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ { // check the return types
+ int a[] = {0};
+ auto res = std::search_n(policy, Iter(std::begin(a)), Iter(std::begin(a)), 1, 0);
+ static_assert(std::is_same_v<decltype(res), Iter>);
+ }
+ { // single element range with count = 1, matching
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 5);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // single element range with count = 1, not matching
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 3);
+ assert(ret == Iter(std::end(a)));
+ }
+ { // simple test - single match in the middle, count = 1
+ int a[] = {1, 2, 3, 4, 5, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 3);
+ assert(ret == Iter(std::begin(a) + 2));
+ }
+ { // matching part begins at the front
+ int a[] = {7, 7, 3, 7, 3, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 7);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // matching part ends at the back
+ int a[] = {9, 3, 6, 4, 4};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 4);
+ assert(ret == Iter(std::begin(a) + 3));
+ }
+ { // pattern does not match
+ int a[] = {9, 3, 6, 4, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 1);
+ assert(ret == Iter(std::end(a)));
+ }
+ { // range and pattern are identical
+ int a[] = {1, 1, 1, 1};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 1);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // pattern is longer than range
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 5);
+ assert(ret == Iter(std::end(a)));
+ }
+ { // pattern is longer than range
+ int a[] = {3, 3, 3};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 3);
+ assert(ret == Iter(std::end(a)));
+ }
+ { // pattern has zero length
+ int a[] = {6, 7, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 0, 7);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // range has zero length
+ int a[] = {0};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::begin(a)), 1, 1);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // check that the first match is returned
+ { // match is at the start
+ int a[] = {6, 6, 8, 6, 6, 8, 6, 6, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 6);
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // match is in the middle
+ int a[] = {6, 8, 8, 6, 6, 8, 6, 6, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 6);
+ assert(ret == Iter(std::begin(a) + 3));
+ }
+ { // match is at the end
+ int a[] = {6, 6, 8, 6, 6, 8, 6, 6, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 3, 6);
+ assert(ret == Iter(std::begin(a) + 6));
+ }
+ { // multiple overlapping potential matches
+ int a[] = {3, 3, 3, 3, 3};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 3, 3);
+ assert(ret == Iter(std::begin(a)));
+ }
+ }
+ { // first almost matches, second is a match
+ int a[] = {6, 6, 6, 7, 6, 6, 6, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 6);
+ assert(ret == Iter(std::begin(a) + 4));
+ }
+ { // big haystack, small needle (size=1)
+ int a[1073];
+ std::fill(std::begin(a), std::end(a), 0);
+ runway_sample(std::size(a), [&](size_t i) {
+ a[i] = 1;
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 1);
+ assert(ret == Iter(std::begin(a) + i));
+ a[i] = 0;
+ });
+ }
+ { // big haystack, medium needle (size=73)
+ int a[1073];
+ constexpr size_t needle_size = 73;
+ std::fill(std::begin(a), std::end(a), 0);
+ runway_sample(std::size(a) - needle_size + 1, [&](size_t i) {
+ std::fill(std::begin(a) + i, std::begin(a) + i + needle_size, 1);
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), needle_size, 1);
+ assert(ret == Iter(std::begin(a) + i));
+ std::fill(std::begin(a) + i, std::begin(a) + i + needle_size, 0);
+ });
+ }
+ { // big haystack, same size needle
+ int a[1073];
+ std::fill(std::begin(a), std::end(a), 1);
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), std::size(a), 1);
+ assert(ret == Iter(std::begin(a)));
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(types::forward_iterator_list<const int*>{}, TestIteratorWithPolicies<Test>{});
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n_pred.pass.cpp
new file mode 100644
index 0000000000000..da1caa9fc5169
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/pstl.search_n_pred.pass.cpp
@@ -0,0 +1,164 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// <algorithm>
+
+// template<class ExecutionPolicy, class ForwardIterator, class Size, class T, class BinaryPredicate>
+// ForwardIterator
+// search_n(ExecutionPolicy&& exec,
+// ForwardIterator first, ForwardIterator last,
+// Size count, const T& value, BinaryPredicate pred);
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+
+#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(search_n);
+
+static_assert(sfinae_test_search_n<int, int*, int*, int, int, bool (*)(int, int)>);
+static_assert(!sfinae_test_search_n<std::execution::parallel_policy, int*, int*, int, int, bool (*)(int, int)>);
+
+struct Pred {
+ bool operator()(int hay, int needle) const { return hay * 2 == needle; }
+};
+
+template <class Iter>
+struct Test {
+ template <class ExecutionPolicy>
+ void operator()(ExecutionPolicy&& policy) {
+ { // check the return types
+ int a[] = {0};
+ auto res = std::search_n(policy, Iter(std::begin(a)), Iter(std::begin(a)), 1, 0, Pred{});
+ static_assert(std::is_same_v<decltype(res), Iter>);
+ }
+ { // single element range with count = 1, matching
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 10, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // single element range with count = 1, not matching
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 6, Pred{});
+ assert(ret == Iter(std::end(a)));
+ }
+ { // simple test - single match in the middle, count = 1
+ int a[] = {1, 2, 3, 4, 5, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 6, Pred{});
+ assert(ret == Iter(std::begin(a) + 2));
+ }
+ { // matching part begins at the front
+ int a[] = {7, 7, 3, 7, 3, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 14, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // matching part ends at the back
+ int a[] = {9, 3, 6, 4, 4};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 8, Pred{});
+ assert(ret == Iter(std::begin(a) + 3));
+ }
+ { // pattern does not match
+ int a[] = {9, 3, 6, 4, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 1, Pred{});
+ assert(ret == Iter(std::end(a)));
+ }
+ { // range and pattern are identical
+ int a[] = {1, 1, 1, 1};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 2, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // pattern is longer than range
+ int a[] = {5};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 10, Pred{});
+ assert(ret == Iter(std::end(a)));
+ }
+ { // pattern is longer than range
+ int a[] = {3, 3, 3};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 6, Pred{});
+ assert(ret == Iter(std::end(a)));
+ }
+ { // pattern has zero length
+ int a[] = {6, 7, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 0, 14, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // range has zero length
+ int a[] = {0};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::begin(a)), 1, 2, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // check that the first match is returned
+ { // match is at the start
+ int a[] = {6, 6, 8, 6, 6, 8, 6, 6, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 12, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ { // match is in the middle
+ int a[] = {6, 8, 8, 6, 6, 8, 6, 6, 8};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 2, 12, Pred{});
+ assert(ret == Iter(std::begin(a) + 3));
+ }
+ { // match is at the end
+ int a[] = {6, 6, 8, 6, 6, 8, 6, 6, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 3, 12, Pred{});
+ assert(ret == Iter(std::begin(a) + 6));
+ }
+ { // multiple overlapping potential matches
+ int a[] = {3, 3, 3, 3, 3};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 3, 6, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ }
+ { // first almost matches, second is a match
+ int a[] = {6, 6, 6, 7, 6, 6, 6, 6};
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 4, 12, Pred{});
+ assert(ret == Iter(std::begin(a) + 4));
+ }
+ { // big haystack, small needle (size=1)
+ int a[1073];
+ std::fill(std::begin(a), std::end(a), 0);
+ runway_sample(std::size(a), [&](size_t i) {
+ a[i] = 1;
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), 1, 2, Pred{});
+ assert(ret == Iter(std::begin(a) + i));
+ a[i] = 0;
+ });
+ }
+ { // big haystack, medium needle (size=73)
+ int a[1073];
+ constexpr size_t needle_size = 73;
+ std::fill(std::begin(a), std::end(a), 0);
+ runway_sample(std::size(a) - needle_size + 1, [&](size_t i) {
+ std::fill(std::begin(a) + i, std::begin(a) + i + needle_size, 1);
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), needle_size, 2, Pred{});
+ assert(ret == Iter(std::begin(a) + i));
+ std::fill(std::begin(a) + i, std::begin(a) + i + needle_size, 0);
+ });
+ }
+ { // big haystack, same size needle
+ int a[1073];
+ std::fill(std::begin(a), std::end(a), 1);
+ auto ret = std::search_n(policy, Iter(std::begin(a)), Iter(std::end(a)), std::size(a), 2, Pred{});
+ assert(ret == Iter(std::begin(a)));
+ }
+ }
+};
+
+int main(int, char**) {
+ types::for_each(types::forward_iterator_list<const int*>{}, TestIteratorWithPolicies<Test>{});
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
index 514dc9a911302..bbe9f0ec51b3d 100644
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -22,6 +22,23 @@
template <class Iter>
TEST_CONSTEXPR_CXX20 bool test() {
+#if TEST_STD_VER >= 11
+ { // check the return type
+ int a[] = {0};
+ auto res = std::search_n(Iter(a), Iter(a + 1), 1, 0);
+ static_assert(std::is_same<decltype(res), Iter>::value, "");
+ }
+#endif
+ { // single element range with count = 1, matching
+ int a[] = {5};
+ auto ret = std::search_n(Iter(a), Iter(a + 1), 1, 5);
+ assert(base(ret) == a);
+ }
+ { // single element range with count = 1, not matching
+ int a[] = {5};
+ auto ret = std::search_n(Iter(a), Iter(a + 1), 1, 3);
+ assert(base(ret) == a + 1);
+ }
{ // simple test
int a[] = {1, 2, 3, 4, 5, 6};
auto ret = std::search_n(Iter(a), Iter(a + 6), 1, 3);
@@ -47,6 +64,11 @@ TEST_CONSTEXPR_CXX20 bool test() {
auto ret = std::search_n(Iter(a), Iter(a + 4), 4, 1);
assert(base(ret) == a);
}
+ { // pattern is longer than range
+ int a[] = {5};
+ auto ret = std::search_n(Iter(std::begin(a)), Iter(std::end(a)), 2, 5);
+ assert(base(ret) == std::end(a));
+ }
{ // pattern is longer than range
int a[] = {3, 3, 3};
auto ret = std::search_n(Iter(a), Iter(a + 3), 4, 3);
@@ -78,6 +100,16 @@ TEST_CONSTEXPR_CXX20 bool test() {
auto ret = std::search_n(Iter(a), Iter(a + 9), 3, 6);
assert(base(ret) == a + 6);
}
+ { // multiple overlapping potential matches
+ int a[] = {3, 3, 3, 3, 3};
+ auto ret = std::search_n(Iter(std::begin(a)), Iter(std::end(a)), 3, 3);
+ assert(base(ret) == std::begin(a));
+ }
+ }
+ { // first almost matches, second is a match
+ int a[] = {6, 6, 6, 7, 6, 6, 6, 6};
+ auto ret = std::search_n(Iter(std::begin(a)), Iter(std::end(a)), 4, 6);
+ assert(base(ret) == std::begin(a) + 4);
}
return true;
diff --git a/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp b/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
index 4998b02fd0650..c63f65572832f 100644
--- a/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
+++ b/libcxx/test/std/algorithms/pstl.exception_handling.pass.cpp
@@ -355,6 +355,18 @@ int main(int, char**) {
});
}
+ {
+ auto pred = maybe_throw(tokens[5], [](int x, int y) -> bool { return x == y; });
+
+ // search_n(first, last, n, val)
+ assert_non_throwing([=, &policy] { (void)std::search_n(policy, std::move(first1), std::move(last1), 1, 1); });
+
+ // search_n(first, last, n, val, pred)
+ assert_non_throwing([=, &policy] {
+ (void)std::search_n(policy, std::move(first1), std::move(last1), 1, 1, pred);
+ });
+ }
+
{
auto compare = maybe_throw(tokens[5], [](int x, int y) -> bool { return x < y; });
More information about the libcxx-commits
mailing list