From: Howard Hinnant (hinnant_at_[hidden])
Date: 2007-11-14 16:41:12
On Nov 14, 2007, at 3:53 PM, Preston A. Elder wrote:
> Is there any plan to implement something like this:
>
> http://www.neuromancy.net/fisheye/browse/mantra/trunk/Mantra-I/mantra/
> utils/shared_mutex_views.h?r=435
>
> So that a shared mutex can be operated like a normal mutex, including
> scoped_lock behavior, and you can choose whether that scoped_lock
> behavior should be to acquire an exclusive, a shared, or an upgrade
> lock?
>
> The idea being:
>
> // somewhere else
> shared_mutex smtx;
>
> // Where I need it:
>
> shared_mutex_view smv(smtx);
> shared_mutex_view::scoped_lock sl(smv);
> // ...
>
> // OR:
> exclusive_mutex_view smv(smtx);
> exclusive_mutex_view::scoped_lock sl(smv);
>
> Right now, shared_mutex only has primitives, and cannot be used with
> things like scoped_lock (aka. unique_lock). Additionally, it cannot
> be
> used as a condition, despite the condition framework. These views
> would
> facilitate that, however I'll admit, I've not thought of all the
> implications of such things.
I'm not sure I see the purpose of:
> exclusive_mutex_view smv(smtx);
> exclusive_mutex_view::scoped_lock sl(smv);
because actually unique_lock<shared_mutex> should work just fine (and
has semantics similar to what you indicate for exclusive_mutex_view).
And condition_variable_any::wait works with unique_lock<shared_mutex>
just fine as well. That covers exclusive locking for shared_mutex.
For shared locking what you have for shared_mutex_view is very similar
to the shared_lock<Mutex> template proposed here:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html#shared_mutex
Differences include:
shared_mutex_view works only for shared_mutex. shared_lock works for
any type supporting the shared_mutex interface (such as a user-written
interruptible_shared_mutex).
It is easier (syntactically) to convert ownership modes using lock
conversion syntax. For example:
upgrade_mutex mut;
unique_lock<upgrade_mutex> lk(mut);
// mut exclusive locked here
shared_lock<upgrade_mutex> slk(move(lk));
// mut share locked here
I.e. the locks provide the "homogenized view", and add the ability to
move and convert the mutex ownership, also with a homogenized syntax.
The homogenized syntax for moving and converting mutex ownership
enables extremely simple implementations of "generic lock conversion
algorithms" (such as transfer_lock also in N2406).
And all of the lock/mutex combinations work with
condition_variable_any (which only requires lock/unlock and everything
has that).
shared_mutex mut;
condition_variable_any cv;
void wait_in_shared_ownership_mode()
{
shared_lock<shared_mutex> shared_lk(mut);
// mut is now shared-locked
// ...
while (not_ready_to_proceed())
cv.wait(shared_lk); // shared-lock released while waiting
// mut is now shared-locked
// ...
} // mut is now unlocked
void wait_in_unique_ownership_mode()
{
unique_lock<shared_mutex> lk(mut);
// mut is now unique-locked
// ...
while (not_ready_to_proceed())
cv.wait(lk); // unique-lock released while waiting
// mut is now unique-locked
// ...
} // mut is now unlocked
upgrade_mutex mut2;
void wait_with_transfer_from_unique_to_shared_ownership()
{
upgrade_lock<upgrade_mutex> slk(mut2);
// mut2 is now share-locked
// ...
if (I_need_to()) {
transfer_lock<unique_lock<upgrade_mutex>,
upgrade_lock<upgrade_mutex>> lk(slk);
// mut2 is now unique-locked
// ...
while (not_ready_to_proceed())
cv.wait(lk); // mut2 share-locked while waiting
// mut2 is now unique-locked
// ...
}
// mut2 is now share-locked
// ...
} // mut2 is now unlocked
-Howard