This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [patch] Fix shared_timed_mutex::try_lock_until() et al


On 10/04/15 02:16 +0200, Torvald Riegel wrote:
On Wed, 2015-04-08 at 20:38 +0100, Jonathan Wakely wrote:
On 08/04/15 20:11 +0100, Jonathan Wakely wrote:
>We can get rid of the _Mutex type then, and just use std::mutex,
>and that also means we can provide the timed locking functions
>even when !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK).
>
>And so maybe we should use this fallback implementation instead of
the
>pthread_rwlock_t one when !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK),
>so that they have a complete std::shared_timed_mutex (this applies
>to at least Darwin, not sure which other targets).

Here's a further patch to do that (which really needs to go into
5.0 too, so we don't switch Darwin to the new pthread_rwlock_t
version and then have to swtich it back again in 6.0).

I understand why a mutex with timeouts isn't required anymore, but
why do you now add it to the USE_PTHREAD_RWLOCK_T condition?  If
pthread_rwlock_t is available, why would we need a normal mutex with
timeouts?

Darwin and HPUX support pthread_rwlock_t but not the timed lock
functions, see https://gcc.gnu.org/PR64847 and (part of)
https://gcc.gnu.org/PR64368 which were "fixed" by
https://gcc.gnu.org/r220161 which just disables the timed lock
functions on those targets, using #if _GTHREAD_USE_MUTEX_TIMEDLOCK.

That means Darwin and HPUX have an incomplete shared_timed_mutex that
doesn't support the timed functions (i.e. what might get added to
C++17 as std::shared_mutex).

The patch below gives Darwin and HPUX a fully conforming (albeit
slower) shared_timed_mutex, by ensuring we don't use pthread_rwlock_t
for targets that can't use timed functions with pthread_rwlock_t.

If std::shared_mutex is added to the standard we could use
pthread_rwlock_t for that even on Darwin and HPUX, because it provides
everything needed for a non-timed std::shared_mutex.

For example, this chunk here (and others too):

diff --git a/libstdc++-v3/include/std/shared_mutex b/libstdc
++-v3/include/std/shared_mutex
index 7f26465..351a4f6 100644
--- a/libstdc++-v3/include/std/shared_mutex
+++ b/libstdc++-v3/include/std/shared_mutex
@@ -57,7 +57,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   /// shared_timed_mutex
   class shared_timed_mutex
   {
-#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_T
+#if defined(_GLIBCXX_USE_PTHREAD_RWLOCK_T) &&
_GTHREAD_USE_MUTEX_TIMEDLOCK
     typedef chrono::system_clock       __clock_t;

 #ifdef PTHREAD_RWLOCK_INITIALIZER



Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]