[libc++] Avoid <climits> dependency in <thread>

[joerg]

Summary

The standard guarantees sleep durations of 2^63-1 nanoseconds to work.
Instead of depending on INT64_MAX or ULONGLONG_MAX to exist via the
header pollution, fold the constant directly. That has the additional
positive side effect that it avoids long double arithmetic bugs in GCC.

[• Quuxplusone]

libcxx/include/thread

381

Seems reasonable to me, but I do wonder:
(1) Why does the old code even need to drag in long double? What's wrong with regular double? (This is in generic code where 99% of the time __d will just be plain old std::chrono::seconds or std::chrono::milliseconds, which are denominated in long long.)
(2) What do the relevant unit tests look like?

[joerg]

libcxx/include/thread

381

I think the idea was to avoid loss of precision or the like if possible. I don't think there is a reasonable way to unit test this?

[• Quuxplusone]

Well, seems reasonable to me, even if I personally would use double instead of long double.

If my math is right: If the caller passes in "2^53 + 1 nanoseconds" as a long long and we lose precision by casting it to a double with 53 mantissa bits, we end up waiting for only 2^53 nanoseconds (i.e. the precision loss is on the order of one nanosecond every 104 days).

But anyway this seems fine.

[Mordante]

LGTM!

[Mordante]

Just curious since the header doesn't include <climits> directly. Why is it required? Do to a compilation error?

[joerg]

Yeah, I hit a compilation error somewhere depending on the include error. I forgot the details, this has been sitting around in my tree for while.

[Mordante]

In D99516#2659626, @joerg wrote:

Yeah, I hit a compilation error somewhere depending on the include error. I forgot the details, this has been sitting around in my tree for while.

Thanks for the information.

libcxx/include/thread

 _LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& __ns);
 
 template <class _Rep, class _Period>
 void
 sleep_for(const chrono::duration<_Rep, _Period>& __d)
 {
     if (__d > chrono::duration<_Rep, _Period>::zero())
     {
-#if defined(_LIBCPP_COMPILER_GCC) && (__powerpc__ || __POWERPC__)
-    //  GCC's long double const folding is incomplete for IBM128 long doubles.
-        _LIBCPP_CONSTEXPR chrono::duration<long double> _Max = chrono::duration<long double>(ULLONG_MAX/1000000000ULL) ;
-#else
-        _LIBCPP_CONSTEXPR chrono::duration<long double> _Max = chrono::nanoseconds::max();
-#endif
+        // The standard guarantees a 64bit signed integer resolution for nanoseconds,
+        // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
+        // and issues with long double folding on PowerPC with GCC.
+        _LIBCPP_CONSTEXPR chrono::duration<long double> _Max =
+            chrono::duration<long double>(9223372036.0L);
         chrono::nanoseconds __ns;
         if (__d < _Max)
         {
             __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
             if (__ns < __d)
                 ++__ns;
         }
         else
             __ns = chrono::nanoseconds::max();
         this_thread::sleep_for(__ns);
     }
 }
 
 template <class _Clock, class _Duration>
 void
 sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     mutex __mut;
     condition_variable __cv;
     unique_lock<mutex> __lk(__mut);