[libcxx] Threading support: Attempt to externalize system_clock::now() and steady_clock::now() implementations

[rmaprath]

Summary

These implementations depend heavily on the underlying platform. It would be good to put them behind a porting function within the threading API as quite a bit of threading functionality depend on the clocks.

The steady_clock::now() implementation was difficult to pluck out for __APPLE__ because it uses some static functions within the library sources.

I have tested these changes on linux, I will test them on Windows and Mac before committing (if this gets approved).

[rmaprath]

Re-based.

[rmaprath]

Ping?

[EricWF]

I really don't like this change (and D29757) because they start to include a ton of extra headers, and because they lift complex configuration logic into what should be a very simple header.
These functions are much better suited to being define out-of-line for a number of reasons.

Is there another way we can allow "external implementations" of these functions without lifting everything into a header?

[rmaprath]

Different approach: Externalize these functions only for the external-thread-api library variant.

(Similar to D29757)

[rmaprath]

Fixed minor omission.

[rmaprath]

@EricWF: Ping?

[ed]

Worth mentioning: the latest version of macOS now supports clock_gettime(). Maybe better to leave the code as is and simply axe the Mach time code at some point in the future?

[jroelofs]

In D29818#700949, @ed wrote:

Worth mentioning: the latest version of macOS now supports clock_gettime(). Maybe better to leave the code as is and simply axe the Mach time code at some point in the future?

Supporting only the latest and greatest is unfriendly to folks who are stuck on particular versions...

[EricWF]

I really dislike that __libcpp_clock_monotonic and __libcpp_clock_realtime are never declared, and are expected to be magically defined by the external threading header.
This makes the configuration seem incorrect and unused.

Also the previous threading support changes were beneficial to libc++ because they cleaned up and centralized the threading interface, making it easier to port libc++ to different
threading environments. This change has no such benefit.

Why should libc++ upstream this ARM specific configuration need?

[rmaprath]

Hi @EricWF

Apologies for the delay in replying to this.

In D29818#711795, @EricWF wrote:

I really dislike that __libcpp_clock_monotonic and __libcpp_clock_realtime are never declared, and are expected to be magically defined by the external threading header.
This makes the configuration seem incorrect and unused.

This I can address by conditionally declaring these functions in the __threading_support header. But I think the the following assessment is not right:

Also the previous threading support changes were beneficial to libc++ because they cleaned up and centralized the threading interface, making it easier to port libc++ to different
threading environments. This change has no such benefit.

Why should libc++ upstream this ARM specific configuration need?

Currently chrono.cpp depends on more than what a standard C library provides (clock_gettime() is specific to Unix, it is not part of the C standard), so this is about general portability of libc++ and not ARM specific.

Anyone porting libc++ into a bare-metal (or RTOS) environment will have to deal with this, so it would make sense to provide an external API for this? Of course, the approach proposed in this patch might not be the only way (or the best way) to do it.

WDYT?

/ Asiri

src/chrono.cpp

 //===------------------------- chrono.cpp ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "chrono"
 #include "cerrno"        // errno
 #include "system_error"  // __throw_system_error
 #include <time.h>        // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
+#include "__threading_support"
 
 #if (__APPLE__)
 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
 #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
 #define _LIBCXX_USE_CLOCK_GETTIME
 #endif
 #elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
 #if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000

 #if !defined(CLOCK_REALTIME) || !defined(_LIBCXX_USE_CLOCK_GETTIME)
 #include <sys/time.h>        // for gettimeofday and timeval
 #endif // !defined(CLOCK_REALTIME)
 #endif // defined(_LIBCPP_WIN32API)
 
 #if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 #if __APPLE__
 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
-#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
+#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC) && \
+      !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
 #error "Monotonic clock not implemented"
 #endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace chrono
 {
 
 // system_clock
 
 const bool system_clock::is_steady;
 
 system_clock::time_point
 system_clock::now() _NOEXCEPT
 {
-#if defined(_LIBCPP_WIN32API)
+#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
+    struct timespec tp;
+    if (0 != __libcpp_clock_realtime(&tp))
+        __throw_system_error(errno, "__libcpp_clock_realtime() failed");
+    return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
+#elif defined(_LIBCPP_WIN32API)
   // FILETIME is in 100ns units
   using filetime_duration =
       _VSTD::chrono::duration<__int64,
                               _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
                                                     nanoseconds::period>>;
 
   // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
   static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};
 
   FILETIME ft;
 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   GetSystemTimePreciseAsFileTime(&ft);
 #else
   GetSystemTimeAsFileTime(&ft);
 #endif
 #else
   GetSystemTimeAsFileTime(&ft);
 #endif
 
   filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) |
                        static_cast<__int64>(ft.dwLowDateTime)};
   return time_point(duration_cast<duration>(d - nt_to_unix_epoch));
-#else
-#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
+
+#elif defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
     struct timespec tp;
     if (0 != clock_gettime(CLOCK_REALTIME, &tp))
         __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
     return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
 #else
     timeval tv;
     gettimeofday(&tv, 0);
     return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
 #endif // _LIBCXX_USE_CLOCK_GETTIME && CLOCK_REALTIME
-#endif
 }
 
 time_t
 system_clock::to_time_t(const time_point& t) _NOEXCEPT
 {
     return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
 }
 
 system_clock::time_point
 system_clock::from_time_t(time_t t) _NOEXCEPT
 {
     return system_clock::time_point(seconds(t));
 }
 
 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
 // steady_clock
 //
 // Warning:  If this is not truly steady, then it is non-conforming.  It is
 //  better for it to not exist and have the rest of libc++ use system_clock
 //  instead.
 
 const bool steady_clock::is_steady;
 
-#if defined(__APPLE__)
+#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
+
+steady_clock::time_point
+steady_clock::now() _NOEXCEPT
+{
+    struct timespec tp;
+    if (0 != __libcpp_clock_monotonic(&tp))
+        __throw_system_error(errno, "__libcpp_clock_monotonic() failed");
+    return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
+}
+
+#elif defined(__APPLE__)
 
 // Darwin libc versions >= 1133 provide ns precision via CLOCK_UPTIME_RAW
 #if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
 steady_clock::time_point
 steady_clock::now() _NOEXCEPT
 {
     struct timespec tp;
     if (0 != clock_gettime(CLOCK_UPTIME_RAW, &tp))