[libc++] Use _Lazy in tuple constructors

[ldionne]

Summary

This reduces the number of instantiations and also avoid blowing up
past the fold-expression limit of Clang.

This is NOT a general statement that we should strive to stay within
Clang's (sometimes way too small) limits, however in this case the
change will reduce the number of template instantiations while at the
same time doing that, which is good.

[huixie90]

Thanks for the fix!

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp

24

I think this would call the move constructor tuple(tuple&&) = default;, which is always going to pass. Those constructors we manually write take a different types of tuple. Would be worth to create a type that is convertible from integral_constant and test tuple of those constructed from LargeTuple?

29

Why does t3 == t4 not work?

43

The new move constructor takes const Tuple<...>&&. It would be good to have a test for that too

LargeTuple t5(std::move(std::as_const(t3)));

[ldionne]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp

29

We seem to blow the constexpr stack. I suggest not trying to fix that in this patch in order to land this.

[ldionne]

Rebase. Fix tests and comments.

[huixie90]

Thanks LGTM!

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp

20–21

unused and remove?

28

nit: for completeness , perhaps we can have another test to test the const tuple& overload? (although source code is not in this patch)

TargetTuple t5 = std::as_const(tuple);

[ldionne]

Address comments.

[ldionne]

Reduce to tuples of size 512, otherwise we don't have enough memory on some builders.

[mstorsjo]

FYI, I see that this change had the effect, that compiling std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp now uses 2.3 GB of memory in Clang, while it previously only used 200 MB memory to compile it.

I guess that particular testcase is a rather extreme case, but I just wanted to doublecheck that this was expected behaviour.

[philnik]

In D132509#4656075, @mstorsjo wrote:

FYI, I see that this change had the effect, that compiling std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp now uses 2.3 GB of memory in Clang, while it previously only used 200 MB memory to compile it.

I guess that particular testcase is a rather extreme case, but I just wanted to doublecheck that this was expected behaviour.

Did the test changes affect the memory usage or the code changes?

[mstorsjo]

In D132509#4656084, @philnik wrote:

In D132509#4656075, @mstorsjo wrote:

FYI, I see that this change had the effect, that compiling std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp now uses 2.3 GB of memory in Clang, while it previously only used 200 MB memory to compile it.

I guess that particular testcase is a rather extreme case, but I just wanted to doublecheck that this was expected behaviour.

Did the test changes affect the memory usage or the code changes?

Good point. It looks like this was caused by the test change, not by the header itself.

The old test file together with the new header uses the same amount of memory to compile as before.

libcxx/include/tuple

public:
     { }
 
 #if _LIBCPP_STD_VER >= 23
     // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
 
     template <class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
     tuple(tuple<_Up...>& __t) : __base_(__t) {}
 
     template <class _Alloc, class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
     tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
 #endif // _LIBCPP_STD_VER >= 23
 
     // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
 
     template <class ..._Up, __enable_if_t<
         _And<
             _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
#endif // _LIBCPP_STD_VER >= 23
     { }
 
 #if _LIBCPP_STD_VER >= 23
     // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
 
     template <class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
     tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
 
     template <class _Alloc, class... _Up, enable_if_t<
         _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+        explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
     tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
         : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
 #endif // _LIBCPP_STD_VER >= 23
 
     // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
 
     template <template <class...> class _Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
     struct _CtorPredicateFromPair : false_type{};

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/recursion_depth.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 // Make sure that we don't blow up the template instantiation recursion depth
-// for tuples of size <= 1024.
+// for tuples of size <= 512.
 
 #include <tuple>
 #include <cassert>
 #include <utility>
 
+#include "test_macros.h"
+
 template <std::size_t... I>
 constexpr void CreateTuple(std::index_sequence<I...>) {
-  std::tuple<decltype(I)...> tuple(I...);
-  assert(std::get<0>(tuple) == 0);
-  assert(std::get<sizeof...(I)-1>(tuple) == sizeof...(I)-1);
+  using LargeTuple = std::tuple<std::integral_constant<std::size_t, I>...>;
+  using TargetTuple = std::tuple<decltype(I)...>;
+  LargeTuple tuple(std::integral_constant<std::size_t, I>{}...);
+  assert(std::get<0>(tuple).value == 0);
+  assert(std::get<sizeof...(I)-1>(tuple).value == sizeof...(I)-1);
+
+  TargetTuple t1 = tuple;                                  // converting copy constructor from &
+  TargetTuple t2 = static_cast<LargeTuple const&>(tuple);  // converting copy constructor from const&
+  TargetTuple t3 = std::move(tuple);                       // converting rvalue constructor
+  TargetTuple t4 = static_cast<LargeTuple const&&>(tuple); // converting const rvalue constructor
+  TargetTuple t5;                                          // default constructor
+  (void)t1; (void)t2; (void)t3; (void)t4; (void)t5;
+
+#if TEST_STD_VER >= 20
+  t1 = tuple;                                              // converting assignment from &
+  t1 = static_cast<LargeTuple const&>(tuple);              // converting assignment from const&
+  t1 = std::move(tuple);                                   // converting assignment from &&
+  t1 = static_cast<LargeTuple const&&>(tuple);             // converting assignment from const&&
+  swap(t1, t2);                                            // swap
+#endif
+  // t1 == tuple;                                          // comparison does not work yet (we blow the constexpr stack)
 }
 
 constexpr bool test() {
-  CreateTuple(std::make_index_sequence<1024>{});
+  CreateTuple(std::make_index_sequence<512>{});
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test(), "");
   return 0;
 }