[libcxx] Optimize std::generate for segmented iterators

libcxx/docs/ReleaseNotes/22.rst

@@ -68,6 +68,8 @@ Improvements and New Features
   reduced debug information.
 
 - The performance of ``std::find`` has been improved by up to 2x for integral types
+- The ``std::generate`` algorithm has been optimized for segmented iterators, resulting in a performance improvement for
+  ``std::deque<short>`` and ``std::join_view<vector<vector<short>>>`` iterators.
 
 Deprecations and Removals
 -------------------------

libcxx/include/__algorithm/generate.h

@@ -9,19 +9,32 @@
 #ifndef _LIBCPP___ALGORITHM_GENERATE_H
 #define _LIBCPP___ALGORITHM_GENERATE_H
 
+#include <__algorithm/for_each.h>
 #include <__config>
+#include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _Generator>
+struct __generate_assigner {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __generate_assigner(_Generator& __gen) : __gen_(__gen) {}
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(_Tp&& __element) const {
+    std::forward<_Tp>(__element) = __gen_();
+  }
+
+  _Generator& __gen_;
+};
+
 template <class _ForwardIterator, class _Generator>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
-  for (; __first != __last; ++__first)
-    *__first = __gen();
+  std::for_each(__first, __last, __generate_assigner<_Generator>(__gen));
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp

@@ -16,50 +16,54 @@
 
 #include <algorithm>
 #include <cassert>
+#include <deque>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct gen_test
-{
-    TEST_CONSTEXPR int operator()() const {return 1;}
+struct gen_test {
+  TEST_CONSTEXPR int operator()() const { return 1; }
 };
 
-
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool test_constexpr() {
-    int ia[] = {0, 1, 2, 3, 4};
+  int ia[] = {0, 1, 2, 3, 4};
 
-    std::generate(std::begin(ia), std::end(ia), gen_test());
+  std::generate(std::begin(ia), std::end(ia), gen_test());
 
-    return std::all_of(std::begin(ia), std::end(ia), [](int x) { return x == 1; })
-        ;
-    }
+  return std::all_of(std::begin(ia), std::end(ia), [](int x) { return x == 1; });
+}
 #endif
 
-
 template <class Iter>
-void
-test()
-{
-    const unsigned n = 4;
-    int ia[n] = {0};
-    std::generate(Iter(ia), Iter(ia+n), gen_test());
-    assert(ia[0] == 1);
-    assert(ia[1] == 1);
-    assert(ia[2] == 1);
-    assert(ia[3] == 1);
+void test() {
+  const unsigned n = 4;
+  int ia[n]        = {0};
+  std::generate(Iter(ia), Iter(ia + n), gen_test());
+  assert(ia[0] == 1);
+  assert(ia[1] == 1);
+  assert(ia[2] == 1);
+  assert(ia[3] == 1);
+}
+
+void deque_test() {
+  int sizes[] = {0, 1, 2, 1023, 1024, 1025, 2047, 2048, 2049};
+  for (const int size : sizes) {
+    std::deque<int> d(size);
+    std::generate(d.begin(), d.end(), gen_test());
+    assert(std::all_of(d.begin(), d.end(), [](int x) { return x == 1; }));
+  }
 }
 
-int main(int, char**)
-{
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
-    test<int*>();
+int main(int, char**) {
+  test<forward_iterator<int*> >();
+  test<bidirectional_iterator<int*> >();
+  test<random_access_iterator<int*> >();
+  test<int*>();
+  deque_test();
 
 #if TEST_STD_VER > 17
-    static_assert(test_constexpr());
+  static_assert(test_constexpr());
 #endif
 
   return 0;