void test_if_other_thread_has_write_lock_try_lock_upgrade_returns_false()
{
boost::shared_mutex rw_mutex;
boost::mutex finish_mutex;
boost::mutex unblocked_mutex;
unsigned unblocked_count=0;
boost::mutex::scoped_lock finish_lock(finish_mutex);
boost::thread writer(simple_writing_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
boost::this_thread::sleep(boost::posix_time::seconds(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
bool const try_succeeded=rw_mutex.try_lock_upgrade();
BOOST_CHECK(!try_succeeded);
if(try_succeeded)
{
rw_mutex.unlock_upgrade();
}
finish_lock.unlock();
writer.join();
}
void operator()()
{
// acquire lock
lock_type lock(rw_mutex);
// increment count to show we're unblocked
{
boost::mutex::scoped_lock ublock(unblocked_count_mutex);
++unblocked_count;
unblocked_condition.notify_one();
++simultaneous_running_count;
if(simultaneous_running_count>max_simultaneous_running)
{
max_simultaneous_running=simultaneous_running_count;
}
}
// wait to finish
boost::mutex::scoped_lock finish_lock(finish_mutex);
{
boost::mutex::scoped_lock ublock(unblocked_count_mutex);
--simultaneous_running_count;
}
}
void test_can_lock_upgrade_if_currently_locked_shared()
{
typedef hpx::lcos::local::shared_mutex shared_mutex_type;
typedef hpx::lcos::local::mutex mutex_type;
test::thread_group pool;
shared_mutex_type rw_mutex;
unsigned unblocked_count = 0;
unsigned simultaneous_running_count = 0;
unsigned max_simultaneous_running = 0;
mutex_type unblocked_count_mutex;
hpx::lcos::local::condition_variable unblocked_condition;
mutex_type finish_mutex;
boost::unique_lock<mutex_type> finish_lock(finish_mutex);
unsigned const reader_count = 10;
try
{
for(unsigned i = 0; i != reader_count; ++i)
{
pool.create_thread(
test::locking_thread<boost::shared_lock<shared_mutex_type> >(
rw_mutex, unblocked_count, unblocked_count_mutex,
unblocked_condition, finish_mutex,
simultaneous_running_count, max_simultaneous_running
)
);
}
hpx::this_thread::sleep_for(boost::chrono::seconds(1));
pool.create_thread(
test::locking_thread<boost::upgrade_lock<shared_mutex_type> >(
rw_mutex, unblocked_count, unblocked_count_mutex,
unblocked_condition, finish_mutex,
simultaneous_running_count, max_simultaneous_running
)
);
{
boost::unique_lock<mutex_type> lk(unblocked_count_mutex);
while(unblocked_count < (reader_count + 1))
{
unblocked_condition.wait(lk);
}
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,
unblocked_count, reader_count + 1);
finish_lock.unlock();
pool.join_all();
}
catch(...)
{
pool.interrupt_all();
pool.join_all();
HPX_TEST(false);
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,
unblocked_count, reader_count + 1);
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,
max_simultaneous_running, reader_count + 1);
}
