[libcxx] Support waiting on monotonic clock with ext. threading

[miyuki]

Summary

This patch adds support for using the monotonic clock (steady_clock)
when waiting on a condition variable with a timeout. This feature is
currently implemented for POSIX threads. The patch generalizes it to
be usable with an external threading library by adding
__libcpp_condvar_monotonic_timedwait.

The external threading layer implementors should define
_LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT in their __external_threading
header and implement the __libcpp_condvar_monotonic_timedwait function
to use the feature.

[miyuki]

Added missing "_LIBCPP_HIDE_FROM_ABI inline"

[• Quuxplusone]

No comment from me; this is above my pay grade. :)
But I could bikeshed the name of the macro: The old name reflected the pthreads name, pthread_cond_clockwait -> _LIBCPP_HAS_COND_CLOCKWAIT. The new name reflects nothing we didn't make up ourselves; so maybe it should be more like _LIBCPP_HAS_MONOTONIC_TIMEDWAIT or _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT. My understanding is that "steady" is a WG21-ism for "monotonic": even though you named the new function __libcpp_condvar_steady_timedwait, we never actually use steady_clock anywhere in its signature or implementation. Instead it depends on pthreads' CLOCK_MONOTONIC.

[miyuki]

Renamed steady -> monotonic.

[miyuki]

@ldionne, could you please have a look at this patch?

[ldionne]

[Github PR transition cleanup]

@miyuki This seems fine to me in principle. Do you still want to pursue this? If so please rebase it and ping me on Discord.

FWIW the "external threading API" is an area I've discussed several times with other folks that we should overhaul to support better and reduce the complexity for libc++, but this patch is orthogonal.

libcxx/include/__config

 #    define _LIBCPP_HAS_THREAD_API_WIN32
 #  else
 #    error "No thread API"
 #  endif // _LIBCPP_HAS_THREAD_API
 #endif // _LIBCPP_HAS_NO_THREADS
 
 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 #if defined(__ANDROID__) && __ANDROID_API__ >= 30
-#define _LIBCPP_HAS_COND_CLOCKWAIT
+#define _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT
 #elif defined(_LIBCPP_GLIBC_PREREQ)
 #if _LIBCPP_GLIBC_PREREQ(2, 30)
-#define _LIBCPP_HAS_COND_CLOCKWAIT
+#define _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT
 #endif
 #endif
 #endif
 
 #if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 #error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
        _LIBCPP_HAS_NO_THREADS is not defined.
 #endif

libcxx/include/__mutex_base

template <class _Rep, class _Period, class _Predicate>
                  _Predicate __pred);
 
     typedef __libcpp_condvar_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+#if defined(_LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT)
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<chrono::steady_clock, chrono::nanoseconds>) _NOEXCEPT;
 #endif
     template <class _Clock>
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<_Clock, chrono::nanoseconds>) _NOEXCEPT;
 };
 #endif // !_LIBCPP_HAS_NO_THREADS
condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d)
 {
     using namespace chrono;
     if (__d <= __d.zero())
         return cv_status::timeout;
     using __ns_rep = nanoseconds::rep;
     steady_clock::time_point __c_now = steady_clock::now();
 
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+#if defined(_LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT)
     using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
     __ns_rep __now_count_ns = _VSTD::__safe_nanosecond_cast(__c_now.time_since_epoch()).count();
 #else
     using __clock_tp_ns = time_point<system_clock, nanoseconds>;
     __ns_rep __now_count_ns = _VSTD::__safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
 #endif
 
     __ns_rep __d_ns_count = _VSTD::__safe_nanosecond_cast(__d).count();

 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
+#if defined(_LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT)
 inline
 void
 condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
      chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) _NOEXCEPT
 {
     using namespace chrono;
     if (!__lk.owns_lock())
         __throw_system_error(EPERM,
                             "condition_variable::timed wait: mutex not locked");
     nanoseconds __d = __tp.time_since_epoch();
-    timespec __ts;
+    __libcpp_timespec_t __ts;
     seconds __s = duration_cast<seconds>(__d);
     using __ts_sec = decltype(__ts.tv_sec);
     const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
     if (__s.count() < __ts_sec_max)
     {
         __ts.tv_sec = static_cast<__ts_sec>(__s.count());
         __ts.tv_nsec = (__d - __s).count();
     }
     else
     {
         __ts.tv_sec = __ts_sec_max;
         __ts.tv_nsec = giga::num - 1;
     }
-    int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
+    int __ec = __libcpp_condvar_monotonic_timedwait(&__cv_,
+                                                    __lk.mutex()->native_handle(),
+                                                    &__ts);
     if (__ec != 0 && __ec != ETIMEDOUT)
         __throw_system_error(__ec, "condition_variable timed_wait failed");
 }
-#endif // _LIBCPP_HAS_COND_CLOCKWAIT
+#endif // _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT
 
 template <class _Clock>
 inline
 void
 condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
      chrono::time_point<_Clock, chrono::nanoseconds> __tp) _NOEXCEPT
 {
     wait_for(__lk, __tp - _Clock::now());

libcxx/include/__threading_support

 
 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
 int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);
 
 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
                                __libcpp_timespec_t *__ts);
 
+#ifdef _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT
+_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_condvar_monotonic_timedwait(__libcpp_condvar_t *__cv,
+                                         __libcpp_mutex_t *__m,
+                                         __libcpp_timespec_t *__ts);
+#endif
+
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
 
 // Execute once
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
                           void (*init_routine)());
 

 
 _LIBCPP_HIDE_FROM_ABI inline
 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
                                __libcpp_timespec_t *__ts)
 {
   return pthread_cond_timedwait(__cv, __m, __ts);
 }
 
+#ifdef _LIBCPP_CONDVAR_HAS_MONOTONIC_TIMEDWAIT
+_LIBCPP_HIDE_FROM_ABI inline
+int __libcpp_condvar_monotonic_timedwait(__libcpp_condvar_t *__cv,
+                                         __libcpp_mutex_t *__m,
+                                         __libcpp_timespec_t *__ts)
+{
+  return pthread_cond_clockwait(__cv, __m, CLOCK_MONOTONIC, __ts);
+}
+#endif
+
 _LIBCPP_HIDE_FROM_ABI inline
 int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
 {
   return pthread_cond_destroy(__cv);
 }
 
 // Execute once
 _LIBCPP_HIDE_FROM_ABI inline

 _LIBCPP_HIDE_FROM_ABI inline
 int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
 {
   return cnd_wait(__cv, __m) == thrd_success ? 0 : EINVAL;
 }
 
 _LIBCPP_HIDE_FROM_ABI inline
 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               timespec *__ts)
+                               __libcpp_timespec_t *__ts)
 {
   int __ec = cnd_timedwait(__cv, __m, __ts);
   return __ec == thrd_timedout ? ETIMEDOUT : __ec;
 }
 
 _LIBCPP_HIDE_FROM_ABI inline
 int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
 {