[gcc/devel/c++-coroutines] libstdc++: Make std::chrono::duration use reduced ratio for period
Iain D Sandoe
iains@gcc.gnu.org
Fri Aug 28 19:44:22 GMT 2020
https://gcc.gnu.org/g:82030d51017323c5706d58d8c8626324ece007e4
commit 82030d51017323c5706d58d8c8626324ece007e4
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 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:
---
libstdc++-v3/include/std/chrono | 45 +++++--
.../duration/requirements/reduced_period.cc | 131 +++++++++++++++++++++
.../20_util/duration/requirements/typedefs_neg2.cc | 3 +-
3 files changed, 168 insertions(+), 11 deletions(-)
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 Libstdc++-cvs
mailing list