Fix shared_timed_mutex::try_lock_until() et al

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).

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?

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

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
>

On Fri, 2015-04-10 at 09:37 +0100, Jonathan Wakely wrote:
> 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.

Ah, right.  I was confused by the name, thinking those targets don't
support pthread_mutex_timedlock, not pthread_rwlock_timedrdlock etc.

On 10/04/15 11:56 +0200, Torvald Riegel wrote:
>Ah, right.  I was confused by the name, thinking those targets don't
>support pthread_mutex_timedlock, not pthread_rwlock_timedrdlock etc.

The macro actually relates to the _POSIX_TIMEOUTS macro, but was
originally added to check for pthread_mutex_timedlock support, hence
its name. Maybe a better name would be _GLIBCXX_USE_MUTEX_TIMEOUTS.

Both pthread_mutex_timedlock and pthread_rwlock_timed??lock were
originally part of the POSIX Timeouts option, so on older POSIX
systems they are only available when _POSIX_TIMEOUTS is defined.
(They are part of the base spec in the current POSIX standard, but
Darwin and HPUX don't implement that and still treat them as
optional.)