From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1059) id A0AC93959CB3; Fri, 28 Aug 2020 16:09:06 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A0AC93959CB3 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1598630946; bh=nI94Z+rbsv/qID4ZYi98UoJsG6KIYm+G8inHBj84urM=; h=From:To:Subject:Date:From; b=kuyxyh6U4WPVjpDccbQ+FUTA7KTQWte+zAStGJoYU0q19crjjDdnPG+8lNBLgtHlK 54M42/K8lWc0P7niR1IsLw9q9TtPqIHAocm3UagC42dSZIYx5C0ALQET+PXIaOdrev I9yrsaVPjk8AtwPvPpPwQ7GOVyJ7xdQVBuBOFWsc= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Nathan Sidwell To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc/devel/c++-modules] libstdc++: Make std::chrono::duration use reduced ratio for period X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/devel/c++-modules X-Git-Oldrev: 33a55fdb1e763e252bca2c872d0ae7670d1fc720 X-Git-Newrev: 82030d51017323c5706d58d8c8626324ece007e4 Message-Id: <20200828160906.A0AC93959CB3@sourceware.org> Date: Fri, 28 Aug 2020 16:09:06 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 28 Aug 2020 16:09:06 -0000 https://gcc.gnu.org/g:82030d51017323c5706d58d8c8626324ece007e4 commit 82030d51017323c5706d58d8c8626324ece007e4 Author: Jonathan Wakely 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::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::type is the same type as common_type::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, but that seems unnecessarily expensive to compute. This change just uses duration 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 - 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 struct common_type, chrono::duration<_Rep2, _Period2>> - : __duration_common_type, _Period1, _Period2> + : __duration_common_type, + typename _Period1::type, + typename _Period2::type> { }; + /// Specialization of common_type for two identical chrono::duration types. + /// @relates duration + template + struct common_type, + chrono::duration<_Rep, _Period>> + { using type = chrono::duration<_Rep, typename _Period::type>; }; + + /// Specialization of common_type for one chrono::duration type. + /// @relates duration + template + struct common_type> + { 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, _Clock> { }; + /// Specialization of common_type for two identical chrono::time_point types. + /// @relates time_point + template + struct common_type, + 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 + struct common_type> + { 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 operator+() const { return *this; } - constexpr duration + constexpr duration 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 +// . + +// { dg-do compile { target c++11 } } + +// Test the changes introduced by P0548R1 "common_type and duration". +// Specifically, duration::period should be the reduced ratio, +// and common_type::type should be a duration using the +// reduced ratio. + +#include + +using std::chrono::duration; +using std::ratio; +using std::common_type; +using std::is_same; + +void +test01() +{ + using D1 = duration>; + static_assert( is_same>::value, + "duration::period is P::type, not P" ); + + using C1 = common_type::type; + static_assert( is_same>::value, + "common_type_t is duration"); + static_assert( is_same::type, C1>::value, + "common_type_t is common_type_t" ); + static_assert( is_same::type, C1>::value, + "common_type_t is common_type_t" ); + + using D2 = duration>; + static_assert( is_same>::value, + "duration::period is P2::type, not P2" ); + + using C2 = common_type::type; + static_assert( is_same>::value, + "common_type_t is duration"); + static_assert( is_same::type, C2>::value, + "common_type_t is common_type_t" ); + static_assert( is_same::type, C2>::value, + "common_type_t is common_type_t" ); + + using D3 = duration>; + static_assert( is_same>::value, + "duration::period is P3::type, not P3" ); + + using C3 = common_type::type; + static_assert( is_same>::value, + "common_type_t is duration"); + static_assert( is_same::type, C3>::value, + "common_type_t is common_type_t" ); + static_assert( is_same::type, C3>::value, + "common_type_t is common_type_t" ); + + using C12 = common_type::type; + static_assert( is_same::value, + "common_type_t uses the right period" ); + using C21 = common_type::type; + static_assert( is_same::value, + "common_type_t is common_type_t" ); + + using C13 = common_type::type; + static_assert( is_same::value, + "common_type_t uses the right period" ); + using C31 = common_type::type; + static_assert( is_same::value, + "common_type_t is common_type_t" ); + + using C23 = common_type::type; + static_assert( is_same::value, + "common_type_t uses the right period" ); + using C32 = common_type::type; + static_assert( is_same::value, + "common_type_t is common_type_t" ); + + using C123 = common_type::type; + static_assert( is_same::value, + "common_type of three durations uses the right period" ); + using C132 = common_type::type; + static_assert( is_same::value, "order doesn't matter" ); + using C312 = common_type::type; + static_assert( is_same::value, "order doesn't matter" ); + using C321 = common_type::type; + static_assert( is_same::value, "order doesn't matter" ); + + using C = common_type>, + duration>>::type; + static_assert( is_same::type, + ratio<1, 6>>>::value, "" ); +} + +void +test02() +{ + using D1 = duration>; + D1 d1; + static_assert( is_same::type>::value, + "unary + returns the reduced duration" ); + static_assert( is_same::type>::value, + "unary - returns the reduced duration" ); + + using D2 = duration>; + D2 d2; + static_assert( is_same::type>::value, + "unary + returns the reduced duration" ); + static_assert( is_same::type>::value, + "unary - returns the reduced duration" ); + + using D3 = duration>; + D3 d3; + static_assert( is_same::type>::value, + "unary + returns the reduced duration" ); + static_assert( is_same::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" }