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