libstdc++: Remove redundant clock conversions in atomic waits

For the case where a timeout is specified using the system_clock we
perform a conversion to the preferred clock (which is either
steady_clock or system_clock itself), wait using __cond_wait_until_impl,
and then check the time by that clock again to see if it was reached.
This is entirely redundant, as we can just call __cond_wait_until_impl
directly. It will wait using the specified clock, and there's no need to
check the time twice. For the no_timeout case this removes two
unnecessary calls to the clock's now() function, and for the timeout
case it removes three calls.

libstdc++-v3/ChangeLog:

	* include/bits/atomic_timed_wait.h (__cond_wait_until): Do not
	perform redundant conversions to the same clock.

diff --git a/libstdc++-v3/include/bits/atomic_timed_wait.h b/libstdc++-v3/include/bits/atomic_timed_wait.h
index 9e44114dd5b6f5200fa5ac381a136230e5d70720..1c91c858ce7ce4350b7f9cd7225f52558afb5420 100644 (file)
--- a/libstdc++-v3/include/bits/atomic_timed_wait.h
+++ b/libstdc++-v3/include/bits/atomic_timed_wait.h
@@ -166,24 +166,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __cond_wait_until(__condvar& __cv, mutex& __mx,
          const chrono::time_point<_Clock, _Duration>& __atime)
       {
-#ifdef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
-       using __clock_t = chrono::steady_clock;
-#else
+#ifndef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
        using __clock_t = chrono::system_clock;
+#else
+       using __clock_t = chrono::steady_clock;
+       if constexpr (is_same_v<_Clock, chrono::steady_clock>)
+         return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
+       else
 #endif
-       const typename _Clock::time_point __c_entry = _Clock::now();
-       const __clock_t::time_point __s_entry = __clock_t::now();
-       const auto __delta = __atime - __c_entry;
-       const auto __s_atime = __s_entry + __delta;
-       if (__detail::__cond_wait_until_impl(__cv, __mx, __s_atime)
-           == __atomic_wait_status::no_timeout)
-         return __atomic_wait_status::no_timeout;
-       // We got a timeout when measured against __clock_t but
-       // we need to check against the caller-supplied clock
-       // to tell whether we should return a timeout.
-       if (_Clock::now() < __atime)
-         return __atomic_wait_status::no_timeout;
-       return __atomic_wait_status::timeout;
+       if constexpr (is_same_v<_Clock, chrono::system_clock>)
+         return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
+       else
+         {
+           const typename _Clock::time_point __c_entry = _Clock::now();
+           const __clock_t::time_point __s_entry = __clock_t::now();
+           const auto __delta = __atime - __c_entry;
+           const auto __s_atime = __s_entry + __delta;
+           if (__detail::__cond_wait_until_impl(__cv, __mx, __s_atime)
+               == __atomic_wait_status::no_timeout)
+             return __atomic_wait_status::no_timeout;
+           // We got a timeout when measured against __clock_t but
+           // we need to check against the caller-supplied clock
+           // to tell whether we should return a timeout.
+           if (_Clock::now() < __atime)
+             return __atomic_wait_status::no_timeout;
+           return __atomic_wait_status::timeout;
+         }
       }
 #endif // FUTEX