[gcc r10-9608] libstdc++: Make std::chrono::duration use reduced ratio for period
Jonathan Wakely
redi@gcc.gnu.org
Mon Mar 29 20:04:38 GMT 2021
https://gcc.gnu.org/g:7dea2f84f26d454331d34b8536c261b6e96205d7
commit r10-9608-g7dea2f84f26d454331d34b8536c261b6e96205d7
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Thu Aug 27 22:36:03 2020 +0100
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 uses duration<common_type_t<rep>, period>
which is the same type, so we avoid a common_type specialization.
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.
(cherry picked from commit 82030d51017323c5706d58d8c8626324ece007e4)
Diff:
---
libstdc++-v3/include/std/chrono | 55 +++++--
.../duration/requirements/reduced_period.cc | 183 +++++++++++++++++++++
.../20_util/duration/requirements/typedefs_neg2.cc | 3 +-
3 files changed, 228 insertions(+), 13 deletions(-)
diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index 6d78f32ac78..47c48857bef 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,30 @@ _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<typename common_type<_Rep>::type,
+ 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<typename common_type<_Rep>::type,
+ typename _Period::type>;
+ };
+
// 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
/// @cond undocumented
@@ -135,6 +152,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 +431,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,13 +468,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return __r; }
// 20.11.5.3 arithmetic
- constexpr duration
+
+ constexpr duration<typename common_type<rep>::type, period>
operator+() const
- { return *this; }
+ { return duration<typename common_type<rep>::type, period>(__r); }
- constexpr duration
+ constexpr duration<typename common_type<rep>::type, period>
operator-() const
- { return duration(-__r); }
+ { return duration<typename common_type<rep>::type, period>(-__r); }
_GLIBCXX17_CONSTEXPR duration&
operator++()
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..4c7472699d2
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/duration/requirements/reduced_period.cc
@@ -0,0 +1,183 @@
+// 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" );
+}
+
+template<typename T>
+struct Number
+{
+ explicit
+ Number(T t = 0) : i(t)
+ { }
+
+ template<typename U, bool B = std::is_convertible<U, T>::value,
+ typename = typename std::enable_if<B>::type>
+ explicit
+ Number(Number<U> n) : i(n.i)
+ { }
+
+ T i = 0;
+
+ Number& operator+=(Number n) { i += n.i; return *this; }
+ Number& operator-=(Number n) { i -= n.i; return *this; }
+ Number& operator*=(Number n) { i *= n.i; return *this; }
+ Number& operator/=(Number n) { i /= n.i; return *this; }
+ Number& operator%=(Number n) { i %= n.i; return *this; }
+
+ Number operator+(Number n) { return { i + n.i }; }
+ Number operator-(Number n) { return { i - n.i }; }
+ Number operator*(Number n) { return { i * n.i }; }
+ Number operator/(Number n) { return { i / n.i }; }
+ Number operator%(Number n) { return { i % n.i }; }
+};
+
+namespace std
+{
+ // Specialise common_type to give a different type
+ template<>
+ struct common_type<Number<int>, Number<int>>
+ { using type = Number<long>; };
+}
+
+void
+test03()
+{
+
+ using D4 = duration<Number<int>, ratio<49, 21>>;
+ static_assert( is_same<common_type<D4>::type,
+ duration<Number<long>, ratio<7, 3>>>::value,
+ "common_type_t<duration<R,P>> uses common_type_t<R>" );
+
+ D4 d4;
+ static_assert( is_same<decltype(+d4), common_type<D4>::type>::value,
+ "unary + returns type with common_type_t<D4::rep> as rep" );
+ static_assert( is_same<decltype(-d4), common_type<D4>::type>::value,
+ "unary - returns type with common_type_t<D4::rep> as rep" );
+}
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 Libstdc++-cvs
mailing list