diff --git a/example/shared_monitor.cpp b/example/shared_monitor.cpp new file mode 100644 index 00000000..64932ff8 --- /dev/null +++ b/example/shared_monitor.cpp @@ -0,0 +1,136 @@ +// Copyright (C) 2012 Vicente J. Botet Escriba +// +// 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) + +#include +#include +#include +#include +#include + +#include +#include + +#define EXCLUSIVE 1 +#define SHARED 2 + +#define MODE SHARED + +class A +{ +#if MODE == EXCLUSIVE + typedef boost::mutex mutex_type; +#elif MODE == SHARED + typedef boost::shared_mutex mutex_type; +#else +#error MODE not set +#endif + typedef std::vector C; + mutable mutex_type mut_; + C data_; +public: + A() : data_(10000000) {} + A(const A& a); + A& operator=(const A& a); + + void compute(const A& x, const A& y); +}; + +A::A(const A& a) +{ +#if MODE == EXCLUSIVE + boost::unique_lock lk(a.mut_); +#elif MODE == SHARED + boost::shared_lock lk(a.mut_); +#else +#error MODE not set +#endif + data_ = a.data_; +} + +A& +A::operator=(const A& a) +{ + if (this != &a) + { + boost::unique_lock lk1(mut_, boost::defer_lock); +#if MODE == EXCLUSIVE + boost::unique_lock lk2(a.mut_, boost::defer_lock); +#elif MODE == SHARED + boost::shared_lock lk2(a.mut_, boost::defer_lock); +#else +#error MODE not set +#endif + boost::lock(lk1, lk2); + data_ = a.data_; + } + return *this; +} + +void +A::compute(const A& x, const A& y) +{ + boost::unique_lock lk1(mut_, boost::defer_lock); +#if MODE == EXCLUSIVE + boost::unique_lock lk2(x.mut_, boost::defer_lock); + boost::unique_lock lk3(y.mut_, boost::defer_lock); +#elif MODE == SHARED + boost::shared_lock lk2(x.mut_, boost::defer_lock); + boost::shared_lock lk3(y.mut_, boost::defer_lock); +#else +#error MODE not set +#endif + boost::lock(lk1, lk2, lk3); + assert(data_.size() == x.data_.size()); + assert(data_.size() == y.data_.size()); + for (unsigned i = 0; i < data_.size(); ++i) + data_[i] = (x.data_[i] + y.data_[i]) / 2; +} + +A a1; +A a2; + +void test_s() +{ + A la3 = a1; + for (int i = 0; i < 150; ++i) + { + la3.compute(a1, a2); + } +} + +void test_w() +{ + A la3 = a1; + for (int i = 0; i < 10; ++i) + { + la3.compute(a1, a2); + a1 = la3; + a2 = la3; +// boost::this_thread::sleep_for(boost::chrono::seconds(1)); + } +} + +int main() +{ + typedef boost::chrono::high_resolution_clock Clock; + typedef boost::chrono::duration sec; + Clock::time_point t0 = Clock::now(); + std::vector v; + boost::thread thw(test_w); + v.push_back(&thw); + boost::thread thr0(test_w); + v.push_back(&thr0); + boost::thread thr1(test_w); + v.push_back(&thr1); + boost::thread thr2(test_w); + v.push_back(&thr2); + boost::thread thr3(test_w); + v.push_back(&thr3); + for (int i = 0; i < v.size(); ++i) + v[i]->join(); + Clock::time_point t1 = Clock::now(); + std::cout << sec(t1-t0) << '\n'; + return 0; +} diff --git a/example/shared_mutex.cpp b/example/shared_mutex.cpp new file mode 100644 index 00000000..60aadc06 --- /dev/null +++ b/example/shared_mutex.cpp @@ -0,0 +1,722 @@ +// Copyright (C) 2012 Vicente J. Botet Escriba +// +// 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_SHARED_MUTEX_PROVIDES_UPWARDS_CONVERSION +#define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION + +#include +#include +#include +#include +#include + +#include +#include + +enum {reading, writing}; +int state = reading; + +#if 1 + +boost::mutex& +cout_mut() +{ + static boost::mutex m; + return m; +} + +void +print(const char* tag, unsigned count, char ch) +{ + boost::lock_guard _(cout_mut()); + std::cout << tag << count << ch; +} + +#elif 0 + +boost::recursive_mutex& +cout_mut() +{ + static boost::recursive_mutex m; + return m; +} + +void print() {} + +template +void +print(const A0& a0, const Args& ...args) +{ + boost::lock_guard _(cout_mut()); + std::cout << a0; + print(args...); +} + +#else + +template +void +print(const A0&, const A1& a1, const A2&) +{ + assert(a1 > 10000); +} + +#endif + +namespace S +{ + +boost::shared_mutex mut; + +void reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock_shared(); + assert(state == reading); + ++count; + mut.unlock_shared(); + } + print("reader = ", count, '\n'); +} + +void writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock(); + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + print("writer = ", count, '\n'); +} + +void try_reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared()) + { + assert(state == reading); + ++count; + mut.unlock_shared(); + } + } + print("try_reader = ", count, '\n'); +} + +void try_writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock()) + { + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + } + print("try_writer = ", count, '\n'); +} + +void try_for_reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + ++count; + mut.unlock_shared(); + } + } + print("try_for_reader = ", count, '\n'); +} + +void try_for_writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_for(boost::chrono::microseconds(5))) + { + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + } + print("try_for_writer = ", count, '\n'); +} + +void +test_shared_mutex() +{ + { + boost::thread t1(reader); + boost::thread t2(writer); + boost::thread t3(reader); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(try_reader); + boost::thread t2(try_writer); + boost::thread t3(try_reader); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(try_for_reader); + boost::thread t2(try_for_writer); + boost::thread t3(try_for_reader); + t1.join(); + t2.join(); + t3.join(); + } +} + +} + +namespace U +{ + +boost::upgrade_mutex mut; + +void reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock_shared(); + assert(state == reading); + ++count; + mut.unlock_shared(); + } + print("reader = ", count, '\n'); +} + +void writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock(); + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + print("writer = ", count, '\n'); +} + +void try_reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared()) + { + assert(state == reading); + ++count; + mut.unlock_shared(); + } + } + print("try_reader = ", count, '\n'); +} + +void try_writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock()) + { + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + } + print("try_writer = ", count, '\n'); +} + +void try_for_reader() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + ++count; + mut.unlock_shared(); + } + } + print("try_for_reader = ", count, '\n'); +} + +void try_for_writer() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_for(boost::chrono::microseconds(5))) + { + state = writing; + assert(state == writing); + state = reading; + ++count; + mut.unlock(); + } + } + print("try_for_writer = ", count, '\n'); +} + +void upgradable() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock_upgrade(); + assert(state == reading); + ++count; + mut.unlock_upgrade(); + } + print("upgradable = ", count, '\n'); +} + +void try_upgradable() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_upgrade()) + { + assert(state == reading); + ++count; + mut.unlock_upgrade(); + } + } + print("try_upgradable = ", count, '\n'); +} + +void try_for_upgradable() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + ++count; + mut.unlock_upgrade(); + } + } + print("try_for_upgradable = ", count, '\n'); +} + +void clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock_shared(); + assert(state == reading); + if (mut.try_unlock_shared_and_lock()) + { + state = writing; + } + else if (mut.try_unlock_shared_and_lock_upgrade()) + { + assert(state == reading); + mut.unlock_upgrade_and_lock(); + state = writing; + } + else + { + mut.unlock_shared(); + continue; + } + assert(state == writing); + state = reading; + mut.unlock_and_lock_upgrade(); + assert(state == reading); + mut.unlock_upgrade_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + print("clockwise = ", count, '\n'); +} + +void counter_clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + mut.lock_upgrade(); + assert(state == reading); + mut.unlock_upgrade_and_lock(); + assert(state == reading); + state = writing; + assert(state == writing); + state = reading; + mut.unlock_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + print("counter_clockwise = ", count, '\n'); +} + +void try_clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared()) + { + assert(state == reading); + if (mut.try_unlock_shared_and_lock()) + { + state = writing; + } + else if (mut.try_unlock_shared_and_lock_upgrade()) + { + assert(state == reading); + mut.unlock_upgrade_and_lock(); + state = writing; + } + else + { + mut.unlock_shared(); + continue; + } + assert(state == writing); + state = reading; + mut.unlock_and_lock_upgrade(); + assert(state == reading); + mut.unlock_upgrade_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + } + print("try_clockwise = ", count, '\n'); +} + +void try_for_clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_shared_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + if (mut.try_unlock_shared_and_lock_for(boost::chrono::microseconds(5))) + { + state = writing; + } + else if (mut.try_unlock_shared_and_lock_upgrade_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + mut.unlock_upgrade_and_lock(); + state = writing; + } + else + { + mut.unlock_shared(); + continue; + } + assert(state == writing); + state = reading; + mut.unlock_and_lock_upgrade(); + assert(state == reading); + mut.unlock_upgrade_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + } + print("try_for_clockwise = ", count, '\n'); +} + +void try_counter_clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_upgrade()) + { + assert(state == reading); + if (mut.try_unlock_upgrade_and_lock()) + { + assert(state == reading); + state = writing; + assert(state == writing); + state = reading; + mut.unlock_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + else + { + mut.unlock_upgrade(); + } + } + } + print("try_counter_clockwise = ", count, '\n'); +} + +void try_for_counter_clockwise() +{ + typedef boost::chrono::steady_clock Clock; + unsigned count = 0; + Clock::time_point until = Clock::now() + boost::chrono::seconds(3); + while (Clock::now() < until) + { + if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + if (mut.try_unlock_upgrade_and_lock_for(boost::chrono::microseconds(5))) + { + assert(state == reading); + state = writing; + assert(state == writing); + state = reading; + mut.unlock_and_lock_shared(); + assert(state == reading); + mut.unlock_shared(); + ++count; + } + else + { + mut.unlock_upgrade(); + } + } + } + print("try_for_counter_clockwise = ", count, '\n'); +} + +void +test_upgrade_mutex() +{ + { + boost::thread t1(reader); + boost::thread t2(writer); + boost::thread t3(reader); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(try_reader); + boost::thread t2(try_writer); + boost::thread t3(try_reader); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(try_for_reader); + boost::thread t2(try_for_writer); + boost::thread t3(try_for_reader); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(reader); + boost::thread t2(writer); + boost::thread t3(upgradable); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(reader); + boost::thread t2(writer); + boost::thread t3(try_upgradable); + t1.join(); + t2.join(); + t3.join(); + } + { + boost::thread t1(reader); + boost::thread t2(writer); + boost::thread t3(try_for_upgradable); + t1.join(); + t2.join(); + t3.join(); + } + { + state = reading; + boost::thread t1(clockwise); + boost::thread t2(counter_clockwise); + boost::thread t3(clockwise); + boost::thread t4(counter_clockwise); + t1.join(); + t2.join(); + t3.join(); + t4.join(); + } + { + state = reading; + boost::thread t1(try_clockwise); + boost::thread t2(try_counter_clockwise); + t1.join(); + t2.join(); + } + { + state = reading; + boost::thread t1(try_for_clockwise); + boost::thread t2(try_for_counter_clockwise); + t1.join(); + t2.join(); + } +} + +} + +namespace Assignment +{ + +class A +{ + typedef boost::upgrade_mutex mutex_type; + typedef boost::shared_lock SharedLock; + typedef boost::upgrade_lock UpgradeLock; + typedef boost::unique_lock Lock; + + mutable mutex_type mut_; + std::vector data_; + +public: + + A(const A& a) + { + SharedLock _(a.mut_); + data_ = a.data_; + } + + A& operator=(const A& a) + { + if (this != &a) + { + Lock this_lock(mut_, boost::defer_lock); + SharedLock that_lock(a.mut_, boost::defer_lock); + boost::lock(this_lock, that_lock); + data_ = a.data_; + } + return *this; + } + + void swap(A& a) + { + Lock this_lock(mut_, boost::defer_lock); + Lock that_lock(a.mut_, boost::defer_lock); + boost::lock(this_lock, that_lock); + data_.swap(a.data_); + } + + void average(A& a) + { + assert(data_.size() == a.data_.size()); + assert(this != &a); + + Lock this_lock(mut_, boost::defer_lock); + UpgradeLock share_that_lock(a.mut_, boost::defer_lock); + boost::lock(this_lock, share_that_lock); + + for (unsigned i = 0; i < data_.size(); ++i) + data_[i] = (data_[i] + a.data_[i]) / 2; + + SharedLock share_this_lock(boost::move(this_lock)); + Lock that_lock(boost::move(share_that_lock)); + a.data_ = data_; + } +}; + +} // Assignment + +void temp() +{ + using namespace boost; + static upgrade_mutex mut; + unique_lock ul(mut); + shared_lock sl; + sl = shared_lock(boost::move(ul)); +} + +int main() +{ + typedef boost::chrono::high_resolution_clock Clock; + typedef boost::chrono::duration sec; + Clock::time_point t0 = Clock::now(); + + S::test_shared_mutex(); + U::test_upgrade_mutex(); + Clock::time_point t1 = Clock::now(); + std::cout << sec(t1 - t0) << '\n'; + return 0; +} + diff --git a/include/boost/thread/detail/thread.hpp b/include/boost/thread/detail/thread.hpp index 59f2e66e..2efb86c0 100644 --- a/include/boost/thread/detail/thread.hpp +++ b/include/boost/thread/detail/thread.hpp @@ -503,19 +503,24 @@ namespace boost template bool try_join_for(const chrono::duration& rel_time) { - return try_join_for(chrono::ceil(rel_time)); + return try_join_until(chrono::steady_clock::now() + rel_time); } template bool try_join_until(const chrono::time_point& t) { using namespace chrono; + system_clock::time_point s_now = system_clock::now(); typename Clock::time_point c_now = Clock::now(); - return try_join_for(chrono::ceil(t - c_now)); + return try_join_until(s_now + ceil(t - c_now)); } -#endif - private: -#ifdef BOOST_THREAD_USES_CHRONO - bool do_try_join_for(chrono::milliseconds const &rel_time_in_milliseconds); + template + bool try_join_until(const chrono::time_point& t) + { + using namespace chrono; + typedef time_point nano_sys_tmpt; + return try_join_until(nano_sys_tmpt(ceil(t.time_since_epoch()))); + } + bool try_join_until(const chrono::time_point& tp); #endif public: diff --git a/include/boost/thread/future.hpp b/include/boost/thread/future.hpp index 0bc1b1bb..bd4f3d1e 100644 --- a/include/boost/thread/future.hpp +++ b/include/boost/thread/future.hpp @@ -104,14 +104,17 @@ namespace boost } } - class BOOST_THREAD_DECL future_error + class BOOST_SYMBOL_VISIBLE future_error : public std::logic_error { system::error_code ec_; public: - future_error(system::error_code ec); + future_error(system::error_code ec) + : logic_error(ec.message()), + ec_(ec) + { + } - BOOST_SYMBOL_VISIBLE const system::error_code& code() const BOOST_NOEXCEPT { return ec_; @@ -1624,7 +1627,7 @@ namespace boost { this->mark_finished_with_result(f()); } - catch(thread_interrupted& it) + catch(thread_interrupted& ) { this->mark_interrupted_finish(); } @@ -1666,7 +1669,7 @@ namespace boost f(); this->mark_finished_with_result(); } - catch(thread_interrupted& it) + catch(thread_interrupted& ) { this->mark_interrupted_finish(); } diff --git a/include/boost/thread/win32/basic_timed_mutex.hpp b/include/boost/thread/win32/basic_timed_mutex.hpp index 52f3e803..f9743c2b 100644 --- a/include/boost/thread/win32/basic_timed_mutex.hpp +++ b/include/boost/thread/win32/basic_timed_mutex.hpp @@ -145,34 +145,7 @@ namespace boost } return true; } - bool try_lock_for(chrono::milliseconds const& rel_time) - { - if(try_lock()) - { - return true; - } - long old_count=active_count; - mark_waiting_and_try_lock(old_count); - if(old_count&lock_flag_value) - { - bool lock_acquired=false; - void* const sem=get_event(); - - do - { - if(win32::WaitForSingleObject(sem,static_cast(rel_time.count()))!=0) - { - BOOST_INTERLOCKED_DECREMENT(&active_count); - return false; - } - clear_waiting_and_try_lock(old_count); - lock_acquired=!(old_count&lock_flag_value); - } - while(!lock_acquired); - } - return true; - } template bool timed_lock(Duration const& timeout) @@ -185,19 +158,56 @@ namespace boost return timed_lock(system_time(timeout)); } - template - bool try_lock_for(const chrono::duration& rel_time) - { - using namespace chrono; - return try_lock_for(ceil(rel_time)); - } - template - bool try_lock_until(const chrono::time_point& t) - { - using namespace chrono; - typename Clock::time_point c_now = Clock::now(); - return try_lock_for(ceil(t - c_now)); - } + template + bool try_lock_for(const chrono::duration& rel_time) + { + return try_lock_until(chrono::steady_clock::now() + rel_time); + } + template + bool try_lock_until(const chrono::time_point& t) + { + using namespace chrono; + system_clock::time_point s_now = system_clock::now(); + typename Clock::time_point c_now = Clock::now(); + return try_lock_until(s_now + ceil(t - c_now)); + } + template + bool try_lock_until(const chrono::time_point& t) + { + using namespace chrono; + typedef time_point sys_tmpt; + return try_lock_until(sys_tmpt(chrono::ceil(t.time_since_epoch()))); + } + bool try_lock_until(const chrono::time_point& tp) + { + if(try_lock()) + { + return true; + } + long old_count=active_count; + mark_waiting_and_try_lock(old_count); + + if(old_count&lock_flag_value) + { + bool lock_acquired=false; + void* const sem=get_event(); + + do + { + chrono::milliseconds rel_time= chrono::ceil(tp-chrono::system_clock::now()); + + if(win32::WaitForSingleObject(sem,static_cast(rel_time.count()))!=0) + { + BOOST_INTERLOCKED_DECREMENT(&active_count); + return false; + } + clear_waiting_and_try_lock(old_count); + lock_acquired=!(old_count&lock_flag_value); + } + while(!lock_acquired); + } + return true; + } void unlock() { diff --git a/include/boost/thread/win32/shared_mutex.hpp b/include/boost/thread/win32/shared_mutex.hpp index f930bc78..59f154a9 100644 --- a/include/boost/thread/win32/shared_mutex.hpp +++ b/include/boost/thread/win32/shared_mutex.hpp @@ -14,6 +14,10 @@ #include #include #include +#ifdef BOOST_THREAD_USES_CHRONO +#include +#include +#endif #include @@ -21,9 +25,15 @@ namespace boost { class shared_mutex { +#ifndef BOOST_NO_DELETED_FUNCTIONS + public: + shared_mutex(shared_mutex const&) = delete; + shared_mutex& operator=(shared_mutex const&) = delete; +#else // BOOST_NO_DELETED_FUNCTIONS private: shared_mutex(shared_mutex const&); shared_mutex& operator=(shared_mutex const&); +#endif // BOOST_NO_DELETED_FUNCTIONS private: struct state_data { @@ -218,6 +228,113 @@ namespace boost } } + template + bool try_lock_shared_for(const chrono::duration& rel_time) + { + return try_lock_shared_until(chrono::steady_clock::now() + rel_time); + } + template + bool try_lock_shared_until(const chrono::time_point& t) + { + using namespace chrono; + system_clock::time_point s_now = system_clock::now(); + typename Clock::time_point c_now = Clock::now(); + return try_lock_shared_until(s_now + ceil(t - c_now)); + } + template + bool try_lock_shared_until(const chrono::time_point& t) + { + using namespace chrono; + typedef time_point sys_tmpt; + return try_lock_shared_until(sys_tmpt(chrono::ceil(t.time_since_epoch()))); + } + bool try_lock_shared_until(const chrono::time_point& tp) + { + for(;;) + { + state_data old_state=state; + for(;;) + { + state_data new_state=old_state; + if(new_state.exclusive || new_state.exclusive_waiting_blocked) + { + ++new_state.shared_waiting; + if(!new_state.shared_waiting) + { + boost::throw_exception(boost::lock_error()); + } + } + else + { + ++new_state.shared_count; + if(!new_state.shared_count) + { + boost::throw_exception(boost::lock_error()); + } + } + + state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state); + if(current_state==old_state) + { + break; + } + old_state=current_state; + } + + if(!(old_state.exclusive| old_state.exclusive_waiting_blocked)) + { + return true; + } + + chrono::system_clock::time_point n = chrono::system_clock::now(); + unsigned long res; + if (tp>n) { + chrono::milliseconds rel_time= chrono::ceil(tp-n); + res=detail::win32::WaitForSingleObject(semaphores[unlock_sem], + static_cast(rel_time.count())); + } else { + res=detail::win32::timeout; + } + if(res==detail::win32::timeout) + { + for(;;) + { + state_data new_state=old_state; + if(new_state.exclusive || new_state.exclusive_waiting_blocked) + { + if(new_state.shared_waiting) + { + --new_state.shared_waiting; + } + } + else + { + ++new_state.shared_count; + if(!new_state.shared_count) + { + return false; + } + } + + state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state); + if(current_state==old_state) + { + break; + } + old_state=current_state; + } + + if(!(old_state.exclusive| old_state.exclusive_waiting_blocked)) + { + return true; + } + return false; + } + + BOOST_ASSERT(res==0); + } + } + void unlock_shared() { state_data old_state=state; @@ -380,6 +497,115 @@ namespace boost } } + + template + bool try_lock_for(const chrono::duration& rel_time) + { + return try_lock_until(chrono::steady_clock::now() + rel_time); + } + template + bool try_lock_until(const chrono::time_point& t) + { + using namespace chrono; + system_clock::time_point s_now = system_clock::now(); + typename Clock::time_point c_now = Clock::now(); + return try_lock_until(s_now + ceil(t - c_now)); + } + template + bool try_lock_until(const chrono::time_point& t) + { + using namespace chrono; + typedef time_point sys_tmpt; + return try_lock_until(sys_tmpt(chrono::ceil(t.time_since_epoch()))); + } + bool try_lock_until(const chrono::time_point& tp) + { + for(;;) + { + state_data old_state=state; + + for(;;) + { + state_data new_state=old_state; + if(new_state.shared_count || new_state.exclusive) + { + ++new_state.exclusive_waiting; + if(!new_state.exclusive_waiting) + { + boost::throw_exception(boost::lock_error()); + } + + new_state.exclusive_waiting_blocked=true; + } + else + { + new_state.exclusive=true; + } + + state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state); + if(current_state==old_state) + { + break; + } + old_state=current_state; + } + + if(!old_state.shared_count && !old_state.exclusive) + { + return true; + } + #ifndef UNDER_CE + const bool wait_all = true; + #else + const bool wait_all = false; + #endif + + chrono::system_clock::time_point n = chrono::system_clock::now(); + unsigned long wait_res; + if (tp>n) { + chrono::milliseconds rel_time= chrono::ceil(tp-chrono::system_clock::now()); + wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,wait_all, + static_cast(rel_time.count())); + } else { + wait_res=detail::win32::timeout; + } + if(wait_res==detail::win32::timeout) + { + for(;;) + { + state_data new_state=old_state; + if(new_state.shared_count || new_state.exclusive) + { + if(new_state.exclusive_waiting) + { + if(!--new_state.exclusive_waiting) + { + new_state.exclusive_waiting_blocked=false; + } + } + } + else + { + new_state.exclusive=true; + } + + state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state); + if(current_state==old_state) + { + break; + } + old_state=current_state; + } + if(!old_state.shared_count && !old_state.exclusive) + { + return true; + } + return false; + } + BOOST_ASSERT(wait_res<2); + } + } + void unlock() { state_data old_state=state; @@ -563,7 +789,17 @@ namespace boost } release_waiters(old_state); } - +#if 0 // To be added + bool try_unlock_upgrade_and_lock(); + template + bool + try_unlock_upgrade_and_lock_for( + const chrono::duration& rel_time); + template + bool + try_unlock_upgrade_and_lock_until( + const chrono::time_point& abs_time); +#endif void unlock_and_lock_shared() { state_data old_state=state; @@ -588,7 +824,17 @@ namespace boost } release_waiters(old_state); } - +#if 0 // To be added + bool try_unlock_shared_and_lock(); + template + bool + try_unlock_shared_and_lock_for( + const chrono::duration& rel_time); + template + bool + try_unlock_shared_and_lock_until( + const chrono::time_point& abs_time); +#endif void unlock_upgrade_and_lock_shared() { state_data old_state=state; @@ -612,7 +858,17 @@ namespace boost } release_waiters(old_state); } - +#if 0 // To be added + bool try_unlock_shared_and_lock_upgrade(); + template + bool + try_unlock_shared_and_lock_upgrade_for( + const chrono::duration& rel_time); + template + bool + try_unlock_shared_and_lock_upgrade_until( + const chrono::time_point& abs_time); +#endif }; } diff --git a/src/future.cpp b/src/future.cpp index 35cc54c2..838dfe74 100755 --- a/src/future.cpp +++ b/src/future.cpp @@ -53,16 +53,4 @@ namespace boost return f; } - future_error::future_error(system::error_code ec) - : logic_error(ec.message()), - ec_(ec) - { - } - -// future_error::~future_error() //BOOST_NOEXCEPT -// { -// } - - - } diff --git a/src/win32/thread.cpp b/src/win32/thread.cpp index a02a9eaf..09ba7316 100644 --- a/src/win32/thread.cpp +++ b/src/win32/thread.cpp @@ -319,7 +319,9 @@ namespace boost } #ifdef BOOST_THREAD_USES_CHRONO - bool thread::do_try_join_for(chrono::milliseconds const &rel_time_in_milliseconds) { + + bool thread::try_join_until(const chrono::time_point& tp) + { if (this_thread::get_id() == get_id()) { boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself")); @@ -327,15 +329,16 @@ namespace boost detail::thread_data_ptr local_thread_info=(get_thread_info)(); if(local_thread_info) { - if(!this_thread::interruptible_wait(local_thread_info->thread_handle,rel_time_in_milliseconds.count())) - { - return false; - } - release_handle(); + chrono::milliseconds rel_time= chrono::ceil(tp-chrono::system_clock::now()); + if(!this_thread::interruptible_wait(local_thread_info->thread_handle,rel_time.count())) + { + return false; + } + release_handle(); } return true; - } + #endif void thread::detach() diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 00eebc19..4620d831 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -35,10 +35,10 @@ rule thread-run ( sources ) rule thread-run2 ( sources : name ) { return - [ run $(sources) ../build//boost_thread : : : + [ run $(sources) ../build//boost_thread : : : : $(name) ] [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/static - : : : + : : : : $(name)_lib ] ; } @@ -48,7 +48,7 @@ rule thread-compile-fail-V2 ( sources : reqs * : name ) { return [ compile-fail $(sources) - : $(reqs) + : $(reqs) : $(name) ] ; } @@ -78,12 +78,11 @@ rule thread-compile-fail-V2 ( sources : reqs * : name ) [ thread-run test_shared_mutex.cpp ] [ thread-run test_shared_mutex_part_2.cpp ] [ thread-run test_shared_mutex_timed_locks.cpp ] - #uncomment the following once these works on windows - #[ thread-run test_shared_mutex_timed_locks_chrono.cpp ] - #uncomment the following once these works on windows - #[ thread-run test_v2_shared_mutex.cpp ] - #[ thread-run test_v2_shared_mutex_part_2.cpp ] - #[ thread-run test_v2_shared_mutex_timed_locks.cpp ] + [ thread-run test_shared_mutex_timed_locks_chrono.cpp ] + #uncomment the following once these works on windows + [ thread-run test_v2_shared_mutex.cpp ] + [ thread-run test_v2_shared_mutex_part_2.cpp ] + [ thread-run test_v2_shared_mutex_timed_locks.cpp ] [ thread-run test_lock_concept.cpp ] [ thread-run test_generic_locks.cpp ] [ thread-run test_futures.cpp ] @@ -123,190 +122,215 @@ rule thread-compile-fail-V2 ( sources : reqs * : name ) #explicit conditions ; test-suite conditions : - [ thread-compile-fail-V2 ./sync/conditions/condition_variable/assign_fail.cpp : : conditions__condition_variable__assign_fail ] - [ thread-compile-fail-V2 ./sync/conditions/condition_variable/copy_fail.cpp : : conditions__condition_variable__copy_fail ] - [ thread-run2 ./sync/conditions/condition_variable/default_pass.cpp : conditions__condition_variable__default_pass ] - [ thread-run2 ./sync/conditions/condition_variable/dtor_pass.cpp : conditions__condition_variable__dtor_pass ] - [ thread-run2 ./sync/conditions/condition_variable/native_handle_pass.cpp : conditions__condition_variable__native_handle_pass ] - [ thread-run2 ./sync/conditions/condition_variable/wait_for_pass.cpp : conditions__condition_variable__wait_for_pass ] - [ thread-run2 ./sync/conditions/condition_variable/wait_for_pred_pass.cpp : conditions__condition_variable__wait_for_pred_pass ] - [ thread-run2 ./sync/conditions/condition_variable/wait_until_pass.cpp : conditions__condition_variable__wait_until_pass ] - [ thread-run2 ./sync/conditions/condition_variable/wait_until_pred_pass.cpp : conditions__condition_variable__wait_until_pred_pass ] + [ thread-compile-fail-V2 ./sync/conditions/condition_variable/assign_fail.cpp : : conditions__condition_variable__assign_f ] + [ thread-compile-fail-V2 ./sync/conditions/condition_variable/copy_fail.cpp : : conditions__condition_variable__copy_f ] + [ thread-run2 ./sync/conditions/condition_variable/default_pass.cpp : conditions__condition_variable__default_p ] + [ thread-run2 ./sync/conditions/condition_variable/dtor_pass.cpp : conditions__condition_variable__dtor_p ] + [ thread-run2 ./sync/conditions/condition_variable/native_handle_pass.cpp : conditions__condition_variable__native_handle_p ] + [ thread-run2 ./sync/conditions/condition_variable/wait_for_pass.cpp : conditions__condition_variable__wait_for_p ] + [ thread-run2 ./sync/conditions/condition_variable/wait_for_pred_pass.cpp : conditions__condition_variable__wait_for_pred_p ] + [ thread-run2 ./sync/conditions/condition_variable/wait_until_pass.cpp : conditions__condition_variable__wait_until_p ] + [ thread-run2 ./sync/conditions/condition_variable/wait_until_pred_pass.cpp : conditions__condition_variable__wait_until_pred_p ] - [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/assign_fail.cpp : : conditions__condition_variable_any__assign_fail ] - [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/copy_fail.cpp : : conditions__condition_variable_any__copy_fail ] - [ thread-run2 ./sync/conditions/condition_variable_any/default_pass.cpp : conditions__condition_variable_any__default_pass ] - [ thread-run2 ./sync/conditions/condition_variable_any/dtor_pass.cpp : conditions__condition_variable_any__dtor_pass ] - [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pass.cpp : conditions__condition_variable_any__wait_for_pass ] - [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pred_pass.cpp : conditions__condition_variable_any__wait_for_pred_pass ] - [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pass.cpp : conditions__condition_variable_any__wait_until_pass ] - [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pred_pass.cpp : conditions__condition_variable_any__wait_until_pred_pass ] - [ thread-run2 ./sync/conditions/cv_status/cv_status_pass.cpp : conditions__cv_status__cv_status_pass ] + [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/assign_fail.cpp : : conditions__condition_variable_any__assign_f ] + [ thread-compile-fail-V2 ./sync/conditions/condition_variable_any/copy_fail.cpp : : conditions__condition_variable_any__copy_f ] + [ thread-run2 ./sync/conditions/condition_variable_any/default_pass.cpp : conditions__condition_variable_any__default_p ] + [ thread-run2 ./sync/conditions/condition_variable_any/dtor_pass.cpp : conditions__condition_variable_any__dtor_p ] + [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pass.cpp : conditions__condition_variable_any__wait_for_p ] + [ thread-run2 ./sync/conditions/condition_variable_any/wait_for_pred_pass.cpp : conditions__condition_variable_any__wait_for_pred_p ] + [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pass.cpp : conditions__condition_variable_any__wait_until_p ] + [ thread-run2 ./sync/conditions/condition_variable_any/wait_until_pred_pass.cpp : conditions__condition_variable_any__wait_until_pred_p ] + [ thread-run2 ./sync/conditions/cv_status/cv_status_pass.cpp : conditions__cv_status__cv_status_p ] ; #explicit futures ; test-suite futures : - # [ thread-run2 ./sync/futures/async/async_pass.cpp : futures__async__async_pass ] - [ thread-run2 ./sync/futures/promise/default_pass.cpp : futures__promise__default_pass ] - [ thread-run2 ./sync/futures/promise/dtor_pass.cpp : futures__promise__dtor_pass ] - [ thread-run2 ./sync/futures/promise/get_future_pass.cpp : futures__promise__get_future_pass ] + # [ thread-run2 ./sync/futures/async/async_pass.cpp : futures__async__async_p ] + [ thread-run2 ./sync/futures/promise/default_pass.cpp : futures__promise__default_p ] + [ thread-run2 ./sync/futures/promise/dtor_pass.cpp : futures__promise__dtor_p ] + [ thread-run2 ./sync/futures/promise/get_future_pass.cpp : futures__promise__get_future_p ] ; #explicit mutual_exclusion ; test-suite mutual_exclusion : + #uncomment the following once these works on windows + #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp : : lock_guard__cons__copy_assign_f ] + #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp : : lock_guard__cons__copy_ctor_f ] + #[ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp : lock_guard__cons__adopt_lock_p ] + #[ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/default_pass.cpp : lock_guard__cons__default_p ] + #[ thread-run2 ./sync/mutual_exclusion/locks/lock_guard/types_pass.cpp : lock_guard__types_p ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp : : mutual_exclusion__locks__unique_lock__cons__copy_assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp : : mutual_exclusion__locks__unique_lock__cons__copy_ctor_fail ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__adopt_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp : mutual_exclusion__locks__unique_lock__cons__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__defer_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp : mutual_exclusion__locks__unique_lock__cons__duration_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp : mutual_exclusion__locks__unique_lock__cons__move_assign_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp : mutual_exclusion__locks__unique_lock__cons__move_ctor_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp : mutual_exclusion__locks__unique_lock__cons__mutex_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp : mutual_exclusion__locks__unique_lock__cons__time_point_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp : mutual_exclusion__locks__unique_lock__cons__try_to_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_for_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp : mutual_exclusion__locks__unique_lock__locking__try_lock_until_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp : mutual_exclusion__locks__unique_lock__locking__unlock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp : mutual_exclusion__locks__unique_lock__mod__member_swap_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp : mutual_exclusion__locks__unique_lock__mod__non_member_swap_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp : mutual_exclusion__locks__unique_lock__mod__release_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp : mutual_exclusion__locks__unique_lock__obs__mutex_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp : mutual_exclusion__locks__unique_lock__obs__op_bool_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp : mutual_exclusion__locks__unique_lock__obs__owns_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/types_pass.cpp : mutual_exclusion__locks__unique_lock__types_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_assign_fail.cpp : : unique_lock__cons__copy_assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/unique_lock/cons/copy_ctor_fail.cpp : : unique_lock__cons__copy_ctor_f ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/adopt_lock_pass.cpp : unique_lock__cons__adopt_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/default_pass.cpp : unique_lock__cons__default_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/defer_lock_pass.cpp : unique_lock__cons__defer_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp : unique_lock__cons__duration_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_assign_pass.cpp : unique_lock__cons__move_assign_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_pass.cpp : unique_lock__cons__move_ctor_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp : unique_lock__cons__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp : unique_lock__cons__time_point_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp : unique_lock__cons__try_to_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp : unique_lock__locking__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_for_pass.cpp : unique_lock__locking__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_pass.cpp : unique_lock__locking__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/try_lock_until_pass.cpp : unique_lock__locking__try_lock_until_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/locking/unlock_pass.cpp : unique_lock__locking__unlock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/member_swap_pass.cpp : unique_lock__mod__member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/non_member_swap_pass.cpp : unique_lock__mod__non_member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/mod/release_pass.cpp : unique_lock__mod__release_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/mutex_pass.cpp : unique_lock__obs__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/op_bool_pass.cpp : unique_lock__obs__op_bool_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/obs/owns_lock_pass.cpp : unique_lock__obs__owns_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/types_pass.cpp : unique_lock__types_p ] - #uncomment the following once these works on windows - #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp : : mutual_exclusion__locks__shared_lock__cons__copy_assign_fail ] - #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp : : mutual_exclusion__locks__shared_lock__cons__copy_ctor_fail ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__adopt_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp : mutual_exclusion__locks__shared_lock__cons__default_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__defer_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp : mutual_exclusion__locks__shared_lock__cons__duration_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp : mutual_exclusion__locks__shared_lock__cons__move_assign_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp : mutual_exclusion__locks__shared_lock__cons__move_ctor_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp : mutual_exclusion__locks__shared_lock__cons__mutex_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp : mutual_exclusion__locks__shared_lock__cons__time_point_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp : mutual_exclusion__locks__shared_lock__cons__try_to_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_for_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp : mutual_exclusion__locks__shared_lock__locking__try_lock_until_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp : mutual_exclusion__locks__shared_lock__locking__unlock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp : mutual_exclusion__locks__shared_lock__mod__member_swap_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp : mutual_exclusion__locks__shared_lock__mod__non_member_swap_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp : mutual_exclusion__locks__shared_lock__mod__release_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp : mutual_exclusion__locks__shared_lock__obs__mutex_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp : mutual_exclusion__locks__shared_lock__obs__op_bool_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp : mutual_exclusion__locks__shared_lock__obs__owns_lock_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_assign_fail.cpp : : shared_lock__cons__copy_assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/shared_lock/cons/copy_ctor_fail.cpp : : shared_lock__cons__copy_ctor_f ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/adopt_lock_pass.cpp : shared_lock__cons__adopt_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/default_pass.cpp : shared_lock__cons__default_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/defer_lock_pass.cpp : shared_lock__cons__defer_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp : shared_lock__cons__duration_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp : shared_lock__cons__move_assign_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/move_ctor_pass.cpp : shared_lock__cons__move_ctor_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp : shared_lock__cons__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp : shared_lock__cons__time_point_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp : shared_lock__cons__try_to_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp : shared_lock__locking__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_for_pass.cpp : shared_lock__locking__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_pass.cpp : shared_lock__locking__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/try_lock_until_pass.cpp : shared_lock__locking__try_lock_until_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/locking/unlock_pass.cpp : shared_lock__locking__unlock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/member_swap_pass.cpp : shared_lock__mod__member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/non_member_swap_pass.cpp : shared_lock__mod__non_member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/mod/release_pass.cpp : shared_lock__mod__release_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/mutex_pass.cpp : shared_lock__obs__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/op_bool_pass.cpp : shared_lock__obs__op_bool_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/obs/owns_lock_pass.cpp : shared_lock__obs__owns_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/shared_lock/types_pass.cpp : shared_lock__types_p ] - #uncomment the following once these works on windows - #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp : : mutual_exclusion__locks__upgrade_lock__cons__copy_assign_fail ] - #[ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp : : mutual_exclusion__locks__upgrade_lock__cons__copy_ctor_fail ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__adopt_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__default_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__defer_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__duration_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__move_assign_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__move_ctor_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__mutex_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__time_point_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__cons__try_to_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__locking__lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp : mutual_exclusion__locks__upgrade_lock__locking__try_lock_for_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__locking__try_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp : mutual_exclusion__locks__upgrade_lock__locking__try_lock_until_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp : mutual_exclusion__locks__upgrade_lock__locking__unlock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp : mutual_exclusion__locks__upgrade_lock__mod__member_swap_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp : mutual_exclusion__locks__upgrade_lock__mod__non_member_swap_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp : mutual_exclusion__locks__upgrade_lock__mod__release_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp : mutual_exclusion__locks__upgrade_lock__obs__mutex_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp : mutual_exclusion__locks__upgrade_lock__obs__op_bool_pass ] - #[ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp : mutual_exclusion__locks__upgrade_lock__obs__owns_lock_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_assign_fail.cpp : : upgrade_lock__cons__copy_assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/copy_ctor_fail.cpp : : upgrade_lock__cons__copy_ctor_f ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/adopt_lock_pass.cpp : upgrade_lock__cons__adopt_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/default_pass.cpp : upgrade_lock__cons__default_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/defer_lock_pass.cpp : upgrade_lock__cons__defer_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp : upgrade_lock__cons__duration_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp : upgrade_lock__cons__move_assign_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/move_ctor_pass.cpp : upgrade_lock__cons__move_ctor_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp : upgrade_lock__cons__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp : upgrade_lock__cons__time_point_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp : upgrade_lock__cons__try_to_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp : upgrade_lock__locking__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_for_pass.cpp : upgrade_lock__locking__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_pass.cpp : upgrade_lock__locking__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/try_lock_until_pass.cpp : upgrade_lock__locking__try_lock_until_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/locking/unlock_pass.cpp : upgrade_lock__locking__unlock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/member_swap_pass.cpp : upgrade_lock__mod__member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/non_member_swap_pass.cpp : upgrade_lock__mod__non_member_swap_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/mod/release_pass.cpp : upgrade_lock__mod__release_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/mutex_pass.cpp : upgrade_lock__obs__mutex_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/op_bool_pass.cpp : upgrade_lock__obs__op_bool_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/obs/owns_lock_pass.cpp : upgrade_lock__obs__owns_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp : upgrade_lock__types_p ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutex__assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutex__copy_f ] + [ thread-run2 ./sync/mutual_exclusion/mutex/default_pass.cpp : mutex__default_p ] + [ thread-run2 ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutex__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutex__native_handle_p ] + [ thread-run2 ./sync/mutual_exclusion/mutex/try_lock_pass.cpp : mutex__try_lock_p ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutual_exclusion__mutex__assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutual_exclusion__mutex__copy_fail ] - [ thread-run2 ./sync/mutual_exclusion/mutex/default_pass.cpp : mutual_exclusion__mutex__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutual_exclusion__mutex__lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutual_exclusion__mutex__native_handle_pass ] - [ thread-run2 ./sync/mutual_exclusion/mutex/try_lock_pass.cpp : mutual_exclusion__mutex__try_lock_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/assign_fail.cpp : : recursive_mutex__assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/copy_fail.cpp : : recursive_mutex__copy_f ] + [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/default_pass.cpp : recursive_mutex__default_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/lock_pass.cpp : recursive_mutex__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp : recursive_mutex__native_handle_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp : recursive_mutex__try_lock_p ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/assign_fail.cpp : : mutual_exclusion__recursive_mutex__assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_mutex/copy_fail.cpp : : mutual_exclusion__recursive_mutex__copy_fail ] - [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/default_pass.cpp : mutual_exclusion__recursive_mutex__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/lock_pass.cpp : mutual_exclusion__recursive_mutex__lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/native_handle_pass.cpp : mutual_exclusion__recursive_mutex__native_handle_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp : mutual_exclusion__recursive_mutex__try_lock_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp : : recursive_timed_mutex__assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp : : recursive_timed_mutex__copy_f ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp : recursive_timed_mutex__default_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp : recursive_timed_mutex__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp : recursive_timed_mutex__native_handle_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp : recursive_timed_mutex__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp : recursive_timed_mutex__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp : recursive_timed_mutex__try_lock_until_p ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/assign_fail.cpp : : mutual_exclusion__recursive_timed_mutex__assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/recursive_timed_mutex/copy_fail.cpp : : mutual_exclusion__recursive_timed_mutex__copy_fail ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/default_pass.cpp : mutual_exclusion__recursive_timed_mutex__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp : mutual_exclusion__recursive_timed_mutex__lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/native_handle_pass.cpp : mutual_exclusion__recursive_timed_mutex__native_handle_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_for_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp : mutual_exclusion__recursive_timed_mutex__try_lock_until_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/assign_fail.cpp : : timed_mutex__assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/copy_fail.cpp : : timed_mutex__copy_f ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/default_pass.cpp : timed_mutex__default_p ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/lock_pass.cpp : timed_mutex__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp : timed_mutex__native_handle_p ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp : timed_mutex__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp : timed_mutex__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp : timed_mutex__try_lock_until_p ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/assign_fail.cpp : : mutual_exclusion__timed_mutex__assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/timed_mutex/copy_fail.cpp : : mutual_exclusion__timed_mutex__copy_fail ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/default_pass.cpp : mutual_exclusion__timed_mutex__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/lock_pass.cpp : mutual_exclusion__timed_mutex__lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/native_handle_pass.cpp : mutual_exclusion__timed_mutex__native_handle_pass ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp : mutual_exclusion__timed_mutex__try_lock_for_pass ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp : mutual_exclusion__timed_mutex__try_lock_pass ] - [ thread-run2 ./sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp : mutual_exclusion__timed_mutex__try_lock_until_pass ] - - [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/assign_fail.cpp : : mutual_exclusion__shared_mutex__assign_fail ] - [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/copy_fail.cpp : : mutual_exclusion__shared_mutex__copy_fail ] - [ thread-run2 ./sync/mutual_exclusion/shared_mutex/default_pass.cpp : mutual_exclusion__shared_mutex__default_pass ] - [ thread-run2 ./sync/mutual_exclusion/shared_mutex/lock_pass.cpp : mutual_exclusion__shared_mutex__lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp : mutual_exclusion__shared_mutex__try_lock_for_pass ] - [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp : mutual_exclusion__shared_mutex__try_lock_pass ] - #[ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp : mutual_exclusion__shared_mutex__try_lock_until_pass ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/assign_fail.cpp : : shared_mutex__assign_f ] + [ thread-compile-fail-V2 ./sync/mutual_exclusion/shared_mutex/copy_fail.cpp : : shared_mutex__copy_f ] + [ thread-run2 ./sync/mutual_exclusion/shared_mutex/default_pass.cpp : shared_mutex__default_p ] + [ thread-run2 ./sync/mutual_exclusion/shared_mutex/lock_pass.cpp : shared_mutex__lock_p ] + [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp : shared_mutex__try_lock_for_p ] + [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp : shared_mutex__try_lock_p ] + [ thread-run2 ./sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp : shared_mutex__try_lock_until_p ] ; #explicit this_thread ; test-suite this_thread : - [ thread-run2 ./threads/this_thread/get_id/get_id_pass.cpp : this_thread__get_id__get_id_pass ] - [ thread-run2 ./threads/this_thread/sleep_for/sleep_for_pass.cpp : this_thread__sleep_for__sleep_for_pass ] - [ thread-run2 ./threads/this_thread/sleep_until/sleep_until_pass.cpp : this_thread__sleep_until__sleep_until_pass ] + [ thread-run2 ./threads/this_thread/get_id/get_id_pass.cpp : this_thread__get_id_p ] + [ thread-run2 ./threads/this_thread/sleep_for/sleep_for_pass.cpp : this_thread__sleep_for_p ] + [ thread-run2 ./threads/this_thread/sleep_until/sleep_until_pass.cpp : this_thread__sleep_until_p ] ; #explicit thread ; test-suite thread : - [ thread-compile-fail-V2 ./threads/thread/assign/copy_fail.cpp : : thread__assign__copy_fail ] - [ thread-run2 ./threads/thread/assign/move_pass.cpp : thread__assign__move_pass ] - [ thread-compile-fail-V2 ./threads/thread/constr/copy_fail.cpp : : thread__constr__copy_fail ] - [ thread-run2 ./threads/thread/constr/default_pass.cpp : thread__constr__default_pass ] - [ thread-run2 ./threads/thread/constr/F_pass.cpp : thread__constr__F_pass ] - [ thread-run2 ./threads/thread/constr/Frvalue_pass.cpp : thread__constr__Frvalue_pass ] - #[ thread-run2 ./threads/thread/constr/FrvalueArgs_pass.cpp : thread__constr__FrvalueArgs_pass ] - [ thread-run2 ./threads/thread/constr/move_pass.cpp : thread__constr__move_pass ] - [ thread-run2 ./threads/thread/destr/dtor_pass.cpp : thread__destr__dtor_pass ] - [ thread-run2 ./threads/thread/id/hash_pass.cpp : thread__id__hash_pass ] - [ thread-run2 ./threads/thread/members/detach_pass.cpp : thread__members__detach_pass ] - [ thread-run2 ./threads/thread/members/get_id_pass.cpp : thread__members__get_id_pass ] - [ thread-run2 ./threads/thread/members/join_pass.cpp : thread__members__join_pass ] - [ thread-run2 ./threads/thread/members/joinable_pass.cpp : thread__members__joinable_pass ] - [ thread-run2 ./threads/thread/members/native_handle_pass.cpp : thread__members__native_handle_pass ] - [ thread-run2 ./threads/thread/members/swap_pass.cpp : thread__members__swap_pass ] - [ thread-run2 ./threads/thread/non_members/swap_pass.cpp : thread__non_members__swap_pass ] - [ thread-run2 ./threads/thread/static/hardware_concurrency_pass.cpp : thread__static__hardware_concurrency_pass ] + [ thread-compile-fail-V2 ./threads/thread/assign/copy_fail.cpp : : thread__assign__copy_f ] + [ thread-run2 ./threads/thread/assign/move_pass.cpp : thread__assign__move_p ] + [ thread-compile-fail-V2 ./threads/thread/constr/copy_fail.cpp : : thread__constr__copy_f ] + [ thread-run2 ./threads/thread/constr/default_pass.cpp : thread__constr__default_p ] + [ thread-run2 ./threads/thread/constr/F_pass.cpp : thread__constr__F_p ] + [ thread-run2 ./threads/thread/constr/Frvalue_pass.cpp : thread__constr__Frvalue_p ] + #[ thread-run2 ./threads/thread/constr/FrvalueArgs_pass.cpp : thread__constr__FrvalueArgs_p ] + [ thread-run2 ./threads/thread/constr/move_pass.cpp : thread__constr__move_p ] + [ thread-run2 ./threads/thread/destr/dtor_pass.cpp : thread__destr__dtor_p ] + [ thread-run2 ./threads/thread/id/hash_pass.cpp : thread__id__hash_p ] + [ thread-run2 ./threads/thread/members/detach_pass.cpp : thread__members__detach_p ] + [ thread-run2 ./threads/thread/members/get_id_pass.cpp : thread__members__get_id_p ] + [ thread-run2 ./threads/thread/members/join_pass.cpp : thread__members__join_p ] + [ thread-run2 ./threads/thread/members/joinable_pass.cpp : thread__members__joinable_p ] + [ thread-run2 ./threads/thread/members/native_handle_pass.cpp : thread__members__native_handle_p ] + [ thread-run2 ./threads/thread/members/swap_pass.cpp : thread__members__swap_p ] + [ thread-run2 ./threads/thread/non_members/swap_pass.cpp : thread__non_members__swap_p ] + [ thread-run2 ./threads/thread/static/hardware_concurrency_pass.cpp : thread__static__hardware_concurrency_p ] ; - #explicit ttt ; - #test-suite ttt - #: - #; + #explicit examples ; + test-suite examples + : + [ thread-run ../example/monitor.cpp ] + #[ thread-run ../example/starvephil.cpp ] + #[ thread-run ../example/tennis.cpp ] + #[ thread-run ../example/condition.cpp ] + [ thread-run ../example/mutex.cpp ] + [ thread-run ../example/once.cpp ] + [ thread-run ../example/recursive_mutex.cpp ] + [ thread-run2 ../example/thread.cpp : ex_thread ] + [ thread-run ../example/thread_group.cpp ] + [ thread-run ../example/tss.cpp ] + [ thread-run ../example/xtime.cpp ] + [ thread-run ../example/shared_monitor.cpp ] + [ thread-run ../example/shared_mutex.cpp ] + #[ thread-run ../example/v2_shared_monitor.cpp ] + #[ thread-run ../example/v2_shared_mutex.cpp ] + ; + explicit ttt ; + test-suite ttt + : + #[ thread-run2 ./sync/mutual_exclusion/locks/unique_lock/cons/move_ctor_upgrade_lock_pass.cpp : unique_lock__cons__move_ctor_upgrade_lock_p ] + ; } diff --git a/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp new file mode 100755 index 00000000..01c88204 --- /dev/null +++ b/test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2012 Vicente J. Botet Escriba +// +// 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) + +// + +// template class lock_guard; + +// lock_guard(mutex_type& m, adopt_lock_t); + +#include +#include +#include +#include + +typedef boost::chrono::high_resolution_clock Clock; +typedef Clock::time_point time_point; +typedef Clock::duration duration; +typedef boost::chrono::milliseconds ms; +typedef boost::chrono::nanoseconds ns; + +boost::mutex m; + +void f() +{ + time_point t0 = Clock::now(); + time_point t1; + { + m.lock(); + boost::lock_guard lg(m, boost::adopt_lock); + t1 = Clock::now(); + } + ns d = t1 - t0 - ms(250); + BOOST_TEST(d < ns(2500000)+ms(1000)); // within 2.5ms +} + +int main() +{ + m.lock(); + boost::thread t(f); + boost::this_thread::sleep_for(ms(250)); + m.unlock(); + t.join(); + + return boost::report_errors(); +} + diff --git a/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp new file mode 100755 index 00000000..a29f953b --- /dev/null +++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2011 Vicente J. Botet Escriba +// +// 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) + +// + +// template class lock_guard; + +// lock_guard& operator=(lock_guard const&) = delete; + +#include +#include +#include + +boost::mutex m0; +boost::mutex m1; + +int main() +{ + boost::lock_guard lk0(m0); + boost::lock_guard lk1(m1); + lk1 = lk0; + +} + diff --git a/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp b/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp new file mode 100755 index 00000000..50e0154e --- /dev/null +++ b/test/sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2011 Vicente J. Botet Escriba +// +// 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) + +// + +// template class lock_guard; + +// lock_guard(lock_guard const&) = delete; + + +#include +#include +#include + +boost::mutex m0; +boost::mutex m1; + +int main() +{ + boost::lock_guard lk0(m0); + boost::lock_guard lk1 = lk0; +} + diff --git a/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp new file mode 100755 index 00000000..72dff1cc --- /dev/null +++ b/test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp @@ -0,0 +1,56 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2011 Vicente J. Botet Escriba +// +// 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) + +// + +// template class lock_guard; + +// lock_guard(lock_guard const&) = delete; + +#include +#include +#include +#include + +typedef boost::chrono::high_resolution_clock Clock; +typedef Clock::time_point time_point; +typedef Clock::duration duration; +typedef boost::chrono::milliseconds ms; +typedef boost::chrono::nanoseconds ns; + +boost::mutex m; + +void f() +{ + time_point t0 = Clock::now(); + time_point t1; + { + boost::lock_guard lg(m); + t1 = Clock::now(); + } + ns d = t1 - t0 - ms(250); + // This test is spurious as it depends on the time the thread system switches the threads + BOOST_TEST(d < ns(2500000)+ms(1000)); // within 2.5ms +} + +int main() +{ + m.lock(); + boost::thread t(f); + boost::this_thread::sleep_for(ms(250)); + m.unlock(); + t.join(); + + return boost::report_errors(); +} diff --git a/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp b/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp new file mode 100755 index 00000000..161d69d5 --- /dev/null +++ b/test/sync/mutual_exclusion/locks/lock_guard/types_pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2012 Vicente J. Botet Escriba +// +// 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) + +// + +// + +// template +// class lock_guard +// { +// public: +// typedef Mutex mutex_type; +// ... +// }; + + +#include +#include +#include + +int main() +{ + BOOST_STATIC_ASSERT_MSG((boost::is_same::mutex_type, + boost::mutex>::value), ""); + + return boost::report_errors(); +} + diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp index fbbf0c92..272bc1a1 100755 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp @@ -40,7 +40,8 @@ void f1() BOOST_TEST(lk.owns_lock() == true); time_point t1 = Clock::now(); ns d = t1 - t0 - ms(250); - BOOST_TEST(d < ns(5000000)); // within 5ms + // This test is spurious as it depends on the time the thread system switches the threads + BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms } void f2() diff --git a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp index 211f704f..ab024a89 100755 --- a/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/locks/shared_lock/cons/move_assign_pass.cpp @@ -47,7 +47,7 @@ int main() { boost::unique_lock lk0(m0); boost::shared_lock lk1(m1); - lk1 = boost::move(lk0); + lk1 = boost::shared_lock(boost::move(lk0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); @@ -56,14 +56,14 @@ int main() { boost::shared_lock lk1; - lk1 = boost::unique_lock(m0); + lk1 = boost::shared_lock(boost::unique_lock(m0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); } { boost::upgrade_lock lk0(m0); boost::shared_lock lk1(m1); - lk1 = boost::move(lk0); + lk1 = boost::shared_lock(boost::move(lk0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); @@ -72,7 +72,7 @@ int main() { boost::shared_lock lk1; - lk1 = boost::upgrade_lock(m0); + lk1 = boost::shared_lock(boost::upgrade_lock(m0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); } diff --git a/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp new file mode 100755 index 00000000..f8b7b42a --- /dev/null +++ b/test/sync/mutual_exclusion/locks/shared_lock/types_pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2011 Vicente J. Botet Escriba +// +// 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) + +// + +// + +// template +// class shared_lock +// { +// public: +// typedef Mutex mutex_type; +// ... +// }; + + +#include +#include +#include + +int main() +{ + BOOST_STATIC_ASSERT_MSG((boost::is_same::mutex_type, + boost::shared_mutex>::value), ""); + + return boost::report_errors(); +} + diff --git a/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp index f6581fdc..db65d79f 100644 --- a/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp +++ b/test/sync/mutual_exclusion/locks/unique_lock/types_pass.cpp @@ -16,26 +16,23 @@ // -// struct defer_lock_t {}; -// struct try_to_lock_t {}; -// struct adopt_lock_t {}; -// -// constexpr defer_lock_t defer_lock{}; -// constexpr try_to_lock_t try_to_lock{}; -// constexpr adopt_lock_t adopt_lock{}; +// template +// class unique_lock +// { +// public: +// typedef Mutex mutex_type; +// ... +// }; + #include +#include #include int main() { - typedef boost::defer_lock_t T1; - typedef boost::try_to_lock_t T2; - typedef boost::adopt_lock_t T3; - - T1 t1 = boost::defer_lock; - T2 t2 = boost::try_to_lock; - T3 t3 = boost::adopt_lock; + BOOST_STATIC_ASSERT_MSG((boost::is_same::mutex_type, + boost::mutex>::value), ""); return boost::report_errors(); } diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp index e0035dc5..f252f7d3 100755 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp @@ -40,7 +40,8 @@ void f1() BOOST_TEST(lk.owns_lock() == true); time_point t1 = Clock::now(); ns d = t1 - t0 - ms(250); - BOOST_TEST(d < ns(5000000)); // within 5ms + // This test is spurious as it depends on the time the thread system switches the threads + BOOST_TEST(d < ns(5000000)+ms(1000)); // within 5ms } void f2() diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp index d8848759..c33a060b 100755 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/move_assign_pass.cpp @@ -47,7 +47,7 @@ int main() { boost::unique_lock lk0(m0); boost::upgrade_lock lk1(m1); - lk1 = boost::move(lk0); + lk1 = boost::upgrade_lock(boost::move(lk0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); BOOST_TEST(lk0.mutex() == 0); @@ -56,7 +56,7 @@ int main() { boost::upgrade_lock lk1; - lk1 = boost::unique_lock(m0); + lk1 = boost::upgrade_lock(boost::unique_lock(m0)); BOOST_TEST(lk1.mutex() == &m0); BOOST_TEST(lk1.owns_lock() == true); } diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp index ce2886f7..cb186d3c 100755 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp @@ -14,10 +14,10 @@ // -// template class shared_lock; +// template class upgrade_lock; // template -// shared_lock(mutex_type& m, const chrono::time_point& abs_time); +// upgrade_lock(mutex_type& m, const chrono::time_point& abs_time); #include #include @@ -35,7 +35,7 @@ typedef boost::chrono::nanoseconds ns; void f1() { time_point t0 = Clock::now(); - boost::shared_lock lk(m, Clock::now() + ms(300)); + boost::upgrade_lock lk(m, Clock::now() + ms(300)); BOOST_TEST(lk.owns_lock() == true); time_point t1 = Clock::now(); ns d = t1 - t0 - ms(250); @@ -45,7 +45,7 @@ void f1() void f2() { time_point t0 = Clock::now(); - boost::shared_lock lk(m, Clock::now() + ms(250)); + boost::upgrade_lock lk(m, Clock::now() + ms(250)); BOOST_TEST(lk.owns_lock() == false); time_point t1 = Clock::now(); ns d = t1 - t0 - ms(250); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp index 11a54531..59566756 100755 --- a/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp @@ -14,9 +14,9 @@ // -// template class shared_lock; +// template class upgrade_lock; -// shared_lock(mutex_type& m, try_to_lock_t); +// upgrade_lock(mutex_type& m, try_to_lock_t); #include @@ -36,20 +36,20 @@ void f() { time_point t0 = Clock::now(); { - boost::shared_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(m, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::shared_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(m, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } { - boost::shared_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(m, boost::try_to_lock); BOOST_TEST(lk.owns_lock() == false); } while (true) { - boost::shared_lock lk(m, boost::try_to_lock); + boost::upgrade_lock lk(m, boost::try_to_lock); if (lk.owns_lock()) break; } time_point t1 = Clock::now(); diff --git a/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp b/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp new file mode 100755 index 00000000..f178b73e --- /dev/null +++ b/test/sync/mutual_exclusion/locks/upgrade_lock/types_pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Copyright (C) 2011 Vicente J. Botet Escriba +// +// 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) + +// + +// + +// template +// class upgrade_lock +// { +// public: +// typedef Mutex mutex_type; +// ... +// }; + + +#include +#include +#include + +int main() +{ + BOOST_STATIC_ASSERT_MSG((boost::is_same::mutex_type, + boost::upgrade_mutex>::value), ""); + + return boost::report_errors(); +} + diff --git a/test/test_thread_launching.cpp b/test/test_thread_launching.cpp index 714f33bf..086a2af4 100644 --- a/test/test_thread_launching.cpp +++ b/test/test_thread_launching.cpp @@ -145,8 +145,10 @@ void test_thread_callable_object_multiple_arguments() } callable_multiple_arg func; - - boost::thread callable3(func,"hello",x,1.2); + // Avoid + // boost/bind/bind.hpp(392) : warning C4244: 'argument' : conversion from 'double' to 'int', possible loss of data + + boost::thread callable3(func,"hello",x,1); callable3.join(); BOOST_CHECK(callable_multiple_arg::called_three); BOOST_CHECK_EQUAL(callable_multiple_arg::called_three_arg1,"hello");