Boost logo

Boost :

From: Peter Dimov (pdimov_at_[hidden])
Date: 2004-07-06 04:47:11


Howard Hinnant wrote:
>
> So in:
>
> void f(read_write_mutex m)
> {
> read_write_mutex::read_lock r(m);
>
> int y = x;
>
> if (...)
> {
> read_write_mutex::write_lock w(r); //lock promotion
>
> what would happen here if two threads entered f and tried to construct
> w simultaneously?
>
> My take, depending upon how the w(r) constructor is implemented, is
> either:
>
> 1. deadlock.
> 2. one thread blocks and one thread gets the lock.
>
> Imho choice 1 is a buggy implementation of the w(r) constructor. And
> choice 2 results in the assert(x==y) possibly firing.
>
> I believe choice 2 is the only reasonable path.

Both choices are buggy.

3. One thread gets the lock, the other throws lock_error.

is the only reasonable implementation of this operation, if it is provided.

> And I also believe
> that the syntax above might lull a code reader into believing that
> assert(x==y) should always be true.

As it will be. There is no point in having the syntax otherwise, as the
statement would have no reliable postconditions.

> And therefore I think the
> following (more explicit) syntax is superior:
>
> void f(read_write_mutex m)
> {
> read_write_mutex::read_lock r(m);
>
> int y = x;
>
> if (...)
> {
> r.unlock();
> read_write_mutex::write_lock w(m);

This syntax is already available, and it does what it's supposed to do, but
it's not the same as "promotion", which is atomic.

I have to admit that I'm not convinced that unconditional promotion is
useful, and I have trouble coming up with use cases for conditional
promotion, too.


Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk