[libcxx-commits] [libcxx] a066217 - [libc++] Speed up set_intersection() by fast-forwarding over ranges of non-matching elements with one-sided binary search. (#75230)
via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Jul 18 13:11:29 PDT 2024
Author: Iuri Chaer
Date: 2024-07-18T16:11:24-04:00
New Revision: a0662176a9b40462aafbb17cd8eb8cf6a65e940e
URL: https://github.com/llvm/llvm-project/commit/a0662176a9b40462aafbb17cd8eb8cf6a65e940e
DIFF: https://github.com/llvm/llvm-project/commit/a0662176a9b40462aafbb17cd8eb8cf6a65e940e.diff
LOG: [libc++] Speed up set_intersection() by fast-forwarding over ranges of non-matching elements with one-sided binary search. (#75230)
One-sided binary search, aka meta binary search, has been in the public
domain for decades, and has the general advantage of being constant time
in the best case, with the downside of executing at most 2*log(N)
comparisons vs classic binary search's exact log(N). There are two
scenarios in which it really shines: the first one is when operating
over non-random-access iterators, because the classic algorithm requires
knowing the container's size upfront, which adds N iterator increments
to the complexity. The second one is when traversing the container in
order, trying to fast-forward to the next value: in that case the
classic algorithm requires at least O(N*log(N)) comparisons and, for
non-random-access iterators, O(N^2) iterator increments, whereas the
one-sided version will yield O(N) operations on both counts, with a
best-case of O(log(N)) comparisons which is very common in practice.
Added:
libcxx/benchmarks/algorithms/set_intersection.bench.cpp
libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_complexity.pass.cpp
Modified:
libcxx/benchmarks/CMakeLists.txt
libcxx/docs/ReleaseNotes/19.rst
libcxx/include/__algorithm/iterator_operations.h
libcxx/include/__algorithm/lower_bound.h
libcxx/include/__algorithm/set_intersection.h
libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp
libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.pass.cpp
libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.drop/types.h
libcxx/test/std/ranges/range.adaptors/range.transform/types.h
libcxx/test/support/test_iterators.h
Removed:
################################################################################
diff --git a/libcxx/benchmarks/CMakeLists.txt b/libcxx/benchmarks/CMakeLists.txt
index 110672600213a..d96ccc1e49f66 100644
--- a/libcxx/benchmarks/CMakeLists.txt
+++ b/libcxx/benchmarks/CMakeLists.txt
@@ -135,6 +135,7 @@ set(BENCHMARK_TESTS
algorithms/ranges_sort.bench.cpp
algorithms/ranges_sort_heap.bench.cpp
algorithms/ranges_stable_sort.bench.cpp
+ algorithms/set_intersection.bench.cpp
algorithms/sort.bench.cpp
algorithms/sort_heap.bench.cpp
algorithms/stable_sort.bench.cpp
diff --git a/libcxx/benchmarks/algorithms/set_intersection.bench.cpp b/libcxx/benchmarks/algorithms/set_intersection.bench.cpp
new file mode 100644
index 0000000000000..b3fb15fc77b31
--- /dev/null
+++ b/libcxx/benchmarks/algorithms/set_intersection.bench.cpp
@@ -0,0 +1,184 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+#include <cstdlib>
+#include <iterator>
+#include <set>
+#include <vector>
+
+#include "common.h"
+#include "test_iterators.h"
+
+namespace {
+
+// types of containers we'll want to test, covering interesting iterator types
+struct VectorContainer {
+ template <typename... Args>
+ using type = std::vector<Args...>;
+
+ static constexpr const char* Name = "Vector";
+};
+
+struct SetContainer {
+ template <typename... Args>
+ using type = std::set<Args...>;
+
+ static constexpr const char* Name = "Set";
+};
+
+using AllContainerTypes = std::tuple<VectorContainer, SetContainer>;
+
+// set_intersection performance may depend on where matching values lie
+enum class OverlapPosition {
+ None,
+ Front,
+ // performance-wise, matches at the back are identical to ones at the front
+ Interlaced,
+};
+
+struct AllOverlapPositions : EnumValuesAsTuple<AllOverlapPositions, OverlapPosition, 3> {
+ static constexpr const char* Names[] = {"None", "Front", "Interlaced"};
+};
+
+// forward_iterator wrapping which, for each increment, moves the underlying iterator forward Stride elements
+template <typename Wrapped>
+struct StridedFwdIt {
+ Wrapped base_;
+ unsigned stride_;
+
+ using iterator_category = std::forward_iterator_tag;
+ using
diff erence_type = typename Wrapped::
diff erence_type;
+ using value_type = typename Wrapped::value_type;
+ using pointer = typename Wrapped::pointer;
+ using reference = typename Wrapped::reference;
+
+ StridedFwdIt(Wrapped base, unsigned stride) : base_(base), stride_(stride) { assert(stride_ != 0); }
+
+ StridedFwdIt operator++() {
+ for (unsigned i = 0; i < stride_; ++i)
+ ++base_;
+ return *this;
+ }
+ StridedFwdIt operator++(int) {
+ auto tmp = *this;
+ ++*this;
+ return tmp;
+ }
+ value_type& operator*() { return *base_; }
+ const value_type& operator*() const { return *base_; }
+ value_type& operator->() { return *base_; }
+ const value_type& operator->() const { return *base_; }
+ bool operator==(const StridedFwdIt& o) const { return base_ == o.base_; }
+ bool operator!=(const StridedFwdIt& o) const { return !operator==(o); }
+};
+template <typename Wrapped>
+StridedFwdIt(Wrapped, unsigned) -> StridedFwdIt<Wrapped>;
+
+template <typename T>
+std::vector<T> getVectorOfRandom(size_t N) {
+ std::vector<T> v;
+ fillValues(v, N, Order::Random);
+ sortValues(v, Order::Random);
+ return std::vector<T>(v);
+}
+
+// Realistically, data won't all be nicely contiguous in a container,
+// we'll go through some effort to ensure that it's shuffled through memory
+// this is especially important for containers with non-contiguous element
+// storage, but it will affect even a std::vector, because when you copy a
+// std::vector<std::string> the underlying data storage position for the char
+// arrays of the copy are likely to have high locality
+template <class Container>
+std::pair<Container, Container> genCacheUnfriendlyData(size_t size1, size_t size2, OverlapPosition pos) {
+ using ValueType = typename Container::value_type;
+ auto move_into = [](auto first, auto last) {
+ Container out;
+ std::move(first, last, std::inserter(out, out.begin()));
+ return out;
+ };
+ const auto src_size = pos == OverlapPosition::None ? size1 + size2 : std::max(size1, size2);
+ std::vector<ValueType> src = getVectorOfRandom<ValueType>(src_size);
+
+ if (pos == OverlapPosition::None) {
+ std::sort(src.begin(), src.end());
+ return std::make_pair(move_into(src.begin(), src.begin() + size1), move_into(src.begin() + size1, src.end()));
+ }
+
+ // All other overlap types will have to copy some part of the data, but if
+ // we copy after sorting it will likely have high locality, so we sort
+ // each copy separately
+ auto copy = src;
+ std::sort(src.begin(), src.end());
+ std::sort(copy.begin(), copy.end());
+
+ switch (pos) {
+ case OverlapPosition::None:
+ // we like -Wswitch :)
+ break;
+
+ case OverlapPosition::Front:
+ return std::make_pair(move_into(src.begin(), src.begin() + size1), move_into(copy.begin(), copy.begin() + size2));
+
+ case OverlapPosition::Interlaced:
+ const auto stride1 = size1 < size2 ? size2 / size1 : 1;
+ const auto stride2 = size2 < size1 ? size1 / size2 : 1;
+ return std::make_pair(move_into(StridedFwdIt(src.begin(), stride1), StridedFwdIt(src.end(), stride1)),
+ move_into(StridedFwdIt(copy.begin(), stride2), StridedFwdIt(copy.end(), stride2)));
+ }
+ std::abort(); // would be std::unreachable() if it could
+ return std::pair<Container, Container>();
+}
+
+template <class ValueType, class Container, class Overlap>
+struct SetIntersection {
+ using ContainerType = typename Container::template type<Value<ValueType>>;
+ size_t size1_;
+ size_t size2_;
+
+ SetIntersection(size_t size1, size_t size2) : size1_(size1), size2_(size2) {}
+
+ bool skip() const noexcept {
+ // let's save some time and skip simmetrical runs
+ return size1_ < size2_;
+ }
+
+ void run(benchmark::State& state) const {
+ auto input = genCacheUnfriendlyData<ContainerType>(size1_, size2_, Overlap());
+ std::vector<Value<ValueType>> out(std::min(size1_, size2_));
+
+ const auto BATCH_SIZE = std::max(size_t{512}, (2 * TestSetElements) / (size1_ + size2_));
+ for (const auto& _ : state) {
+ while (state.KeepRunningBatch(BATCH_SIZE)) {
+ for (unsigned i = 0; i < BATCH_SIZE; ++i) {
+ const auto& [c1, c2] = input;
+ auto res = std::set_intersection(c1.begin(), c1.end(), c2.begin(), c2.end(), out.begin());
+ benchmark::DoNotOptimize(res);
+ }
+ }
+ }
+ }
+
+ std::string name() const {
+ return std::string("SetIntersection") + Overlap::name() + '_' + Container::Name + ValueType::name() + '_' +
+ std::to_string(size1_) + '_' + std::to_string(size2_);
+ }
+};
+
+} // namespace
+
+int main(int argc, char** argv) { /**/
+ benchmark::Initialize(&argc, argv);
+ if (benchmark::ReportUnrecognizedArguments(argc, argv))
+ return 1;
+
+ makeCartesianProductBenchmark<SetIntersection, AllValueTypes, AllContainerTypes, AllOverlapPositions>(
+ Quantities, Quantities);
+ benchmark::RunSpecifiedBenchmarks();
+ return 0;
+}
diff --git a/libcxx/docs/ReleaseNotes/19.rst b/libcxx/docs/ReleaseNotes/19.rst
index 624550f998858..ccafa1a1456e0 100644
--- a/libcxx/docs/ReleaseNotes/19.rst
+++ b/libcxx/docs/ReleaseNotes/19.rst
@@ -71,6 +71,10 @@ Improvements and New Features
- The ``std::ranges::minmax`` algorithm has been optimized for integral types, resulting in a performance increase of
up to 100x.
+- The ``std::set_intersection`` and ``std::ranges::set_intersection`` algorithms have been optimized to fast-forward over
+ contiguous ranges of non-matching values, reducing the number of comparisons from linear to
+ logarithmic growth with the number of elements in best-case scenarios.
+
- The ``_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM`` macro has been added to make the declarations in ``<strstream>`` available.
- The ``_LIBCPP_ENABLE_CXX26_REMOVED_WSTRING_CONVERT`` macro has been added to make the declarations in ``<locale>``
diff --git a/libcxx/include/__algorithm/iterator_operations.h b/libcxx/include/__algorithm/iterator_operations.h
index 5cf13f0a3f292..8ced989233bc4 100644
--- a/libcxx/include/__algorithm/iterator_operations.h
+++ b/libcxx/include/__algorithm/iterator_operations.h
@@ -11,6 +11,7 @@
#include <__algorithm/iter_swap.h>
#include <__algorithm/ranges_iterator_concept.h>
+#include <__assert>
#include <__config>
#include <__iterator/advance.h>
#include <__iterator/distance.h>
@@ -160,6 +161,59 @@ struct _IterOps<_ClassicAlgPolicy> {
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 void __advance_to(_Iter& __first, _Iter __last) {
__first = __last;
}
+
+ // advance with sentinel, a la std::ranges::advance
+ template <class _Iter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __
diff erence_type<_Iter>
+ __advance_to(_Iter& __iter, __
diff erence_type<_Iter> __count, const _Iter& __sentinel) {
+ return _IterOps::__advance_to(__iter, __count, __sentinel, typename iterator_traits<_Iter>::iterator_category());
+ }
+
+private:
+ // advance with sentinel, a la std::ranges::advance -- InputIterator specialization
+ template <class _InputIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __
diff erence_type<_InputIter> __advance_to(
+ _InputIter& __iter, __
diff erence_type<_InputIter> __count, const _InputIter& __sentinel, input_iterator_tag) {
+ __
diff erence_type<_InputIter> __dist = 0;
+ for (; __dist < __count && __iter != __sentinel; ++__dist)
+ ++__iter;
+ return __count - __dist;
+ }
+
+ // advance with sentinel, a la std::ranges::advance -- BidirectionalIterator specialization
+ template <class _BiDirIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __
diff erence_type<_BiDirIter>
+ __advance_to(_BiDirIter& __iter,
+ __
diff erence_type<_BiDirIter> __count,
+ const _BiDirIter& __sentinel,
+ bidirectional_iterator_tag) {
+ __
diff erence_type<_BiDirIter> __dist = 0;
+ if (__count >= 0)
+ for (; __dist < __count && __iter != __sentinel; ++__dist)
+ ++__iter;
+ else
+ for (__count = -__count; __dist < __count && __iter != __sentinel; ++__dist)
+ --__iter;
+ return __count - __dist;
+ }
+
+ // advance with sentinel, a la std::ranges::advance -- RandomIterator specialization
+ template <class _RandIter>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __
diff erence_type<_RandIter>
+ __advance_to(_RandIter& __iter,
+ __
diff erence_type<_RandIter> __count,
+ const _RandIter& __sentinel,
+ random_access_iterator_tag) {
+ auto __dist = _IterOps::distance(__iter, __sentinel);
+ _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+ __count == 0 || (__dist < 0) == (__count < 0), "__sentinel must precede __iter when __count < 0");
+ if (__count < 0)
+ __dist = __dist > __count ? __dist : __count;
+ else
+ __dist = __dist < __count ? __dist : __count;
+ __iter += __dist;
+ return __count - __dist;
+ }
};
_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__algorithm/lower_bound.h b/libcxx/include/__algorithm/lower_bound.h
index 8fd355a7cfc4a..c417d84835497 100644
--- a/libcxx/include/__algorithm/lower_bound.h
+++ b/libcxx/include/__algorithm/lower_bound.h
@@ -27,11 +27,13 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template <class _AlgPolicy, class _Iter, class _Sent, class _Type, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter
-__lower_bound(_Iter __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
- auto __len = _IterOps<_AlgPolicy>::distance(__first, __last);
-
+template <class _AlgPolicy, class _Iter, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter __lower_bound_bisecting(
+ _Iter __first,
+ const _Type& __value,
+ typename iterator_traits<_Iter>::
diff erence_type __len,
+ _Comp& __comp,
+ _Proj& __proj) {
while (__len != 0) {
auto __l2 = std::__half_positive(__len);
_Iter __m = __first;
@@ -46,6 +48,48 @@ __lower_bound(_Iter __first, _Sent __last, const _Type& __value, _Comp& __comp,
return __first;
}
+// One-sided binary search, aka meta binary search, has been in the public domain for decades, and has the general
+// advantage of being \Omega(1) rather than the classic algorithm's \Omega(log(n)), with the downside of executing at
+// most 2*log(n) comparisons vs the classic algorithm's exact log(n). There are two scenarios in which it really shines:
+// the first one is when operating over non-random-access iterators, because the classic algorithm requires knowing the
+// container's size upfront, which adds \Omega(n) iterator increments to the complexity. The second one is when you're
+// traversing the container in order, trying to fast-forward to the next value: in that case, the classic algorithm
+// would yield \Omega(n*log(n)) comparisons and, for non-random-access iterators, \Omega(n^2) iterator increments,
+// whereas the one-sided version will yield O(n) operations on both counts, with a \Omega(log(n)) bound on the number of
+// comparisons.
+template <class _AlgPolicy, class _ForwardIterator, class _Sent, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__lower_bound_onesided(_ForwardIterator __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
+ // step = 0, ensuring we can always short-circuit when distance is 1 later on
+ if (__first == __last || !std::__invoke(__comp, std::__invoke(__proj, *__first), __value))
+ return __first;
+
+ using _Distance = typename iterator_traits<_ForwardIterator>::
diff erence_type;
+ for (_Distance __step = 1; __first != __last; __step <<= 1) {
+ auto __it = __first;
+ auto __dist = __step - _IterOps<_AlgPolicy>::__advance_to(__it, __step, __last);
+ // once we reach the last range where needle can be we must start
+ // looking inwards, bisecting that range
+ if (__it == __last || !std::__invoke(__comp, std::__invoke(__proj, *__it), __value)) {
+ // we've already checked the previous value and it was less, we can save
+ // one comparison by skipping bisection
+ if (__dist == 1)
+ return __it;
+ return std::__lower_bound_bisecting<_AlgPolicy>(__first, __value, __dist, __comp, __proj);
+ }
+ // range not found, move forward!
+ __first = __it;
+ }
+ return __first;
+}
+
+template <class _AlgPolicy, class _ForwardIterator, class _Sent, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__lower_bound(_ForwardIterator __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
+ const auto __dist = _IterOps<_AlgPolicy>::distance(__first, __last);
+ return std::__lower_bound_bisecting<_AlgPolicy>(__first, __value, __dist, __comp, __proj);
+}
+
template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
diff --git a/libcxx/include/__algorithm/set_intersection.h b/libcxx/include/__algorithm/set_intersection.h
index 73d888d1b0384..bb0d86cd0f58d 100644
--- a/libcxx/include/__algorithm/set_intersection.h
+++ b/libcxx/include/__algorithm/set_intersection.h
@@ -12,10 +12,15 @@
#include <__algorithm/comp.h>
#include <__algorithm/comp_ref_type.h>
#include <__algorithm/iterator_operations.h>
+#include <__algorithm/lower_bound.h>
#include <__config>
+#include <__functional/identity.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/next.h>
+#include <__type_traits/is_same.h>
+#include <__utility/exchange.h>
#include <__utility/move.h>
+#include <__utility/swap.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -38,10 +43,103 @@ struct __set_intersection_result {
: __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
};
-template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InIter1, _InIter2, _OutIter>
+// Helper for __set_intersection() with one-sided binary search: populate result and advance input iterators if they
+// are found to potentially contain the same value in two consecutive calls. This function is very intimately related to
+// the way it is used and doesn't attempt to abstract that, it's not appropriate for general usage outside of its
+// context.
+template <class _InForwardIter1, class _InForwardIter2, class _OutIter>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_intersection_add_output_if_equal(
+ bool __may_be_equal,
+ _InForwardIter1& __first1,
+ _InForwardIter2& __first2,
+ _OutIter& __result,
+ bool& __prev_may_be_equal) {
+ if (__may_be_equal && __prev_may_be_equal) {
+ *__result = *__first1;
+ ++__result;
+ ++__first1;
+ ++__first2;
+ __prev_may_be_equal = false;
+ } else {
+ __prev_may_be_equal = __may_be_equal;
+ }
+}
+
+// With forward iterators we can make multiple passes over the data, allowing the use of one-sided binary search to
+// reduce best-case complexity to log(N). Understanding how we can use binary search and still respect complexity
+// guarantees is _not_ straightforward: the guarantee is "at most 2*(N+M)-1 comparisons", and one-sided binary search
+// will necessarily overshoot depending on the position of the needle in the haystack -- for instance, if we're
+// searching for 3 in (1, 2, 3, 4), we'll check if 3<1, then 3<2, then 3<4, and, finally, 3<3, for a total of 4
+// comparisons, when linear search would have yielded 3. However, because we won't need to perform the intervening
+// reciprocal comparisons (ie 1<3, 2<3, 4<3), that extra comparison doesn't run afoul of the guarantee. Additionally,
+// this type of scenario can only happen for match distances of up to 5 elements, because 2*log2(8) is 6, and we'll
+// still be worse-off at position 5 of an 8-element set. From then onwards these scenarios can't happen. TL;DR: we'll be
+// 1 comparison worse-off compared to the classic linear-searching algorithm if matching position 3 of a set with 4
+// elements, or position 5 if the set has 7 or 8 elements, but we'll never exceed the complexity guarantees from the
+// standard.
+template <class _AlgPolicy,
+ class _Compare,
+ class _InForwardIter1,
+ class _Sent1,
+ class _InForwardIter2,
+ class _Sent2,
+ class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InForwardIter1, _InForwardIter2, _OutIter>
__set_intersection(
- _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
+ _InForwardIter1 __first1,
+ _Sent1 __last1,
+ _InForwardIter2 __first2,
+ _Sent2 __last2,
+ _OutIter __result,
+ _Compare&& __comp,
+ std::forward_iterator_tag,
+ std::forward_iterator_tag) {
+ _LIBCPP_CONSTEXPR std::__identity __proj;
+ bool __prev_may_be_equal = false;
+
+ while (__first2 != __last2) {
+ _InForwardIter1 __first1_next =
+ std::__lower_bound_onesided<_AlgPolicy>(__first1, __last1, *__first2, __comp, __proj);
+ std::swap(__first1_next, __first1);
+ // keeping in mind that a==b iff !(a<b) && !(b<a):
+ // if we can't advance __first1, that means !(*__first1 < *_first2), therefore __may_be_equal==true
+ std::__set_intersection_add_output_if_equal(
+ __first1 == __first1_next, __first1, __first2, __result, __prev_may_be_equal);
+ if (__first1 == __last1)
+ break;
+
+ _InForwardIter2 __first2_next =
+ std::__lower_bound_onesided<_AlgPolicy>(__first2, __last2, *__first1, __comp, __proj);
+ std::swap(__first2_next, __first2);
+ std::__set_intersection_add_output_if_equal(
+ __first2 == __first2_next, __first1, __first2, __result, __prev_may_be_equal);
+ }
+ return __set_intersection_result<_InForwardIter1, _InForwardIter2, _OutIter>(
+ _IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)),
+ _IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)),
+ std::move(__result));
+}
+
+// input iterators are not suitable for multipass algorithms, so we stick to the classic single-pass version
+template <class _AlgPolicy,
+ class _Compare,
+ class _InInputIter1,
+ class _Sent1,
+ class _InInputIter2,
+ class _Sent2,
+ class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InInputIter1, _InInputIter2, _OutIter>
+__set_intersection(
+ _InInputIter1 __first1,
+ _Sent1 __last1,
+ _InInputIter2 __first2,
+ _Sent2 __last2,
+ _OutIter __result,
+ _Compare&& __comp,
+ std::input_iterator_tag,
+ std::input_iterator_tag) {
while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first1, *__first2))
++__first1;
@@ -55,12 +153,28 @@ __set_intersection(
}
}
- return __set_intersection_result<_InIter1, _InIter2, _OutIter>(
+ return __set_intersection_result<_InInputIter1, _InInputIter2, _OutIter>(
_IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)),
_IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)),
std::move(__result));
}
+template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InIter1, _InIter2, _OutIter>
+__set_intersection(
+ _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
+ return std::__set_intersection<_AlgPolicy>(
+ std::move(__first1),
+ std::move(__last1),
+ std::move(__first2),
+ std::move(__last2),
+ std::move(__result),
+ std::forward<_Compare>(__comp),
+ typename std::_IterOps<_AlgPolicy>::template __iterator_category<_InIter1>(),
+ typename std::_IterOps<_AlgPolicy>::template __iterator_category<_InIter2>());
+}
+
template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_intersection(
_InputIterator1 __first1,
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp
index 5323bb1bc1193..f7870485cfefc 100644
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/ranges_set_intersection.pass.cpp
@@ -28,6 +28,8 @@
#include <algorithm>
#include <array>
#include <concepts>
+#include <cstddef>
+#include <ranges>
#include "almost_satisfies_types.h"
#include "MoveOnly.h"
@@ -463,75 +465,6 @@ constexpr bool test() {
}
}
- // Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.
- {
- std::array<Data, 5> r1{{{1}, {3}, {5}, {7}, {9}}};
- std::array<Data, 5> r2{{{2}, {4}, {6}, {8}, {10}}};
- std::array<int, 0> expected{};
-
- const std::size_t maxOperation = 2 * (r1.size() + r2.size()) - 1;
-
- // iterator overload
- {
- std::array<Data, 0> out{};
- std::size_t numberOfComp = 0;
- std::size_t numberOfProj1 = 0;
- std::size_t numberOfProj2 = 0;
-
- const auto comp = [&numberOfComp](int x, int y) {
- ++numberOfComp;
- return x < y;
- };
-
- const auto proj1 = [&numberOfProj1](const Data& d) {
- ++numberOfProj1;
- return d.data;
- };
-
- const auto proj2 = [&numberOfProj2](const Data& d) {
- ++numberOfProj2;
- return d.data;
- };
-
- std::ranges::set_intersection(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), comp, proj1, proj2);
-
- assert(std::ranges::equal(out, expected, {}, &Data::data));
- assert(numberOfComp < maxOperation);
- assert(numberOfProj1 < maxOperation);
- assert(numberOfProj2 < maxOperation);
- }
-
- // range overload
- {
- std::array<Data, 0> out{};
- std::size_t numberOfComp = 0;
- std::size_t numberOfProj1 = 0;
- std::size_t numberOfProj2 = 0;
-
- const auto comp = [&numberOfComp](int x, int y) {
- ++numberOfComp;
- return x < y;
- };
-
- const auto proj1 = [&numberOfProj1](const Data& d) {
- ++numberOfProj1;
- return d.data;
- };
-
- const auto proj2 = [&numberOfProj2](const Data& d) {
- ++numberOfProj2;
- return d.data;
- };
-
- std::ranges::set_intersection(r1, r2, out.data(), comp, proj1, proj2);
-
- assert(std::ranges::equal(out, expected, {}, &Data::data));
- assert(numberOfComp < maxOperation);
- assert(numberOfProj1 < maxOperation);
- assert(numberOfProj2 < maxOperation);
- }
- }
-
// Comparator convertible to bool
{
struct ConvertibleToBool {
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_complexity.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_complexity.pass.cpp
new file mode 100644
index 0000000000000..ddf4087ddd6cd
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_complexity.pass.cpp
@@ -0,0 +1,404 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// Algorithmic complexity tests for both std::set_intersection and std::ranges::set_intersection
+
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+// requires OutputIterator<OutIter, InIter1::reference>
+// && OutputIterator<OutIter, InIter2::reference>
+// && HasLess<InIter2::value_type, InIter1::value_type>
+// && HasLess<InIter1::value_type, InIter2::value_type>
+// constexpr OutIter // constexpr after C++17
+// set_intersection(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
+// OutIter result);
+//
+// template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+// weakly_incrementable O, class Comp = ranges::less,
+// class Proj1 = identity, class Proj2 = identity>
+// requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+// constexpr set_intersection_result<I1, I2, O>
+// set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+// Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+//
+// template<input_range R1, input_range R2, weakly_incrementable O,
+// class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+// requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
+// constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
+// set_intersection(R1&& r1, R2&& r2, O result,
+// Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // since C++20
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <ranges>
+
+#include "test_iterators.h"
+
+namespace {
+
+// __debug_less will perform an additional comparison in an assertion
+static constexpr unsigned std_less_comparison_count_multiplier() noexcept {
+#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+ return 2;
+#else
+ return 1;
+#endif
+}
+
+struct [[nodiscard]] OperationCounts {
+ std::size_t comparisons{};
+ struct PerInput {
+ std::size_t proj{};
+ IteratorOpCounts iterops;
+
+ [[nodiscard]] constexpr bool isNotBetterThan(const PerInput& other) {
+ return proj >= other.proj && iterops.increments + iterops.decrements + iterops.zero_moves >=
+ other.iterops.increments + other.iterops.decrements + other.iterops.zero_moves;
+ }
+ };
+ std::array<PerInput, 2> in;
+
+ [[nodiscard]] constexpr bool isNotBetterThan(const OperationCounts& expect) {
+ return std_less_comparison_count_multiplier() * comparisons >= expect.comparisons &&
+ in[0].isNotBetterThan(expect.in[0]) && in[1].isNotBetterThan(expect.in[1]);
+ }
+};
+
+template <std::size_t ResultSize>
+struct counted_set_intersection_result {
+ std::array<int, ResultSize> result;
+ OperationCounts opcounts;
+
+ constexpr counted_set_intersection_result() = default;
+
+ constexpr explicit counted_set_intersection_result(std::array<int, ResultSize>&& contents) : result{contents} {}
+
+ constexpr void assertNotBetterThan(const counted_set_intersection_result& other) {
+ assert(result == other.result);
+ assert(opcounts.isNotBetterThan(other.opcounts));
+ }
+};
+
+template <std::size_t ResultSize>
+counted_set_intersection_result(std::array<int, ResultSize>) -> counted_set_intersection_result<ResultSize>;
+
+template <template <class...> class InIterType1,
+ template <class...>
+ class InIterType2,
+ class OutIterType,
+ std::size_t ResultSize,
+ std::ranges::input_range R1,
+ std::ranges::input_range R2>
+constexpr counted_set_intersection_result<ResultSize> counted_set_intersection(const R1& in1, const R2& in2) {
+ counted_set_intersection_result<ResultSize> out;
+
+ const auto comp = [&out](int x, int y) {
+ ++out.opcounts.comparisons;
+ return x < y;
+ };
+
+ operation_counting_iterator b1(InIterType1<decltype(in1.begin())>(in1.begin()), &out.opcounts.in[0].iterops);
+ operation_counting_iterator e1(InIterType1<decltype(in1.end()) >(in1.end()), &out.opcounts.in[0].iterops);
+
+ operation_counting_iterator b2(InIterType2<decltype(in2.begin())>(in2.begin()), &out.opcounts.in[1].iterops);
+ operation_counting_iterator e2(InIterType2<decltype(in2.end()) >(in2.end()), &out.opcounts.in[1].iterops);
+
+ std::set_intersection(b1, e1, b2, e2, OutIterType(out.result.data()), comp);
+
+ return out;
+}
+
+template <template <class...> class InIterType1,
+ template <class...>
+ class InIterType2,
+ class OutIterType,
+ std::size_t ResultSize,
+ std::ranges::input_range R1,
+ std::ranges::input_range R2>
+constexpr counted_set_intersection_result<ResultSize> counted_ranges_set_intersection(const R1& in1, const R2& in2) {
+ counted_set_intersection_result<ResultSize> out;
+
+ const auto comp = [&out](int x, int y) {
+ ++out.opcounts.comparisons;
+ return x < y;
+ };
+
+ const auto proj1 = [&out](const int& i) {
+ ++out.opcounts.in[0].proj;
+ return i;
+ };
+
+ const auto proj2 = [&out](const int& i) {
+ ++out.opcounts.in[1].proj;
+ return i;
+ };
+
+ operation_counting_iterator b1(InIterType1<decltype(in1.begin())>(in1.begin()), &out.opcounts.in[0].iterops);
+ operation_counting_iterator e1(InIterType1<decltype(in1.end()) >(in1.end()), &out.opcounts.in[0].iterops);
+
+ operation_counting_iterator b2(InIterType2<decltype(in2.begin())>(in2.begin()), &out.opcounts.in[1].iterops);
+ operation_counting_iterator e2(InIterType2<decltype(in2.end()) >(in2.end()), &out.opcounts.in[1].iterops);
+
+ std::ranges::subrange r1{b1, sentinel_wrapper<decltype(e1)>{e1}};
+ std::ranges::subrange r2{b2, sentinel_wrapper<decltype(e2)>{e2}};
+ std::same_as<std::ranges::set_intersection_result<decltype(e1), decltype(e2), OutIterType>> decltype(auto) result =
+ std::ranges::set_intersection(r1, r2, OutIterType{out.result.data()}, comp, proj1, proj2);
+ assert(base(result.in1) == base(e1));
+ assert(base(result.in2) == base(e2));
+ assert(base(result.out) == out.result.data() + out.result.size());
+
+ return out;
+}
+
+template <template <typename...> class In1, template <typename...> class In2, class Out>
+constexpr void testComplexityParameterizedIter() {
+ // Worst-case complexity:
+ // Let N=(last1 - first1) and M=(last2 - first2)
+ // At most 2*(N+M) - 1 comparisons and applications of each projection.
+ // At most 2*(N+M) iterator mutations.
+ {
+ std::array r1{1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
+ std::array r2{2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
+
+ counted_set_intersection_result<0> expected;
+ expected.opcounts.comparisons = 37;
+ expected.opcounts.in[0].proj = 37;
+ expected.opcounts.in[0].iterops.increments = 30;
+ expected.opcounts.in[0].iterops.decrements = 0;
+ expected.opcounts.in[1] = expected.opcounts.in[0];
+
+ expected.assertNotBetterThan(counted_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ expected.assertNotBetterThan(counted_ranges_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ }
+
+ {
+ std::array r1{1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
+ std::array r2{1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
+
+ counted_set_intersection_result expected(std::array{1, 3, 5, 7, 9, 11, 13, 15, 17, 19});
+ expected.opcounts.comparisons = 38;
+ expected.opcounts.in[0].proj = 38;
+ expected.opcounts.in[0].iterops.increments = 30;
+ expected.opcounts.in[0].iterops.decrements = 0;
+ expected.opcounts.in[1] = expected.opcounts.in[0];
+
+ expected.assertNotBetterThan(counted_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ expected.assertNotBetterThan(counted_ranges_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ }
+
+ // Lower complexity when there is low overlap between ranges: we can make 2*log(X) comparisons when one range
+ // has X elements that can be skipped over (and then 1 more to confirm that the value we found is equal).
+ {
+ std::array r1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+ std::array r2{15};
+
+ counted_set_intersection_result expected(std::array{15});
+ expected.opcounts.comparisons = 9;
+ expected.opcounts.in[0].proj = 9;
+ expected.opcounts.in[0].iterops.increments = 23;
+ expected.opcounts.in[0].iterops.decrements = 0;
+ expected.opcounts.in[1].proj = 9;
+ expected.opcounts.in[1].iterops.increments = 1;
+ expected.opcounts.in[1].iterops.decrements = 0;
+
+ expected.assertNotBetterThan(counted_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ expected.assertNotBetterThan(counted_ranges_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ }
+
+ {
+ std::array r1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+ std::array r2{0, 16};
+ counted_set_intersection_result<0> expected;
+
+ expected.opcounts.comparisons = 10;
+ expected.opcounts.in[0].proj = 10;
+ expected.opcounts.in[0].iterops.increments = 24;
+ expected.opcounts.in[0].iterops.decrements = 0;
+ expected.opcounts.in[1].proj = 10;
+ expected.opcounts.in[1].iterops.increments = 4;
+ expected.opcounts.in[1].iterops.decrements = 0;
+
+ expected.assertNotBetterThan(counted_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ expected.assertNotBetterThan(counted_ranges_set_intersection<In1, In2, Out, expected.result.size()>(r1, r2));
+ }
+}
+
+template <template <typename...> class In2, class Out>
+constexpr void testComplexityParameterizedIterPermutateIn1() {
+ //common_input_iterator
+ testComplexityParameterizedIter<forward_iterator, In2, Out>();
+ testComplexityParameterizedIter<bidirectional_iterator, In2, Out>();
+ testComplexityParameterizedIter<random_access_iterator, In2, Out>();
+}
+
+template <class Out>
+constexpr void testComplexityParameterizedIterPermutateIn1In2() {
+ testComplexityParameterizedIterPermutateIn1<forward_iterator, Out>();
+ testComplexityParameterizedIterPermutateIn1<bidirectional_iterator, Out>();
+ testComplexityParameterizedIterPermutateIn1<random_access_iterator, Out>();
+}
+
+constexpr bool testComplexity() {
+ testComplexityParameterizedIterPermutateIn1In2<forward_iterator<int*>>();
+ testComplexityParameterizedIterPermutateIn1In2<bidirectional_iterator<int*>>();
+ testComplexityParameterizedIterPermutateIn1In2<random_access_iterator<int*>>();
+ return true;
+}
+
+template <template <typename...> class In1, template <typename...> class In2, class Out>
+constexpr void testComplexityGuaranteesParameterizedIter() {
+ // now a more generic validation of the complexity guarantees when searching for a single value
+ for (unsigned range_size = 1; range_size < 20; ++range_size) {
+ std::ranges::iota_view<int, int> r1(0, range_size);
+ for (int i : r1) {
+ // At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons
+ counted_set_intersection_result<1> expected(std::array{i});
+ expected.opcounts.comparisons = 2 * (r1.size() + 1) - 1;
+ expected.opcounts.in[0].proj = expected.opcounts.comparisons;
+ expected.opcounts.in[1].proj = expected.opcounts.comparisons;
+ expected.opcounts.in[0].iterops.increments = 2 * r1.size();
+ expected.opcounts.in[1].iterops.increments = 2;
+ expected.opcounts.in[0].iterops.decrements = expected.opcounts.in[0].iterops.increments;
+ expected.opcounts.in[1].iterops.decrements = expected.opcounts.in[1].iterops.increments;
+
+ expected.assertNotBetterThan(
+ counted_set_intersection<In1, In2, Out, expected.result.size()>(r1, expected.result));
+ expected.assertNotBetterThan(
+ counted_ranges_set_intersection<In1, In2, Out, expected.result.size()>(r1, expected.result));
+ }
+ }
+}
+
+template <template <typename...> class In2, class Out>
+constexpr void testComplexityGuaranteesParameterizedIterPermutateIn1() {
+ //common_input_iterator
+ testComplexityGuaranteesParameterizedIter<forward_iterator, In2, Out>();
+ testComplexityGuaranteesParameterizedIter<bidirectional_iterator, In2, Out>();
+ testComplexityGuaranteesParameterizedIter<random_access_iterator, In2, Out>();
+}
+
+template <class Out>
+constexpr void testComplexityGuaranteesParameterizedIterPermutateIn1In2() {
+ testComplexityGuaranteesParameterizedIterPermutateIn1<forward_iterator, Out>();
+ testComplexityGuaranteesParameterizedIterPermutateIn1<bidirectional_iterator, Out>();
+ testComplexityGuaranteesParameterizedIterPermutateIn1<random_access_iterator, Out>();
+}
+
+constexpr bool testComplexityGuarantees() {
+ testComplexityGuaranteesParameterizedIterPermutateIn1In2<forward_iterator<int*>>();
+ testComplexityGuaranteesParameterizedIterPermutateIn1In2<bidirectional_iterator<int*>>();
+ testComplexityGuaranteesParameterizedIterPermutateIn1In2<random_access_iterator<int*>>();
+ return true;
+}
+
+constexpr bool testComplexityBasic() {
+ // Complexity: At most 2 * ((last1 - first1) + (last2 - first2)) - 1 comparisons and applications of each projection.
+ std::array<int, 5> r1{1, 3, 5, 7, 9};
+ std::array<int, 5> r2{2, 4, 6, 8, 10};
+ std::array<int, 0> expected{};
+
+ const std::size_t maxOperation = std_less_comparison_count_multiplier() * (2 * (r1.size() + r2.size()) - 1);
+
+ // std::set_intersection
+ {
+ std::array<int, 0> out{};
+ std::size_t numberOfComp = 0;
+
+ const auto comp = [&numberOfComp](int x, int y) {
+ ++numberOfComp;
+ return x < y;
+ };
+
+ std::set_intersection(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), comp);
+
+ assert(std::ranges::equal(out, expected));
+ assert(numberOfComp <= maxOperation);
+ }
+
+ // ranges::set_intersection iterator overload
+ {
+ std::array<int, 0> out{};
+ std::size_t numberOfComp = 0;
+ std::size_t numberOfProj1 = 0;
+ std::size_t numberOfProj2 = 0;
+
+ const auto comp = [&numberOfComp](int x, int y) {
+ ++numberOfComp;
+ return x < y;
+ };
+
+ const auto proj1 = [&numberOfProj1](int d) {
+ ++numberOfProj1;
+ return d;
+ };
+
+ const auto proj2 = [&numberOfProj2](int d) {
+ ++numberOfProj2;
+ return d;
+ };
+
+ std::ranges::set_intersection(r1.begin(), r1.end(), r2.begin(), r2.end(), out.data(), comp, proj1, proj2);
+
+ assert(std::ranges::equal(out, expected));
+ assert(numberOfComp <= maxOperation);
+ assert(numberOfProj1 <= maxOperation);
+ assert(numberOfProj2 <= maxOperation);
+ }
+
+ // ranges::set_intersection range overload
+ {
+ std::array<int, 0> out{};
+ std::size_t numberOfComp = 0;
+ std::size_t numberOfProj1 = 0;
+ std::size_t numberOfProj2 = 0;
+
+ const auto comp = [&numberOfComp](int x, int y) {
+ ++numberOfComp;
+ return x < y;
+ };
+
+ const auto proj1 = [&numberOfProj1](int d) {
+ ++numberOfProj1;
+ return d;
+ };
+
+ const auto proj2 = [&numberOfProj2](int d) {
+ ++numberOfProj2;
+ return d;
+ };
+
+ std::ranges::set_intersection(r1, r2, out.data(), comp, proj1, proj2);
+
+ assert(std::ranges::equal(out, expected));
+ assert(numberOfComp < maxOperation);
+ assert(numberOfProj1 < maxOperation);
+ assert(numberOfProj2 < maxOperation);
+ }
+ return true;
+}
+
+} // unnamed namespace
+
+int main(int, char**) {
+ testComplexityBasic();
+ testComplexity();
+ testComplexityGuarantees();
+
+ static_assert(testComplexityBasic());
+ static_assert(testComplexity());
+
+ // we hit maximum constexpr evaluation step limit even if we split this into
+ // the 3 types of the first type layer, so let's skip the constexpr validation
+ // static_assert(testComplexityGuarantees());
+
+ return 0;
+}
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.pass.cpp
index cda49acad985b..18f8d15335ec6 100644
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.pass.cpp
@@ -12,6 +12,7 @@
#include <iterator>
+#include <algorithm>
#include <cassert>
#include "test_iterators.h"
@@ -32,12 +33,16 @@ constexpr void check(int* first, std::iter_
diff erence_t<It> n, int* expected) {
// Count operations
if constexpr (Count) {
- auto it = stride_counting_iterator(It(first));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
std::ranges::advance(it, n);
if constexpr (std::random_access_iterator<It>) {
- assert(it.stride_count() <= 1);
+ assert(ops.increments + ops.decrements <= 1);
} else {
- assert(it.stride_count() == abs(M));
+ const auto big = std::max(ops.increments, ops.decrements);
+ const auto small = std::min(ops.increments, ops.decrements);
+ assert(big == std::size_t(abs(M)));
+ assert(small == 0);
}
}
}
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
index 76439ef93a607..d613105805dd5 100644
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp
@@ -38,14 +38,16 @@ check_forward(int* first, int* last, std::iter_
diff erence_t<It> n, int* expected
// Count operations
if constexpr (Count) {
- auto it = stride_counting_iterator(It(first));
- auto sent = sentinel_wrapper(stride_counting_iterator(It(last)));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
+ auto sent = sentinel_wrapper(operation_counting_iterator(It(last), &ops));
(void)std::ranges::advance(it, n, sent);
// We don't have a sized sentinel, so we have to increment one-by-one
// regardless of the iterator category.
- assert(it.stride_count() == M);
- assert(it.stride_displacement() == M);
- assert(it.equals_count() == expected_equals_count);
+ assert(static_cast<Difference>(ops.increments) == M);
+ assert(static_cast<Difference>(ops.decrements) == 0);
+ assert(ops.zero_moves == 0);
+ assert(ops.equal_cmps == static_cast<std::size_t>(expected_equals_count));
}
}
@@ -65,28 +67,24 @@ constexpr void check_forward_sized_sentinel(int* first, int* last, std::iter_dif
// Count operations
{
- auto it = stride_counting_iterator(It(first));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
auto sent = distance_apriori_sentinel(size);
(void)std::ranges::advance(it, n, sent);
if constexpr (std::random_access_iterator<It>) {
- assert(it.stride_count() <= 1);
- assert(it.stride_displacement() <= 1);
+ assert(ops.increments + ops.zero_moves == 1);
+ assert(ops.decrements == 0);
} else {
- assert(it.stride_count() == M);
- assert(it.stride_displacement() == M);
+ assert(static_cast<Difference>(ops.increments) == M);
+ assert(ops.decrements == 0);
+ assert(ops.zero_moves == 0);
}
}
}
-struct Expected {
- int stride_count;
- int stride_displacement;
- int equals_count;
-};
-
template <bool Count, typename It>
constexpr void
-check_backward(int* first, int* last, std::iter_
diff erence_t<It> n, int* expected, Expected expected_counts) {
+check_backward(int* first, int* last, std::iter_
diff erence_t<It> n, int* expected, IteratorOpCounts expected_counts) {
// Check preconditions for `advance` when called with negative `n`
// (see [range.iter.op.advance]). In addition, allow `n == 0`.
assert(n <= 0);
@@ -105,16 +103,18 @@ check_backward(int* first, int* last, std::iter_
diff erence_t<It> n, int* expecte
// Count operations
{
- auto it = stride_counting_iterator(It(last));
- auto sent = stride_counting_iterator(It(first));
- static_assert(std::bidirectional_iterator<stride_counting_iterator<It>>);
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(last), &ops);
+ auto sent = operation_counting_iterator(It(first), &ops);
+ static_assert(std::bidirectional_iterator<operation_counting_iterator<It>>);
static_assert(Count == !std::sized_sentinel_for<It, It>);
(void)std::ranges::advance(it, n, sent);
- assert(it.stride_count() == expected_counts.stride_count);
- assert(it.stride_displacement() == expected_counts.stride_displacement);
- assert(it.equals_count() == expected_counts.equals_count);
+ assert(ops.increments == expected_counts.increments);
+ assert(ops.decrements == expected_counts.decrements);
+ assert(ops.zero_moves == expected_counts.zero_moves);
+ assert(ops.equal_cmps == expected_counts.equal_cmps);
}
}
@@ -217,21 +217,22 @@ constexpr bool test() {
{
int* expected = n > size ? range : range + size - n;
{
- Expected expected_counts = {
- .stride_count = static_cast<int>(range + size - expected),
- .stride_displacement = -expected_counts.stride_count,
- .equals_count = n > size ? size + 1 : n,
+ IteratorOpCounts expected_counts = {
+ .increments = 0,
+ .decrements = static_cast<std::size_t>(range + size - expected),
+ .equal_cmps = static_cast<std::size_t>(n > size ? size + 1 : n),
};
check_backward<true, bidirectional_iterator<int*>>(range, range + size, -n, expected, expected_counts);
}
{
- Expected expected_counts = {
+ IteratorOpCounts expected_counts = {
// If `n >= size`, the algorithm can just do `it = std::move(sent);`
// instead of doing iterator arithmetic.
- .stride_count = (n >= size) ? 0 : 1,
- .stride_displacement = (n >= size) ? 0 : 1,
- .equals_count = 0,
+ .increments = 0,
+ .decrements = static_cast<std::size_t>((n == 0 || n >= size) ? 0 : 1),
+ .zero_moves = static_cast<std::size_t>(n == 0 && size != 0 ? 1 : 0),
+ .equal_cmps = 0,
};
check_backward<false, random_access_iterator<int*>>(range, range + size, -n, expected, expected_counts);
diff --git a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
index 2e9a28e4ad395..147c26e429063 100644
--- a/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp
@@ -12,6 +12,7 @@
#include <iterator>
+#include <algorithm>
#include <cassert>
#include <cstddef>
@@ -31,11 +32,12 @@ constexpr void check_assignable(int* first, int* last, int* expected) {
// Count operations
if constexpr (Count) {
- auto it = stride_counting_iterator(It(first));
- auto sent = assignable_sentinel(stride_counting_iterator(It(last)));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
+ auto sent = assignable_sentinel(operation_counting_iterator(It(last), &ops));
std::ranges::advance(it, sent);
assert(base(base(it)) == expected);
- assert(it.stride_count() == 0); // because we got here by assigning from last, not by incrementing
+ assert(ops.increments + ops.decrements == 0); // because we got here by assigning from last, not by incrementing
}
}
@@ -53,13 +55,17 @@ constexpr void check_sized_sentinel(int* first, int* last, int* expected) {
// Count operations
if constexpr (Count) {
- auto it = stride_counting_iterator(It(first));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
auto sent = distance_apriori_sentinel(size);
std::ranges::advance(it, sent);
if constexpr (std::random_access_iterator<It>) {
- assert(it.stride_count() == 1);
+ assert(ops.increments + ops.decrements + ops.zero_moves == 1);
} else {
- assert(it.stride_count() == size);
+ const auto big = std::max(ops.increments, ops.decrements);
+ const auto small = std::min(ops.increments, ops.decrements);
+ assert(big == static_cast<size_t>(size > 0 ? size : -size));
+ assert(small == 0);
}
}
}
@@ -78,10 +84,14 @@ constexpr void check_sentinel(int* first, int* last, int* expected) {
// Count operations
if constexpr (Count) {
- auto it = stride_counting_iterator(It(first));
- auto sent = sentinel_wrapper(stride_counting_iterator(It(last)));
+ IteratorOpCounts ops;
+ auto it = operation_counting_iterator(It(first), &ops);
+ auto sent = sentinel_wrapper(operation_counting_iterator(It(last), &ops));
std::ranges::advance(it, sent);
- assert(it.stride_count() == size);
+ const auto big = std::max(ops.increments, ops.decrements);
+ const auto small = std::min(ops.increments, ops.decrements);
+ assert(big == static_cast<size_t>(size > 0 ? size : -size));
+ assert(small == 0);
}
}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp
index 28ac53c2445d4..7e01b5884728f 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp
@@ -73,12 +73,12 @@ constexpr bool test() {
std::ranges::drop_view dropView7(MoveOnlyView(), 10);
assert(dropView7.begin() == globalBuff + 8);
- CountedView view8;
+ IteratorOpCounts opcounts;
+ CountedView view8(&opcounts);
+ ;
std::ranges::drop_view dropView8(view8, 5);
assert(base(base(dropView8.begin())) == globalBuff + 5);
- assert(dropView8.begin().stride_count() == 5);
- assert(base(base(dropView8.begin())) == globalBuff + 5);
- assert(dropView8.begin().stride_count() == 5);
+ assert(opcounts.increments == 5);
static_assert(!BeginInvocable<const ForwardView>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.drop/types.h b/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
index ae861bce40f1e..73d1e5045ad22 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.drop/types.h
@@ -120,10 +120,14 @@ struct Range {
int *end() const;
};
-using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
+using CountedIter = operation_counting_iterator<forward_iterator<int*>>;
struct CountedView : std::ranges::view_base {
- constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
- constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
+ explicit constexpr CountedView(IteratorOpCounts* opcounts) noexcept : opcounts_(opcounts) {}
+ constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff), opcounts_); }
+ constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8), opcounts_); }
+
+private:
+ IteratorOpCounts* opcounts_;
};
struct View : std::ranges::view_base {
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
index 14f85722a8c19..cc5679f229de2 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
@@ -119,12 +119,6 @@ struct Range {
int *end() const;
};
-using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
-struct CountedView : std::ranges::view_base {
- constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
- constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
-};
-
struct TimesTwo {
constexpr int operator()(int x) const { return x * 2; }
};
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
index bb3ba2182f557..31564a3977317 100644
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -725,17 +725,18 @@ struct common_input_iterator {
# endif // TEST_STD_VER >= 20
-// Iterator adaptor that counts the number of times the iterator has had a successor/predecessor
-// operation or an equality comparison operation called. Has three recorders:
-// * `stride_count`, which records the total number of calls to an op++, op--, op+=, or op-=.
-// * `stride_displacement`, which records the displacement of the calls. This means that both
-// op++/op+= will increase the displacement counter by 1, and op--/op-= will decrease the
-// displacement counter by 1.
-// * `equals_count`, which records the total number of calls to an op== or op!=. If compared
-// against a sentinel object, that sentinel object must call the `record_equality_comparison`
-// function so that the comparison is counted correctly.
+struct IteratorOpCounts {
+ std::size_t increments = 0; ///< Number of times the iterator moved forward (++it, it++, it+=positive, it-=negative).
+ std::size_t decrements = 0; ///< Number of times the iterator moved backward (--it, it--, it-=positive, it+=negative).
+ std::size_t zero_moves = 0; ///< Number of times a call was made to move the iterator by 0 positions (it+=0, it-=0).
+ std::size_t equal_cmps = 0; ///< Total number of calls to op== or op!=. If compared against a sentinel object, that
+ /// sentinel object must call the `record_equality_comparison` function so that the
+ /// comparison is counted correctly.
+};
+
+// Iterator adaptor that records its operation counts in a IteratorOpCounts
template <class It>
-class stride_counting_iterator {
+class operation_counting_iterator {
public:
using value_type = typename iter_value_or_void<It>::type;
using
diff erence_type = std::iter_
diff erence_t<It>;
@@ -747,147 +748,160 @@ class stride_counting_iterator {
std::conditional_t<std::input_iterator<It>, std::input_iterator_tag,
/* else */ std::output_iterator_tag
>>>>>;
+ using iterator_category = iterator_concept;
- stride_counting_iterator() requires std::default_initializable<It> = default;
-
- constexpr explicit stride_counting_iterator(It const& it) : base_(base(it)) { }
+ operation_counting_iterator()
+ requires std::default_initializable<It>
+ = default;
- friend constexpr It base(stride_counting_iterator const& it) { return It(it.base_); }
+ constexpr explicit operation_counting_iterator(It const& it, IteratorOpCounts* counts = nullptr)
+ : base_(base(it)), counts_(counts) {}
- constexpr
diff erence_type stride_count() const { return stride_count_; }
+ constexpr operation_counting_iterator(const operation_counting_iterator& o) { *this = o; }
+ constexpr operation_counting_iterator(operation_counting_iterator&& o) { *this = o; }
- constexpr
diff erence_type stride_displacement() const { return stride_displacement_; }
+ constexpr operation_counting_iterator& operator=(const operation_counting_iterator& o) = default;
+ constexpr operation_counting_iterator& operator=(operation_counting_iterator&& o) { return *this = o; }
- constexpr
diff erence_type equals_count() const { return equals_count_; }
+ friend constexpr It base(operation_counting_iterator const& it) { return It(it.base_); }
constexpr decltype(auto) operator*() const { return *It(base_); }
constexpr decltype(auto) operator[](
diff erence_type n) const { return It(base_)[n]; }
- constexpr stride_counting_iterator& operator++() {
- It tmp(base_);
- base_ = base(++tmp);
- ++stride_count_;
- ++stride_displacement_;
- return *this;
+ constexpr operation_counting_iterator& operator++() {
+ It tmp(base_);
+ base_ = base(++tmp);
+ moved_by(1);
+ return *this;
}
constexpr void operator++(int) { ++*this; }
- constexpr stride_counting_iterator operator++(int)
- requires std::forward_iterator<It>
+ constexpr operation_counting_iterator operator++(int)
+ requires std::forward_iterator<It>
{
- auto temp = *this;
- ++*this;
- return temp;
+ auto temp = *this;
+ ++*this;
+ return temp;
}
- constexpr stride_counting_iterator& operator--()
- requires std::bidirectional_iterator<It>
+ constexpr operation_counting_iterator& operator--()
+ requires std::bidirectional_iterator<It>
{
- It tmp(base_);
- base_ = base(--tmp);
- ++stride_count_;
- --stride_displacement_;
- return *this;
+ It tmp(base_);
+ base_ = base(--tmp);
+ moved_by(-1);
+ return *this;
}
- constexpr stride_counting_iterator operator--(int)
- requires std::bidirectional_iterator<It>
+ constexpr operation_counting_iterator operator--(int)
+ requires std::bidirectional_iterator<It>
{
- auto temp = *this;
- --*this;
- return temp;
+ auto temp = *this;
+ --*this;
+ return temp;
}
- constexpr stride_counting_iterator& operator+=(
diff erence_type const n)
- requires std::random_access_iterator<It>
+ constexpr operation_counting_iterator& operator+=(
diff erence_type const n)
+ requires std::random_access_iterator<It>
{
- It tmp(base_);
- base_ = base(tmp += n);
- ++stride_count_;
- ++stride_displacement_;
- return *this;
+ It tmp(base_);
+ base_ = base(tmp += n);
+ moved_by(n);
+ return *this;
}
- constexpr stride_counting_iterator& operator-=(
diff erence_type const n)
- requires std::random_access_iterator<It>
+ constexpr operation_counting_iterator& operator-=(
diff erence_type const n)
+ requires std::random_access_iterator<It>
{
- It tmp(base_);
- base_ = base(tmp -= n);
- ++stride_count_;
- --stride_displacement_;
- return *this;
+ It tmp(base_);
+ base_ = base(tmp -= n);
+ moved_by(-n);
+ return *this;
}
- friend constexpr stride_counting_iterator operator+(stride_counting_iterator it,
diff erence_type n)
- requires std::random_access_iterator<It>
+ friend constexpr operation_counting_iterator operator+(operation_counting_iterator it,
diff erence_type n)
+ requires std::random_access_iterator<It>
{
- return it += n;
+ return it += n;
}
- friend constexpr stride_counting_iterator operator+(
diff erence_type n, stride_counting_iterator it)
- requires std::random_access_iterator<It>
+ friend constexpr operation_counting_iterator operator+(
diff erence_type n, operation_counting_iterator it)
+ requires std::random_access_iterator<It>
{
- return it += n;
+ return it += n;
}
- friend constexpr stride_counting_iterator operator-(stride_counting_iterator it,
diff erence_type n)
- requires std::random_access_iterator<It>
+ friend constexpr operation_counting_iterator operator-(operation_counting_iterator it,
diff erence_type n)
+ requires std::random_access_iterator<It>
{
- return it -= n;
+ return it -= n;
}
- friend constexpr
diff erence_type operator-(stride_counting_iterator const& x, stride_counting_iterator const& y)
- requires std::sized_sentinel_for<It, It>
+ friend constexpr
diff erence_type
+ operator-(operation_counting_iterator const& x, operation_counting_iterator const& y)
+ requires std::sized_sentinel_for<It, It>
{
- return base(x) - base(y);
+ return base(x) - base(y);
}
- constexpr void record_equality_comparison() const { ++equals_count_; }
+ constexpr void record_equality_comparison() const {
+ if (counts_ != nullptr)
+ ++counts_->equal_cmps;
+ }
- constexpr bool operator==(stride_counting_iterator const& other) const
- requires std::sentinel_for<It, It>
+ constexpr bool operator==(operation_counting_iterator const& other) const
+ requires std::sentinel_for<It, It>
{
record_equality_comparison();
return It(base_) == It(other.base_);
}
- friend constexpr bool operator<(stride_counting_iterator const& x, stride_counting_iterator const& y)
- requires std::random_access_iterator<It>
+ friend constexpr bool operator<(operation_counting_iterator const& x, operation_counting_iterator const& y)
+ requires std::random_access_iterator<It>
{
- return It(x.base_) < It(y.base_);
+ return It(x.base_) < It(y.base_);
}
- friend constexpr bool operator>(stride_counting_iterator const& x, stride_counting_iterator const& y)
- requires std::random_access_iterator<It>
+ friend constexpr bool operator>(operation_counting_iterator const& x, operation_counting_iterator const& y)
+ requires std::random_access_iterator<It>
{
- return It(x.base_) > It(y.base_);
+ return It(x.base_) > It(y.base_);
}
- friend constexpr bool operator<=(stride_counting_iterator const& x, stride_counting_iterator const& y)
- requires std::random_access_iterator<It>
+ friend constexpr bool operator<=(operation_counting_iterator const& x, operation_counting_iterator const& y)
+ requires std::random_access_iterator<It>
{
- return It(x.base_) <= It(y.base_);
+ return It(x.base_) <= It(y.base_);
}
- friend constexpr bool operator>=(stride_counting_iterator const& x, stride_counting_iterator const& y)
- requires std::random_access_iterator<It>
+ friend constexpr bool operator>=(operation_counting_iterator const& x, operation_counting_iterator const& y)
+ requires std::random_access_iterator<It>
{
- return It(x.base_) >= It(y.base_);
+ return It(x.base_) >= It(y.base_);
}
template <class T>
void operator,(T const &) = delete;
private:
+ constexpr void moved_by(
diff erence_type n) {
+ if (counts_ == nullptr)
+ return;
+ if (n > 0)
+ ++counts_->increments;
+ else if (n < 0)
+ ++counts_->decrements;
+ else
+ ++counts_->zero_moves;
+ }
+
decltype(base(std::declval<It>())) base_;
-
diff erence_type stride_count_ = 0;
-
diff erence_type stride_displacement_ = 0;
- mutable
diff erence_type equals_count_ = 0;
+ IteratorOpCounts* counts_ = nullptr;
};
template <class It>
-stride_counting_iterator(It) -> stride_counting_iterator<It>;
+operation_counting_iterator(It) -> operation_counting_iterator<It>;
#endif // TEST_STD_VER > 17
More information about the libcxx-commits
mailing list