void test_only_one_upgrade_lock_permitted()
{
typedef hpx::lcos::local::shared_mutex shared_mutex_type;
typedef hpx::lcos::local::mutex mutex_type;
unsigned const number_of_threads = 2;
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);
try
{
for( unsigned i = 0; i != number_of_threads; ++i)
{
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
)
);
}
hpx::this_thread::sleep_for(boost::chrono::seconds(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,
unblocked_count, 1u);
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, number_of_threads);
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,
max_simultaneous_running, 1u);
}
void test_unlocking_writer_unblocks_all_readers()
{
boost::thread_group pool;
boost::shared_mutex rw_mutex;
boost::unique_lock<boost::shared_mutex> write_lock(rw_mutex);
unsigned unblocked_count=0;
unsigned simultaneous_running_count=0;
unsigned max_simultaneous_running=0;
boost::mutex unblocked_count_mutex;
boost::condition_variable unblocked_condition;
boost::mutex finish_mutex;
boost::mutex::scoped_lock finish_lock(finish_mutex);
unsigned const reader_count=10;
try
{
for(unsigned i=0;i<reader_count;++i)
{
pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
finish_mutex,simultaneous_running_count,max_simultaneous_running));
}
boost::thread::sleep(delay(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,0U);
write_lock.unlock();
{
boost::mutex::scoped_lock lk(unblocked_count_mutex);
while(unblocked_count<reader_count)
{
unblocked_condition.wait(lk);
}
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,reader_count);
finish_lock.unlock();
pool.join_all();
}
catch(...)
{
pool.interrupt_all();
pool.join_all();
throw;
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,reader_count);
}
void test_timed_lock_shared_succeeds_if_read_lock_held()
{
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 reader(simple_reading_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
boost::this_thread::sleep_for(boost::chrono::seconds(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
boost::chrono::milliseconds const timeout_resolution(50);
bool timed_lock_succeeded=rw_mutex.try_lock_shared_until(timeout);
BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
BOOST_CHECK(timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock_shared();
}
boost::chrono::milliseconds const wait_duration(500);
boost::chrono::steady_clock::time_point const timeout2=boost::chrono::steady_clock::now()+wait_duration;
timed_lock_succeeded=rw_mutex.try_lock_shared_for(wait_duration);
BOOST_CHECK(boost::chrono::steady_clock::now()<timeout2);
BOOST_CHECK(timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock_shared();
}
finish_lock.unlock();
reader.join();
}
void test_timed_lock_shared_succeeds_if_read_lock_held()
{
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 reader(simple_reading_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
boost::thread::sleep(delay(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
boost::system_time const start=boost::get_system_time();
boost::system_time const timeout=start+boost::posix_time::milliseconds(500);
boost::posix_time::milliseconds const timeout_resolution(50);
bool timed_lock_succeeded=rw_mutex.timed_lock_shared(timeout);
BOOST_CHECK(boost::get_system_time()<timeout);
BOOST_CHECK(timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock_shared();
}
boost::posix_time::milliseconds const wait_duration(500);
boost::system_time const timeout2=boost::get_system_time()+wait_duration;
timed_lock_succeeded=rw_mutex.timed_lock_shared(wait_duration);
BOOST_CHECK(boost::get_system_time()<timeout2);
BOOST_CHECK(timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock_shared();
}
finish_lock.unlock();
reader.join();
}
void test_if_other_thread_has_upgrade_lock_try_lock_upgrade_returns_false()
{
typedef hpx::lcos::local::shared_mutex shared_mutex_type;
typedef hpx::lcos::local::mutex mutex_type;
shared_mutex_type rw_mutex;
mutex_type finish_mutex;
mutex_type unblocked_mutex;
unsigned unblocked_count = 0;
boost::unique_lock<mutex_type> finish_lock(finish_mutex);
hpx::thread writer(test::simple_upgrade_thread(
rw_mutex, finish_mutex, unblocked_mutex, unblocked_count));
hpx::this_thread::sleep_for(boost::chrono::seconds(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,
unblocked_count, 1u);
bool const try_succeeded = rw_mutex.try_lock_upgrade();
HPX_TEST(!try_succeeded);
if (try_succeeded)
{
rw_mutex.unlock_upgrade();
}
finish_lock.unlock();
writer.join();
}
void test_timed_lock_times_out_if_write_lock_held()
{
boost::shared_mutex rw_mutex;
boost::mutex finish_mutex;
boost::mutex unblocked_mutex;
unsigned unblocked_count=0;
boost::unique_lock<boost::mutex> finish_lock(finish_mutex);
boost::thread writer(simple_writing_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
boost::thread::sleep(delay(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
boost::system_time const start=boost::get_system_time();
boost::system_time const timeout=start+boost::posix_time::milliseconds(500);
boost::posix_time::milliseconds const timeout_resolution(50);
bool timed_lock_succeeded=rw_mutex.timed_lock(timeout);
BOOST_CHECK((timeout-timeout_resolution)<boost::get_system_time());
BOOST_CHECK(!timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock();
}
boost::posix_time::milliseconds const wait_duration(500);
boost::system_time const timeout2=boost::get_system_time()+wait_duration;
timed_lock_succeeded=rw_mutex.timed_lock(wait_duration);
BOOST_CHECK((timeout2-timeout_resolution)<boost::get_system_time());
BOOST_CHECK(!timed_lock_succeeded);
if(timed_lock_succeeded)
{
rw_mutex.unlock();
}
finish_lock.unlock();
writer.join();
}
void test_multiple_readers()
{
unsigned const number_of_threads=10;
boost::thread_group pool;
boost::shared_mutex rw_mutex;
unsigned unblocked_count=0;
unsigned simultaneous_running_count=0;
unsigned max_simultaneous_running=0;
boost::mutex unblocked_count_mutex;
boost::condition_variable unblocked_condition;
boost::mutex finish_mutex;
boost::mutex::scoped_lock finish_lock(finish_mutex);
try
{
for(unsigned i=0;i<number_of_threads;++i)
{
pool.create_thread(locking_thread<boost::shared_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
finish_mutex,simultaneous_running_count,max_simultaneous_running));
}
{
boost::mutex::scoped_lock lk(unblocked_count_mutex);
while(unblocked_count<number_of_threads)
{
unblocked_condition.wait(lk);
}
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);
finish_lock.unlock();
pool.join_all();
}
catch(...)
{
pool.interrupt_all();
pool.join_all();
throw;
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,number_of_threads);
}
void test_only_one_upgrade_lock_permitted()
{
unsigned const number_of_threads=10;
boost::thread_group pool;
boost::shared_mutex rw_mutex;
unsigned unblocked_count=0;
unsigned simultaneous_running_count=0;
unsigned max_simultaneous_running=0;
boost::mutex unblocked_count_mutex;
boost::condition_variable unblocked_condition;
boost::mutex finish_mutex;
boost::mutex::scoped_lock finish_lock(finish_mutex);
try
{
for(unsigned i=0;i<number_of_threads;++i)
{
pool.create_thread(locking_thread<boost::upgrade_lock<boost::shared_mutex> >(rw_mutex,unblocked_count,unblocked_count_mutex,unblocked_condition,
finish_mutex,simultaneous_running_count,max_simultaneous_running));
}
boost::thread::sleep(delay(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,1U);
finish_lock.unlock();
pool.join_all();
}
catch(...)
{
pool.interrupt_all();
pool.join_all();
throw;
}
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,unblocked_count,number_of_threads);
CHECK_LOCKED_VALUE_EQUAL(unblocked_count_mutex,max_simultaneous_running,1u);
}
void test_if_other_thread_has_upgrade_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_upgrade_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 test_if_other_thread_has_shared_lock_try_lock_shared_returns_true()
{
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_reading_thread(rw_mutex,finish_mutex,unblocked_mutex,unblocked_count));
boost::thread::sleep(delay(1));
CHECK_LOCKED_VALUE_EQUAL(unblocked_mutex,unblocked_count,1u);
bool const try_succeeded=rw_mutex.try_lock_shared();
BOOST_CHECK(try_succeeded);
if(try_succeeded)
{
rw_mutex.unlock_shared();
}
finish_lock.unlock();
writer.join();
}
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);
}