[committed] libstdc++: Make std::chrono::duration use reduced ratio for period

Jonathan Wakely jwakely@redhat.com
Thu Aug 27 21:41:25 GMT 2020


This implements the changes from P0548 "common_type and duration". That
was a change for C++17, but as it corrects some issues introduced by DRs
I'm also treating it as a DR and changing it for all modes from C++11
up.

The main change is that duration<R,P>::period no longer denotes P, but
rather P::type, the reduced ratio. The unary operator+ and operator-
members of duration should now return a duration using that reduced
ratio.

The requirement that common_type<T>::type is the same type as
common_type<T, T>::type (rather than simply T) was already implemented
for PR 89102.

The standard says that duration::operator+() and duration::operator-()
should return common_type_t<duration>, but that seems unnecessarily
expensive to compute. This change just uses duration<rep, period> which
is the same type, so we don't need to instantiate common_type.

As an optimization, this also adds partial specializations of
common_type for two durations of the same type, a single duration, two
time_points of the same type, and a single time_point. These
specializations avoid instantiating other specializations of common_type
and one or both of __duration_common_type or __timepoint_common_type for
the cases where the answer is trivial to obtain.

libstdc++-v3/ChangeLog:

	* include/std/chrono (__duration_common_type): Ensure the
	reduced ratio is used. Remove unused partial specialization
	using __failure_type.
	(common_type): Pass reduced ratios to __duration_common_type.
	Add partial specializations for simple cases involving a single
	duration or time_point type.
	(duration::period): Use reduced ratio.
	(duration::operator+(), duration::operator-()): Return duration
	type using the reduced ratio.
	* testsuite/20_util/duration/requirements/typedefs_neg2.cc:
	Adjust expected errors.
	* testsuite/20_util/duration/requirements/reduced_period.cc: New test.

Tested powerpc64le-linux. Committed to trunk.

This is a C++17 feature, so I think it would be good to backport it to
gcc-10 as well. I'll let it bake on trunk for a while first though.


-------------- next part --------------
commit 82030d51017323c5706d58d8c8626324ece007e4
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Aug 27 22:36:03 2020

    libstdc++: Make std::chrono::duration use reduced ratio for period
    
    This implements the changes from P0548 "common_type and duration". That
    was a change for C++17, but as it corrects some issues introduced by DRs
    I'm also treating it as a DR and changing it for all modes from C++11
    up.
    
    The main change is that duration<R,P>::period no longer denotes P, but
    rather P::type, the reduced ratio. The unary operator+ and operator-
    members of duration should now return a duration using that reduced
    ratio.
    
    The requirement that common_type<T>::type is the same type as
    common_type<T, T>::type (rather than simply T) was already implemented
    for PR 89102.
    
    The standard says that duration::operator+() and duration::operator-()
    should return common_type_t<duration>, but that seems unnecessarily
    expensive to compute. This change just uses duration<rep, period> which
    is the same type, so we don't need to instantiate common_type.
    
    As an optimization, this also adds partial specializations of
    common_type for two durations of the same type, a single duration, two
    time_points of the same type, and a single time_point. These
    specializations avoid instantiating other specializations of common_type
    and one or both of __duration_common_type or __timepoint_common_type for
    the cases where the answer is trivial to obtain.
    
    libstdc++-v3/ChangeLog:
    
            * include/std/chrono (__duration_common_type): Ensure the
            reduced ratio is used. Remove unused partial specialization
            using __failure_type.
            (common_type): Pass reduced ratios to __duration_common_type.
            Add partial specializations for simple cases involving a single
            duration or time_point type.
            (duration::period): Use reduced ratio.
            (duration::operator+(), duration::operator-()): Return duration
            type using the reduced ratio.
            * testsuite/20_util/duration/requirements/typedefs_neg2.cc:
            Adjust expected errors.
            * testsuite/20_util/duration/requirements/reduced_period.cc: New test.

diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index 9fc8f560d99..fb251848da8 100644
--- a/libstdc++-v3/include/std/chrono
+++ b/libstdc++-v3/include/std/chrono
@@ -94,13 +94,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			(_Period1::den / __gcd_den::value) * _Period2::den>;
 
     public:
-      using type = chrono::duration<__cr, __r>;
+      using type = chrono::duration<__cr, typename __r::type>;
     };
 
-  template<typename _Period1, typename _Period2>
-    struct __duration_common_type<__failure_type, _Period1, _Period2>
-    { typedef __failure_type type; };
-
   /// @endcond
 
   /// Specialization of common_type for chrono::duration types.
@@ -108,9 +104,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
     struct common_type<chrono::duration<_Rep1, _Period1>,
 		       chrono::duration<_Rep2, _Period2>>
-    : __duration_common_type<common_type<_Rep1, _Rep2>, _Period1, _Period2>
+    : __duration_common_type<common_type<_Rep1, _Rep2>,
+			     typename _Period1::type,
+			     typename _Period2::type>
     { };
 
+  /// Specialization of common_type for two identical chrono::duration types.
+  /// @relates duration
+  template<typename _Rep, typename _Period>
+    struct common_type<chrono::duration<_Rep, _Period>,
+		       chrono::duration<_Rep, _Period>>
+    { using type = chrono::duration<_Rep, typename _Period::type>; };
+
+  /// Specialization of common_type for one chrono::duration type.
+  /// @relates duration
+  template<typename _Rep, typename _Period>
+    struct common_type<chrono::duration<_Rep, _Period>>
+    { using type = chrono::duration<_Rep, typename _Period::type>; };
+
   // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
 
   /// @cond undocumented
@@ -135,6 +146,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
     { };
 
+  /// Specialization of common_type for two identical chrono::time_point types.
+  /// @relates time_point
+  template<typename _Clock, typename _Duration>
+    struct common_type<chrono::time_point<_Clock, _Duration>,
+		       chrono::time_point<_Clock, _Duration>>
+    { using type = chrono::time_point<_Clock, _Duration>; };
+
+  /// Specialization of common_type for one chrono::time_point type.
+  /// @relates time_point
+  template<typename _Clock, typename _Duration>
+    struct common_type<chrono::time_point<_Clock, _Duration>>
+    { using type = chrono::time_point<_Clock, _Duration>; };
+
   // @} group chrono
 
   namespace chrono
@@ -401,8 +425,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       public:
 
-	typedef _Rep						rep;
-	typedef _Period 					period;
+	using rep = _Rep;
+	using period = typename _Period::type;
 
 	static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
 	static_assert(__is_ratio<_Period>::value,
@@ -438,11 +462,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ return __r; }
 
 	// 20.11.5.3 arithmetic
-	constexpr duration
+
+	constexpr duration<rep, period>
 	operator+() const
 	{ return *this; }
 
-	constexpr duration
+	constexpr duration<rep, period>
 	operator-() const
 	{ return duration(-__r); }
 
diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/reduced_period.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/reduced_period.cc
new file mode 100644
index 00000000000..9eb38a0e56f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/duration/requirements/reduced_period.cc
@@ -0,0 +1,131 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do compile { target c++11 } }
+
+// Test the changes introduced by P0548R1 "common_type and duration".
+// Specifically, duration<R,P>::period should be the reduced ratio,
+// and common_type<D1, D2>::type should be a duration using the
+// reduced ratio.
+
+#include <chrono>
+
+using std::chrono::duration;
+using std::ratio;
+using std::common_type;
+using std::is_same;
+
+void
+test01()
+{
+  using D1 = duration<int, ratio<10, 10>>;
+  static_assert( is_same<D1::period, ratio<1, 1>>::value,
+      "duration<R, P>::period is P::type, not P" );
+
+  using C1 = common_type<D1>::type;
+  static_assert( is_same<C1, duration<int, D1::period>>::value,
+      "common_type_t<duration<R, P1> is duration<R, P1::type>");
+  static_assert( is_same<common_type<D1, D1>::type, C1>::value,
+      "common_type_t<D1, D1> is common_type_t<D1>" );
+  static_assert( is_same<common_type<D1, D1, D1>::type, C1>::value,
+      "common_type_t<D1, D1, D1> is common_type_t<D1>" );
+
+  using D2 = duration<int, ratio<30, 15>>;
+  static_assert( is_same<D2::period, ratio<2, 1>>::value,
+      "duration<R, P2>::period is P2::type, not P2" );
+
+  using C2 = common_type<D2>::type;
+  static_assert( is_same<C2, duration<int, D2::period>>::value,
+      "common_type_t<duration<R, P2> is duration<R, P2::type>");
+  static_assert( is_same<common_type<D2, D2>::type, C2>::value,
+      "common_type_t<D2, D2> is common_type_t<D2>" );
+  static_assert( is_same<common_type<D2, D2, D2>::type, C2>::value,
+      "common_type_t<D2, D2, D2> is common_type_t<D2>" );
+
+  using D3 = duration<int, ratio<4, 12>>;
+  static_assert( is_same<D3::period, ratio<1, 3>>::value,
+      "duration<R, P3>::period is P3::type, not P3" );
+
+  using C3 = common_type<D3>::type;
+  static_assert( is_same<C3, duration<int, D3::period>>::value,
+      "common_type_t<duration<R, P3> is duration<R, P3::type>");
+  static_assert( is_same<common_type<D3, D3>::type, C3>::value,
+      "common_type_t<D3, D3> is common_type_t<D3>" );
+  static_assert( is_same<common_type<D3, D3, D3>::type, C3>::value,
+      "common_type_t<D3, D3, D3> is common_type_t<D3>" );
+
+  using C12 = common_type<D1, D2>::type;
+  static_assert( is_same<C12, C1>::value,
+      "common_type_t<D1, D2> uses the right period" );
+  using C21 = common_type<D2, D1>::type;
+  static_assert( is_same<C21, C12>::value,
+      "common_type_t<D1, D2> is common_type_t<D2, D1>" );
+
+  using C13 = common_type<D1, D3>::type;
+  static_assert( is_same<C13, C3>::value,
+      "common_type_t<D1, D3> uses the right period" );
+  using C31 = common_type<D3, D1>::type;
+  static_assert( is_same<C31, C13>::value,
+      "common_type_t<D1, D3> is common_type_t<D3, D1>" );
+
+  using C23 = common_type<D2, D3>::type;
+  static_assert( is_same<C23, C3>::value,
+      "common_type_t<D2, D3> uses the right period" );
+  using C32 = common_type<D3, D2>::type;
+  static_assert( is_same<C32, C23>::value,
+      "common_type_t<D2, D3> is common_type_t<D3, D2>" );
+
+  using C123 = common_type<D1, D2, D3>::type;
+  static_assert( is_same<C123, C3>::value,
+      "common_type of three durations uses the right period" );
+  using C132 = common_type<D1, D3, D2>::type;
+  static_assert( is_same<C132, C123>::value, "order doesn't matter" );
+  using C312 = common_type<D3, D1, D2>::type;
+  static_assert( is_same<C312, C123>::value, "order doesn't matter" );
+  using C321 = common_type<D3, D2, D1>::type;
+  static_assert( is_same<C321, C123>::value, "order doesn't matter" );
+
+  using C = common_type<duration<short, ratio<1, 3>>,
+			duration<unsigned, ratio<1, 2>>>::type;
+  static_assert( is_same<C, duration<common_type<short, unsigned>::type,
+				     ratio<1, 6>>>::value, "" );
+}
+
+void
+test02()
+{
+  using D1 = duration<int, ratio<10, 10>>;
+  D1 d1;
+  static_assert( is_same<decltype(+d1), common_type<D1>::type>::value,
+      "unary + returns the reduced duration" );
+  static_assert( is_same<decltype(-d1), common_type<D1>::type>::value,
+      "unary - returns the reduced duration" );
+
+  using D2 = duration<int, ratio<30, 15>>;
+  D2 d2;
+  static_assert( is_same<decltype(+d2), common_type<D2>::type>::value,
+      "unary + returns the reduced duration" );
+  static_assert( is_same<decltype(-d2), common_type<D2>::type>::value,
+      "unary - returns the reduced duration" );
+
+  using D3 = duration<int, ratio<4, 12>>;
+  D3 d3;
+  static_assert( is_same<decltype(+d3), common_type<D3>::type>::value,
+      "unary + returns the reduced duration" );
+  static_assert( is_same<decltype(-d3), common_type<D3>::type>::value,
+      "unary - returns the reduced duration" );
+}
diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc
index d86e89b632b..02dab73b0eb 100644
--- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc
+++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc
@@ -31,4 +31,5 @@ void test01()
 }
 
 // { dg-error "must be a specialization of ratio" "" { target *-*-* } 0 }
-// { dg-prune-output "not a member" }
+// { dg-prune-output "'num' is not a member of 'int'" }
+// { dg-prune-output "'int' is not a class, struct, or union type" }


More information about the Gcc-patches mailing list