123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289 |
- // (C) Copyright 2006-7 Anthony Williams
- // Distributed under the Boost Software License, Version 1.0. (See
- // accompanying file LICENSE_1_0.txt or copy at
- // http://www.boost.org/LICENSE_1_0.txt)
- #define BOOST_THREAD_VERSION 2
- #define BOOST_TEST_MODULE Boost.Threads: shared_mutex_part2 test suite
- #include <boost/test/unit_test.hpp>
- #include <boost/thread/thread.hpp>
- #include <boost/thread/xtime.hpp>
- #include "./util.inl"
- #include "./shared_mutex_locking_thread.hpp"
- #define CHECK_LOCKED_VALUE_EQUAL(mutex_name,value,expected_value) \
- { \
- boost::unique_lock<boost::mutex> lock(mutex_name); \
- BOOST_CHECK_EQUAL(value,expected_value); \
- }
- class simple_upgrade_thread
- {
- boost::shared_mutex& rwm;
- boost::mutex& finish_mutex;
- boost::mutex& unblocked_mutex;
- unsigned& unblocked_count;
- void operator=(simple_upgrade_thread&);
- public:
- simple_upgrade_thread(boost::shared_mutex& rwm_,
- boost::mutex& finish_mutex_,
- boost::mutex& unblocked_mutex_,
- unsigned& unblocked_count_):
- rwm(rwm_),finish_mutex(finish_mutex_),
- unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
- {}
- void operator()()
- {
- boost::upgrade_lock<boost::shared_mutex> lk(rwm);
- {
- boost::unique_lock<boost::mutex> ulk(unblocked_mutex);
- ++unblocked_count;
- }
- boost::unique_lock<boost::mutex> flk(finish_mutex);
- }
- };
- BOOST_AUTO_TEST_CASE(test_only_one_upgrade_lock_permitted)
- {
- unsigned const number_of_threads=2;
- 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::unique_lock<boost::mutex> 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);
- }
- BOOST_AUTO_TEST_CASE(test_can_lock_upgrade_if_currently_locked_shared)
- {
- 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::unique_lock<boost::mutex> 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));
- 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::unique_lock<boost::mutex> 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();
- throw;
- }
- 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);
- }
- BOOST_AUTO_TEST_CASE(test_can_lock_upgrade_to_unique_if_currently_locked_upgrade)
- {
- boost::shared_mutex mtx;
- boost::upgrade_lock<boost::shared_mutex> l(mtx);
- boost::upgrade_to_unique_lock<boost::shared_mutex> ul(l);
- BOOST_CHECK(ul.owns_lock());
- }
- BOOST_AUTO_TEST_CASE(test_if_other_thread_has_write_lock_try_lock_shared_returns_false)
- {
- 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::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_shared();
- BOOST_CHECK(!try_succeeded);
- if(try_succeeded)
- {
- rw_mutex.unlock_shared();
- }
- finish_lock.unlock();
- writer.join();
- }
- BOOST_AUTO_TEST_CASE(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::unique_lock<boost::mutex> 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();
- }
- BOOST_AUTO_TEST_CASE(test_if_no_thread_has_lock_try_lock_shared_returns_true)
- {
- boost::shared_mutex rw_mutex;
- bool const try_succeeded=rw_mutex.try_lock_shared();
- BOOST_CHECK(try_succeeded);
- if(try_succeeded)
- {
- rw_mutex.unlock_shared();
- }
- }
- BOOST_AUTO_TEST_CASE(test_if_no_thread_has_lock_try_lock_upgrade_returns_true)
- {
- boost::shared_mutex rw_mutex;
- bool const try_succeeded=rw_mutex.try_lock_upgrade();
- BOOST_CHECK(try_succeeded);
- if(try_succeeded)
- {
- rw_mutex.unlock_upgrade();
- }
- }
- BOOST_AUTO_TEST_CASE(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::unique_lock<boost::mutex> 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();
- }
- BOOST_AUTO_TEST_CASE(test_if_other_thread_has_shared_lock_try_lock_upgrade_returns_true)
- {
- 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_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_upgrade();
- BOOST_CHECK(try_succeeded);
- if(try_succeeded)
- {
- rw_mutex.unlock_upgrade();
- }
- finish_lock.unlock();
- writer.join();
- }
- BOOST_AUTO_TEST_CASE(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::unique_lock<boost::mutex> 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();
- }
|