[libcxx-commits] [libcxx] r372034 - Revert "Implement std::condition_variable via pthread_cond_clockwait() where available"
Dan Albert via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Sep 16 14:20:32 PDT 2019
Author: danalbert
Date: Mon Sep 16 14:20:32 2019
New Revision: 372034
URL: http://llvm.org/viewvc/llvm-project?rev=372034&view=rev
Log:
Revert "Implement std::condition_variable via pthread_cond_clockwait() where available"
This reverts commit 5e37d7f9ff257ec62d733d3d94b11f03e0fe51ca.
Modified:
libcxx/trunk/include/__config
libcxx/trunk/include/__mutex_base
libcxx/trunk/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
Modified: libcxx/trunk/include/__config
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__config?rev=372034&r1=372033&r2=372034&view=diff
==============================================================================
--- libcxx/trunk/include/__config (original)
+++ libcxx/trunk/include/__config Mon Sep 16 14:20:32 2019
@@ -1087,12 +1087,6 @@ _LIBCPP_FUNC_VIS extern "C" void __sanit
# endif // _LIBCPP_HAS_THREAD_API
#endif // _LIBCPP_HAS_NO_THREADS
-#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
-# if (defined(__ANDROID__) && __ANDROID_API__ >= 30) || _LIBCPP_GLIBC_PREREQ(2, 30)
-# define _LIBCPP_HAS_COND_CLOCKWAIT
-# 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.
Modified: libcxx/trunk/include/__mutex_base
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__mutex_base?rev=372034&r1=372033&r2=372034&view=diff
==============================================================================
--- libcxx/trunk/include/__mutex_base (original)
+++ libcxx/trunk/include/__mutex_base Mon Sep 16 14:20:32 2019
@@ -15,7 +15,6 @@
#include <system_error>
#include <__threading_support>
-#include <time.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
@@ -338,75 +337,23 @@ public:
private:
void __do_timed_wait(unique_lock<mutex>& __lk,
chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
- 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
-template <class _Rep, class _Period>
+template <class _To, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
- is_floating_point<_Rep>::value,
- chrono::nanoseconds
+ chrono::__is_duration<_To>::value,
+ _To
>::type
-__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
+__ceil(chrono::duration<_Rep, _Period> __d)
{
using namespace chrono;
- using __ratio = ratio_divide<_Period, nano>;
- using __ns_rep = nanoseconds::rep;
- _Rep __result_float = __d.count() * __ratio::num / __ratio::den;
-
- _Rep __result_max = numeric_limits<__ns_rep>::max();
- if (__result_float >= __result_max) {
- return nanoseconds::max();
- }
-
- _Rep __result_min = numeric_limits<__ns_rep>::min();
- if (__result_float <= __result_min) {
- return nanoseconds::min();
- }
-
- return nanoseconds(static_cast<__ns_rep>(__result_float));
-}
-
-template <class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
- !is_floating_point<_Rep>::value,
- chrono::nanoseconds
->::type
-__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
-{
- using namespace chrono;
- if (__d.count() == 0) {
- return nanoseconds(0);
- }
-
- using __ratio = ratio_divide<_Period, nano>;
- using __ns_rep = nanoseconds::rep;
- __ns_rep __result_max = std::numeric_limits<__ns_rep>::max();
- if (__d.count() > 0 && __d.count() > __result_max / __ratio::num) {
- return nanoseconds::max();
- }
-
- __ns_rep __result_min = std::numeric_limits<__ns_rep>::min();
- if (__d.count() < 0 && __d.count() < __result_min / __ratio::num) {
- return nanoseconds::min();
- }
-
- __ns_rep __result = __d.count() * __ratio::num / __ratio::den;
- if (__result == 0) {
- return nanoseconds(1);
- }
-
- return nanoseconds(__result);
+ _To __r = duration_cast<_To>(__d);
+ if (__r < __d)
+ ++__r;
+ return __r;
}
#ifndef _LIBCPP_HAS_NO_THREADS
@@ -424,15 +371,7 @@ condition_variable::wait_until(unique_lo
const chrono::time_point<_Clock, _Duration>& __t)
{
using namespace chrono;
- using __clock_tp_ns = time_point<_Clock, nanoseconds>;
-
- typename _Clock::time_point __now = _Clock::now();
- if (__t <= __now)
- return cv_status::timeout;
-
- __clock_tp_ns __t_ns = __clock_tp_ns(__safe_nanosecond_cast(__t.time_since_epoch()));
-
- __do_timed_wait(__lk, __t_ns);
+ wait_for(__lk, __t - _Clock::now());
return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
}
@@ -458,25 +397,15 @@ condition_variable::wait_for(unique_lock
using namespace chrono;
if (__d <= __d.zero())
return cv_status::timeout;
- using __ns_rep = nanoseconds::rep;
+ typedef time_point<system_clock, duration<long double, nano> > __sys_tpf;
+ typedef time_point<system_clock, nanoseconds> __sys_tpi;
+ __sys_tpf _Max = __sys_tpi::max();
steady_clock::time_point __c_now = steady_clock::now();
-
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
- using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
- __ns_rep __now_count_ns = __safe_nanosecond_cast(__c_now.time_since_epoch()).count();
-#else
- using __clock_tp_ns = time_point<system_clock, nanoseconds>;
- __ns_rep __now_count_ns = __safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
-#endif
-
- __ns_rep __d_ns_count = __safe_nanosecond_cast(__d).count();
-
- if (__now_count_ns > numeric_limits<__ns_rep>::max() - __d_ns_count) {
- __do_timed_wait(__lk, __clock_tp_ns::max());
- } else {
- __do_timed_wait(__lk, __clock_tp_ns(nanoseconds(__now_count_ns + __d_ns_count)));
- }
-
+ system_clock::time_point __s_now = system_clock::now();
+ if (_Max - __d > __s_now)
+ __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
+ else
+ __do_timed_wait(__lk, __sys_tpi::max());
return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
cv_status::timeout;
}
@@ -492,46 +421,6 @@ condition_variable::wait_for(unique_lock
_VSTD::move(__pred));
}
-#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
-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;
- 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);
- if (__ec != 0 && __ec != ETIMEDOUT)
- __throw_system_error(__ec, "condition_variable timed_wait failed");
-}
-#endif // _LIBCPP_HAS_COND_CLOCKWAIT
-
-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());
-}
-
#endif // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_END_NAMESPACE_STD
Modified: libcxx/trunk/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp?rev=372034&r1=372033&r2=372034&view=diff
==============================================================================
--- libcxx/trunk/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp (original)
+++ libcxx/trunk/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp Mon Sep 16 14:20:32 2019
@@ -25,12 +25,12 @@
#include "test_macros.h"
-struct TestClock
+struct Clock
{
typedef std::chrono::milliseconds duration;
typedef duration::rep rep;
typedef duration::period period;
- typedef std::chrono::time_point<TestClock> time_point;
+ typedef std::chrono::time_point<Clock> time_point;
static const bool is_steady = true;
static time_point now()
@@ -50,40 +50,35 @@ int test2 = 0;
int runs = 0;
-template <typename Clock>
void f()
{
std::unique_lock<std::mutex> lk(mut);
assert(test2 == 0);
test1 = 1;
cv.notify_one();
- typename Clock::time_point t0 = Clock::now();
- typename Clock::time_point t = t0 + std::chrono::milliseconds(250);
+ Clock::time_point t0 = Clock::now();
+ Clock::time_point t = t0 + Clock::duration(250);
while (test2 == 0 && cv.wait_until(lk, t) == std::cv_status::no_timeout)
;
- typename Clock::time_point t1 = Clock::now();
+ Clock::time_point t1 = Clock::now();
if (runs == 0)
{
- assert(t1 - t0 < std::chrono::milliseconds(250));
+ assert(t1 - t0 < Clock::duration(250));
assert(test2 != 0);
}
else
{
- assert(t1 - t0 - std::chrono::milliseconds(250) < std::chrono::milliseconds(50));
+ assert(t1 - t0 - Clock::duration(250) < Clock::duration(50));
assert(test2 == 0);
}
++runs;
}
-template <typename Clock>
-void run_test()
+int main(int, char**)
{
- runs = 0;
- test1 = 0;
- test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
- std::thread t(f<Clock>);
+ std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
@@ -97,7 +92,7 @@ void run_test()
test2 = 0;
{
std::unique_lock<std::mutex>lk(mut);
- std::thread t(f<Clock>);
+ std::thread t(f);
assert(test1 == 0);
while (test1 == 0)
cv.wait(lk);
@@ -105,12 +100,6 @@ void run_test()
lk.unlock();
t.join();
}
-}
-int main(int, char**)
-{
- run_test<TestClock>();
- run_test<std::chrono::steady_clock>();
- run_test<std::chrono::system_clock>();
- return 0;
+ return 0;
}
More information about the libcxx-commits
mailing list