On 18 June 2013 23:55, Jonathan Wakely wrote:
> Instead of fixing the bug three times I refactored the try_lock_xxx
> functions into a mixin template and used that in the various timed
> mutexes.
>
> PR libstdc++/57641
> * include/std/mutex (timed_mutex, recursive_timed_mutex): Move common
> functionality to new __timed_mutex_impl mixin. Overload try_lock_until
> to handle conversion between different clocks. Replace constrained
> __try_lock_for_impl overloads with conditional increment.
> * include/std/shared_mutex (shared_mutex::_Mutex): Use the new mixin.
> * testsuite/30_threads/timed_mutex/try_lock_until/57641.cc: New.
>
> Tested x86_64-linux, committed to trunk.
I've committed a less invasive version of this patch (without the
refactoring to add a new base class) to the 4.8 branch. Tested
x86_64-linux.
PR libstdc++/57641
* include/std/mutex (timed_mutex, recursive_timed_mutex): Add
overloaded _M_try_lock_until to handle conversion between different
clocks. Replace constrained __try_lock_for_impl overloads with
conditional increment.
* testsuite/30_threads/timed_mutex/try_lock_until/57641.cc: New.
commit b28b4820d7a76e58dc764a9bfe978c657386991b
Author: Jonathan Wakely <[email protected]>
Date: Mon Oct 7 10:13:00 2013 +0100
PR libstdc++/57641
* include/std/mutex (timed_mutex, recursive_timed_mutex): Add
overloaded _M_try_lock_until to handle conversion between different
clocks. Replace constrained __try_lock_for_impl overloads with
conditional increment.
* testsuite/30_threads/timed_mutex/try_lock_until/57641.cc: New.
diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex
index 67f3418..3093d9a 100644
--- a/libstdc++-v3/include/std/mutex
+++ b/libstdc++-v3/include/std/mutex
@@ -237,25 +237,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template <class _Rep, class _Period>
bool
try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
- { return __try_lock_for_impl(__rtime); }
+ { return _M_try_lock_for(__rtime); }
template <class _Clock, class _Duration>
bool
try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
- {
- chrono::time_point<_Clock, chrono::seconds> __s =
- chrono::time_point_cast<chrono::seconds>(__atime);
-
- chrono::nanoseconds __ns =
- chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
-
- __gthread_time_t __ts = {
- static_cast<std::time_t>(__s.time_since_epoch().count()),
- static_cast<long>(__ns.count())
- };
-
- return !__gthread_mutex_timedlock(&_M_mutex, &__ts);
- }
+ { return _M_try_lock_until(__atime); }
void
unlock()
@@ -270,26 +257,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private:
template<typename _Rep, typename _Period>
- typename enable_if<
- ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
- __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
+ bool
+ _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
{
- __clock_t::time_point __atime = __clock_t::now()
- + chrono::duration_cast<__clock_t::duration>(__rtime);
+ auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
+ if (ratio_greater<__clock_t::period, _Period>())
+ ++__rt;
- return try_lock_until(__atime);
+ return _M_try_lock_until(__clock_t::now() + __rt);
}
- template <typename _Rep, typename _Period>
- typename enable_if<
- !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
- __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
+ template<typename _Duration>
+ bool
+ _M_try_lock_until(const chrono::time_point<__clock_t,
+ _Duration>& __atime)
{
- __clock_t::time_point __atime = __clock_t::now()
- + ++chrono::duration_cast<__clock_t::duration>(__rtime);
+ chrono::time_point<__clock_t, chrono::seconds> __s =
+ chrono::time_point_cast<chrono::seconds>(__atime);
+
+ chrono::nanoseconds __ns =
+ chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
+
+ __gthread_time_t __ts = {
+ static_cast<std::time_t>(__s.time_since_epoch().count()),
+ static_cast<long>(__ns.count())
+ };
- return try_lock_until(__atime);
+ return !__gthread_mutex_timedlock(native_handle(), &__ts);
}
+
+ template<typename _Clock, typename _Duration>
+ bool
+ _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+ { return _M_try_lock_for(__atime - _Clock::now()); }
};
/// recursive_timed_mutex
@@ -330,25 +330,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template <class _Rep, class _Period>
bool
try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
- { return __try_lock_for_impl(__rtime); }
+ { return _M_try_lock_for(__rtime); }
template <class _Clock, class _Duration>
bool
try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
- {
- chrono::time_point<_Clock, chrono::seconds> __s =
- chrono::time_point_cast<chrono::seconds>(__atime);
-
- chrono::nanoseconds __ns =
- chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
-
- __gthread_time_t __ts = {
- static_cast<std::time_t>(__s.time_since_epoch().count()),
- static_cast<long>(__ns.count())
- };
-
- return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts);
- }
+ { return _M_try_lock_until(__atime); }
void
unlock()
@@ -363,26 +350,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private:
template<typename _Rep, typename _Period>
- typename enable_if<
- ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
- __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
+ bool
+ _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
{
- __clock_t::time_point __atime = __clock_t::now()
- + chrono::duration_cast<__clock_t::duration>(__rtime);
+ auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
+ if (ratio_greater<__clock_t::period, _Period>())
+ ++__rt;
- return try_lock_until(__atime);
+ return _M_try_lock_until(__clock_t::now() + __rt);
}
- template <typename _Rep, typename _Period>
- typename enable_if<
- !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
- __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
+ template<typename _Duration>
+ bool
+ _M_try_lock_until(const chrono::time_point<__clock_t,
+ _Duration>& __atime)
{
- __clock_t::time_point __atime = __clock_t::now()
- + ++chrono::duration_cast<__clock_t::duration>(__rtime);
+ chrono::time_point<__clock_t, chrono::seconds> __s =
+ chrono::time_point_cast<chrono::seconds>(__atime);
+
+ chrono::nanoseconds __ns =
+ chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
+
+ __gthread_time_t __ts = {
+ static_cast<std::time_t>(__s.time_since_epoch().count()),
+ static_cast<long>(__ns.count())
+ };
- return try_lock_until(__atime);
+ return !__gthread_mutex_timedlock(native_handle(), &__ts);
}
+
+ template<typename _Clock, typename _Duration>
+ bool
+ _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
+ { return _M_try_lock_for(__atime - _Clock::now()); }
};
#endif
#endif // _GLIBCXX_HAS_GTHREADS
diff --git
a/libstdc++-v3/testsuite/30_threads/timed_mutex/try_lock_until/57641.cc
b/libstdc++-v3/testsuite/30_threads/timed_mutex/try_lock_until/57641.cc
new file mode 100644
index 0000000..94fe5b3
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/timed_mutex/try_lock_until/57641.cc
@@ -0,0 +1,69 @@
+// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-gnu*
*-*-solaris* *-*-cygwin *-*-darwin* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++0x -pthread" { target *-*-freebsd* *-*-netbsd*
*-*-linux* *-*-gnu* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++0x -pthreads" { target *-*-solaris* } }
+// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
+// { dg-require-cstdint "" }
+// { dg-require-gthreads-timed "" }
+
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <mutex>
+#include <chrono>
+#include <thread>
+#include <testsuite_hooks.h>
+
+// PR libstdc++/57641
+
+namespace C = std::chrono;
+
+// custom clock with epoch 10s before system_clock's
+struct clock
+{
+ typedef C::system_clock::rep rep;
+ typedef C::system_clock::period period;
+ typedef C::system_clock::duration duration;
+ typedef C::time_point<clock> time_point;
+ static constexpr bool is_steady = C::system_clock::is_steady;
+
+ static time_point
+ now()
+ {
+ auto sys_time = C::system_clock::now().time_since_epoch();
+ return time_point(sys_time + C::seconds(10));
+ }
+};
+
+std::timed_mutex mx;
+bool test = false;
+
+void f()
+{
+ test = mx.try_lock_until(clock::now() + C::milliseconds(1));
+}
+
+int main()
+{
+ bool test = false;
+ std::lock_guard<std::timed_mutex> l(mx);
+ auto start = C::system_clock::now();
+ std::thread t(f);
+ t.join();
+ auto stop = C::system_clock::now();
+ VERIFY( (stop - start) < C::seconds(9) );
+ VERIFY( !test );
+}
