diff options
13 files changed, 1077 insertions, 2 deletions
diff --git a/libcxx/include/future b/libcxx/include/future index b75014ac123..4189d88165e 100644 --- a/libcxx/include/future +++ b/libcxx/include/future @@ -257,7 +257,7 @@ class shared_future<R&> public: shared_future(); shared_future(const shared_future& rhs); - shared_future(future<R>&&); + shared_future(future<R&>&&); shared_future(shared_future&& rhs); ~shared_future(); shared_future& operator=(const shared_future& rhs); @@ -284,7 +284,7 @@ class shared_future<void> public: shared_future(); shared_future(const shared_future& rhs); - shared_future(future<R>&&); + shared_future(future<void>&&); shared_future(shared_future&& rhs); ~shared_future(); shared_future& operator=(const shared_future& rhs); @@ -919,6 +919,8 @@ __deferred_assoc_state<void, _F>::__execute() } template <class> class promise; +template <class> class shared_future; +template <class> class atomic_future; // future @@ -940,6 +942,8 @@ class future explicit future(__assoc_state<_R>* __state); template <class> friend class promise; + template <class> friend class shared_future; + template <class> friend class atomic_future; template <class _R1, class _F> #ifdef _LIBCPP_MOVE @@ -1027,6 +1031,8 @@ class future<_R&> explicit future(__assoc_state<_R&>* __state); template <class> friend class promise; + template <class> friend class shared_future; + template <class> friend class atomic_future; template <class _R1, class _F> #ifdef _LIBCPP_MOVE @@ -1109,6 +1115,8 @@ class future<void> explicit future(__assoc_sub_state* __state); template <class> friend class promise; + template <class> friend class shared_future; + template <class> friend class atomic_future; template <class _R1, class _F> #ifdef _LIBCPP_MOVE @@ -1156,6 +1164,14 @@ public: {return __state_->wait_until(__abs_time);} }; +template <class _R> +inline _LIBCPP_INLINE_VISIBILITY +void +swap(future<_R>& __x, future<_R>& __y) +{ + __x.swap(__y); +} + // promise<R> template <class> class packaged_task; @@ -2050,6 +2066,184 @@ async(_F&& __f, _Args&&... __args) #endif // _LIBCPP_HAS_NO_VARIADICS +template <class _R> +class shared_future +{ + __assoc_state<_R>* __state_; + +public: + shared_future() : __state_(nullptr) {} + shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) + {if (__state_) __state_->__add_shared();} +#ifdef _LIBCPP_MOVE + shared_future(future<_R>&& __f) : __state_(__f.__state_) + {__f.__state_ = nullptr;} + shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) + {__rhs.__state_ = nullptr;} +#endif // _LIBCPP_MOVE + ~shared_future(); + shared_future& operator=(const shared_future& __rhs); +#ifdef _LIBCPP_MOVE + shared_future& operator=(shared_future&& __rhs) + { + shared_future(std::move(__rhs)).swap(*this); + return *this; + } +#endif // _LIBCPP_MOVE + + // retrieving the value + const _R& get() const {return __state_->copy();} + + void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);} + + // functions to check state + bool valid() const {return __state_ != nullptr;} + + void wait() const {__state_->wait();} + template <class _Rep, class _Period> + future_status + wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const + {return __state_->wait_for(__rel_time);} + template <class _Clock, class _Duration> + future_status + wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const + {return __state_->wait_until(__abs_time);} +}; + +template <class _R> +shared_future<_R>::~shared_future() +{ + if (__state_) + __state_->__release_shared(); +} + +template <class _R> +shared_future<_R>& +shared_future<_R>::operator=(const shared_future& __rhs) +{ + if (__rhs.__state_) + __rhs.__state_->__add_shared(); + if (__state_) + __state_->__release_shared(); + __state_ = __rhs.__state_; + return *this; +} + +template <class _R> +class shared_future<_R&> +{ + __assoc_state<_R&>* __state_; + +public: + shared_future() : __state_(nullptr) {} + shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) + {if (__state_) __state_->__add_shared();} +#ifdef _LIBCPP_MOVE + shared_future(future<_R&>&& __f) : __state_(__f.__state_) + {__f.__state_ = nullptr;} + shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) + {__rhs.__state_ = nullptr;} +#endif // _LIBCPP_MOVE + ~shared_future(); + shared_future& operator=(const shared_future& __rhs); +#ifdef _LIBCPP_MOVE + shared_future& operator=(shared_future&& __rhs) + { + shared_future(std::move(__rhs)).swap(*this); + return *this; + } +#endif // _LIBCPP_MOVE + + // retrieving the value + _R& get() const {return __state_->copy();} + + void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);} + + // functions to check state + bool valid() const {return __state_ != nullptr;} + + void wait() const {__state_->wait();} + template <class _Rep, class _Period> + future_status + wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const + {return __state_->wait_for(__rel_time);} + template <class _Clock, class _Duration> + future_status + wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const + {return __state_->wait_until(__abs_time);} +}; + +template <class _R> +shared_future<_R&>::~shared_future() +{ + if (__state_) + __state_->__release_shared(); +} + +template <class _R> +shared_future<_R&>& +shared_future<_R&>::operator=(const shared_future& __rhs) +{ + if (__rhs.__state_) + __rhs.__state_->__add_shared(); + if (__state_) + __state_->__release_shared(); + __state_ = __rhs.__state_; + return *this; +} + +template <> +class shared_future<void> +{ + __assoc_sub_state* __state_; + +public: + shared_future() : __state_(nullptr) {} + shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) + {if (__state_) __state_->__add_shared();} +#ifdef _LIBCPP_MOVE + shared_future(future<void>&& __f) : __state_(__f.__state_) + {__f.__state_ = nullptr;} + shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) + {__rhs.__state_ = nullptr;} +#endif // _LIBCPP_MOVE + ~shared_future(); + shared_future& operator=(const shared_future& __rhs); +#ifdef _LIBCPP_MOVE + shared_future& operator=(shared_future&& __rhs) + { + shared_future(std::move(__rhs)).swap(*this); + return *this; + } +#endif // _LIBCPP_MOVE + + // retrieving the value + void get() const {__state_->copy();} + + void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);} + + // functions to check state + bool valid() const {return __state_ != nullptr;} + + void wait() const {__state_->wait();} + template <class _Rep, class _Period> + future_status + wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const + {return __state_->wait_for(__rel_time);} + template <class _Clock, class _Duration> + future_status + wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const + {return __state_->wait_until(__abs_time);} +}; + +template <class _R> +inline _LIBCPP_INLINE_VISIBILITY +void +swap(shared_future<_R>& __x, shared_future<_R>& __y) +{ + __x.swap(__y); +} + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_FUTURE diff --git a/libcxx/src/future.cpp b/libcxx/src/future.cpp index a0082767122..924a6846869 100644 --- a/libcxx/src/future.cpp +++ b/libcxx/src/future.cpp @@ -240,4 +240,21 @@ promise<void>::set_exception_at_thread_exit(exception_ptr __p) __state_->set_exception_at_thread_exit(__p); } +shared_future<void>::~shared_future() +{ + if (__state_) + __state_->__release_shared(); +} + +shared_future<void>& +shared_future<void>::operator=(const shared_future& __rhs) +{ + if (__rhs.__state_) + __rhs.__state_->__add_shared(); + if (__state_) + __state_->__release_shared(); + __state_ = __rhs.__state_; + return *this; +} + _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/test/thread/futures/futures.shared_future/copy_assign.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/copy_assign.pass.cpp new file mode 100644 index 00000000000..04dc1f86724 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/copy_assign.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future& operator=(const shared_future& rhs); + +#include <future> +#include <cassert> + +int main() +{ +#ifdef _LIBCPP_MOVE + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } +#endif // _LIBCPP_MOVE +} diff --git a/libcxx/test/thread/futures/futures.shared_future/copy_ctor.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/copy_ctor.pass.cpp new file mode 100644 index 00000000000..ec17da04256 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/copy_ctor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future(const shared_future& rhs); + +#include <future> +#include <cassert> + +int main() +{ + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::shared_future<T> f0; + std::shared_future<T> f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::shared_future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = f0; + assert(f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::shared_future<T> f0; + std::shared_future<T> f = f0; + assert(!f0.valid()); + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/ctor_future.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/ctor_future.pass.cpp new file mode 100644 index 00000000000..2fb83ff7878 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/ctor_future.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future(future<R>&& rhs); + +#include <future> +#include <cassert> + +int main() +{ + { + typedef int T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/default.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/default.pass.cpp new file mode 100644 index 00000000000..07ec85a0ce7 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/default.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future(); + +#include <future> +#include <cassert> + +int main() +{ + { + std::shared_future<int> f; + assert(!f.valid()); + } + { + std::shared_future<int&> f; + assert(!f.valid()); + } + { + std::shared_future<void> f; + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/dtor.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/dtor.pass.cpp new file mode 100644 index 00000000000..d773a80a23c --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/dtor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// ~shared_future(); + +#include <future> +#include <cassert> + +#include "../test_allocator.h" + +int main() +{ + assert(test_alloc_base::count == 0); + { + typedef int T; + std::shared_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<T>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); + { + typedef int& T; + std::shared_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<int>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); + { + typedef void T; + std::shared_future<T> f; + { + std::promise<T> p(std::allocator_arg, test_allocator<T>()); + assert(test_alloc_base::count == 1); + f = p.get_future(); + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 1); + assert(f.valid()); + } + assert(test_alloc_base::count == 0); +} diff --git a/libcxx/test/thread/futures/futures.shared_future/get.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/get.pass.cpp new file mode 100644 index 00000000000..d3445134599 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/get.pass.cpp @@ -0,0 +1,143 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// const R& shared_future::get(); +// R& shared_future<R&>::get(); +// void shared_future<void>::get(); + +#include <future> +#include <cassert> + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(3); +} + +void func2(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr(3)); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + j = 5; + p.set_value(j); +} + +void func4(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr(3.5)); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(); +} + +void func6(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_exception(std::make_exception_ptr('c')); +} + +int main() +{ + { + typedef int T; + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.get() == 3); + assert(f.valid()); + } + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func2, std::move(p)).detach(); + try + { + assert(f.valid()); + assert(f.get() == 3); + assert(false); + } + catch (int i) + { + assert(i == 3); + } + assert(f.valid()); + } + } + { + typedef int& T; + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.get() == 5); + assert(f.valid()); + } + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func4, std::move(p)).detach(); + try + { + assert(f.valid()); + assert(f.get() == 3); + assert(false); + } + catch (double i) + { + assert(i == 3.5); + } + assert(f.valid()); + } + } + { + typedef void T; + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + f.get(); + assert(f.valid()); + } + { + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func6, std::move(p)).detach(); + try + { + assert(f.valid()); + f.get(); + assert(false); + } + catch (char i) + { + assert(i == 'c'); + } + assert(f.valid()); + } + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/move_assign.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/move_assign.pass.cpp new file mode 100644 index 00000000000..496bac5ae5e --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/move_assign.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future& operator=(shared_future&& rhs); + +#include <future> +#include <cassert> + +int main() +{ +#ifdef _LIBCPP_MOVE + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::shared_future<T> f0; + std::shared_future<T> f; + f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } +#endif // _LIBCPP_MOVE +} diff --git a/libcxx/test/thread/futures/futures.shared_future/move_ctor.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/move_ctor.pass.cpp new file mode 100644 index 00000000000..2130071c75c --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/move_ctor.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// shared_future(shared_future&& rhs); + +#include <future> +#include <cassert> + +int main() +{ + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int T; + std::shared_future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef int& T; + std::shared_future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f0 = p.get_future(); + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(f.valid()); + } + { + typedef void T; + std::shared_future<T> f0; + std::shared_future<T> f = std::move(f0); + assert(!f0.valid()); + assert(!f.valid()); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/wait.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/wait.pass.cpp new file mode 100644 index 00000000000..1bcafb14c24 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/wait.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// void wait() const; + +#include <future> +#include <cassert> + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + typedef std::chrono::duration<double, std::milli> ms; + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + f.wait(); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/wait_for.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/wait_for.pass.cpp new file mode 100644 index 00000000000..bb3bb79f490 --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/wait_for.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// template <class Rep, class Period> +// future_status +// wait_for(const chrono::duration<Rep, Period>& rel_time) const; + +#include <future> +#include <cassert> + +typedef std::chrono::milliseconds ms; + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(ms(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_for(ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} diff --git a/libcxx/test/thread/futures/futures.shared_future/wait_until.pass.cpp b/libcxx/test/thread/futures/futures.shared_future/wait_until.pass.cpp new file mode 100644 index 00000000000..aac0ff2d46a --- /dev/null +++ b/libcxx/test/thread/futures/futures.shared_future/wait_until.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <future> + +// class shared_future<R> + +// template <class Clock, class Duration> +// future_status +// wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; + +#include <future> +#include <cassert> + +typedef std::chrono::milliseconds ms; + +void func1(std::promise<int>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(3); +} + +int j = 0; + +void func3(std::promise<int&>& p) +{ + std::this_thread::sleep_for(ms(500)); + j = 5; + p.set_value(j); +} + +void func5(std::promise<void>& p) +{ + std::this_thread::sleep_for(ms(500)); + p.set_value(); +} + +int main() +{ + typedef std::chrono::high_resolution_clock Clock; + { + typedef int T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func1, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef int& T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func3, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } + { + typedef void T; + std::promise<T> p; + std::shared_future<T> f = p.get_future(); + std::thread(func5, std::move(p)).detach(); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::timeout); + assert(f.valid()); + assert(f.wait_until(Clock::now() + ms(300)) == std::future_status::ready); + assert(f.valid()); + Clock::time_point t0 = Clock::now(); + f.wait(); + Clock::time_point t1 = Clock::now(); + assert(f.valid()); + assert(t1-t0 < ms(5)); + } +} |
