diff mbox

fix libstdc++/57641

Message ID CAH6eHdRO5yOveeFxQqh_QrhALb8WkiUDm+jcM+8EKXg8Kw9urw@mail.gmail.com
State New
Headers show

Commit Message

Jonathan Wakely Oct. 7, 2013, 11:22 p.m. UTC 
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 <jwakely.gcc@gmail.com>
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 mbox

Patch

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 );
+}