1// <future> -*- C++ -*- 2 3// Copyright (C) 2009-2016 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/** @file include/future 26 * This is a Standard C++ Library header. 27 */ 28 29#ifndef _GLIBCXX_FUTURE 30#define _GLIBCXX_FUTURE 1 31 32#pragma GCC system_header 33 34#if __cplusplus < 201103L 35# include <bits/c++0x_warning.h> 36#else 37 38#include <functional> 39#include <mutex> 40#include <thread> 41#include <condition_variable> 42#include <system_error> 43#include <atomic> 44#include <bits/atomic_futex.h> 45#include <bits/functexcept.h> 46#include <bits/unique_ptr.h> 47#include <bits/shared_ptr.h> 48#include <bits/uses_allocator.h> 49#include <bits/allocated_ptr.h> 50#include <ext/aligned_buffer.h> 51 52namespace std _GLIBCXX_VISIBILITY(default) 53{ 54_GLIBCXX_BEGIN_NAMESPACE_VERSION 55 56 /** 57 * @defgroup futures Futures 58 * @ingroup concurrency 59 * 60 * Classes for futures support. 61 * @{ 62 */ 63 64 /// Error code for futures 65 enum class future_errc 66 { 67 future_already_retrieved = 1, 68 promise_already_satisfied, 69 no_state, 70 broken_promise 71 }; 72 73 /// Specialization. 74 template<> 75 struct is_error_code_enum<future_errc> : public true_type { }; 76 77 /// Points to a statically-allocated object derived from error_category. 78 const error_category& 79 future_category() noexcept; 80 81 /// Overload for make_error_code. 82 inline error_code 83 make_error_code(future_errc __errc) noexcept 84 { return error_code(static_cast<int>(__errc), future_category()); } 85 86 /// Overload for make_error_condition. 87 inline error_condition 88 make_error_condition(future_errc __errc) noexcept 89 { return error_condition(static_cast<int>(__errc), future_category()); } 90 91 /** 92 * @brief Exception type thrown by futures. 93 * @ingroup exceptions 94 */ 95 class future_error : public logic_error 96 { 97 error_code _M_code; 98 99 public: 100 explicit future_error(error_code __ec) 101 : logic_error("std::future_error: " + __ec.message()), _M_code(__ec) 102 { } 103 104 virtual ~future_error() noexcept; 105 106 virtual const char* 107 what() const noexcept; 108 109 const error_code& 110 code() const noexcept { return _M_code; } 111 }; 112 113 // Forward declarations. 114 template<typename _Res> 115 class future; 116 117 template<typename _Res> 118 class shared_future; 119 120 template<typename _Signature> 121 class packaged_task; 122 123 template<typename _Res> 124 class promise; 125 126 /// Launch code for futures 127 enum class launch 128 { 129 async = 1, 130 deferred = 2 131 }; 132 133 constexpr launch operator&(launch __x, launch __y) 134 { 135 return static_cast<launch>( 136 static_cast<int>(__x) & static_cast<int>(__y)); 137 } 138 139 constexpr launch operator|(launch __x, launch __y) 140 { 141 return static_cast<launch>( 142 static_cast<int>(__x) | static_cast<int>(__y)); 143 } 144 145 constexpr launch operator^(launch __x, launch __y) 146 { 147 return static_cast<launch>( 148 static_cast<int>(__x) ^ static_cast<int>(__y)); 149 } 150 151 constexpr launch operator~(launch __x) 152 { return static_cast<launch>(~static_cast<int>(__x)); } 153 154 inline launch& operator&=(launch& __x, launch __y) 155 { return __x = __x & __y; } 156 157 inline launch& operator|=(launch& __x, launch __y) 158 { return __x = __x | __y; } 159 160 inline launch& operator^=(launch& __x, launch __y) 161 { return __x = __x ^ __y; } 162 163 /// Status code for futures 164 enum class future_status 165 { 166 ready, 167 timeout, 168 deferred 169 }; 170 171 // _GLIBCXX_RESOLVE_LIB_DEFECTS 172 // 2021. Further incorrect usages of result_of 173 template<typename _Fn, typename... _Args> 174 using __async_result_of = typename result_of< 175 typename decay<_Fn>::type(typename decay<_Args>::type...)>::type; 176 177 template<typename _Fn, typename... _Args> 178 future<__async_result_of<_Fn, _Args...>> 179 async(launch __policy, _Fn&& __fn, _Args&&... __args); 180 181 template<typename _Fn, typename... _Args> 182 future<__async_result_of<_Fn, _Args...>> 183 async(_Fn&& __fn, _Args&&... __args); 184 185#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \ 186 && (ATOMIC_INT_LOCK_FREE > 1) 187 188 /// Base class and enclosing scope. 189 struct __future_base 190 { 191 /// Base class for results. 192 struct _Result_base 193 { 194 exception_ptr _M_error; 195 196 _Result_base(const _Result_base&) = delete; 197 _Result_base& operator=(const _Result_base&) = delete; 198 199 // _M_destroy() allows derived classes to control deallocation 200 virtual void _M_destroy() = 0; 201 202 struct _Deleter 203 { 204 void operator()(_Result_base* __fr) const { __fr->_M_destroy(); } 205 }; 206 207 protected: 208 _Result_base(); 209 virtual ~_Result_base(); 210 }; 211 212 /// A unique_ptr for result objects. 213 template<typename _Res> 214 using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>; 215 216 /// A result object that has storage for an object of type _Res. 217 template<typename _Res> 218 struct _Result : _Result_base 219 { 220 private: 221 __gnu_cxx::__aligned_buffer<_Res> _M_storage; 222 bool _M_initialized; 223 224 public: 225 typedef _Res result_type; 226 227 _Result() noexcept : _M_initialized() { } 228 229 ~_Result() 230 { 231 if (_M_initialized) 232 _M_value().~_Res(); 233 } 234 235 // Return lvalue, future will add const or rvalue-reference 236 _Res& 237 _M_value() noexcept { return *_M_storage._M_ptr(); } 238 239 void 240 _M_set(const _Res& __res) 241 { 242 ::new (_M_storage._M_addr()) _Res(__res); 243 _M_initialized = true; 244 } 245 246 void 247 _M_set(_Res&& __res) 248 { 249 ::new (_M_storage._M_addr()) _Res(std::move(__res)); 250 _M_initialized = true; 251 } 252 253 private: 254 void _M_destroy() { delete this; } 255 }; 256 257 /// A result object that uses an allocator. 258 template<typename _Res, typename _Alloc> 259 struct _Result_alloc final : _Result<_Res>, _Alloc 260 { 261 using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>; 262 263 explicit 264 _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) 265 { } 266 267 private: 268 void _M_destroy() 269 { 270 __allocator_type __a(*this); 271 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; 272 this->~_Result_alloc(); 273 } 274 }; 275 276 // Create a result object that uses an allocator. 277 template<typename _Res, typename _Allocator> 278 static _Ptr<_Result_alloc<_Res, _Allocator>> 279 _S_allocate_result(const _Allocator& __a) 280 { 281 using __result_type = _Result_alloc<_Res, _Allocator>; 282 typename __result_type::__allocator_type __a2(__a); 283 auto __guard = std::__allocate_guarded(__a2); 284 __result_type* __p = ::new((void*)__guard.get()) __result_type{__a}; 285 __guard = nullptr; 286 return _Ptr<__result_type>(__p); 287 } 288 289 // Keep it simple for std::allocator. 290 template<typename _Res, typename _Tp> 291 static _Ptr<_Result<_Res>> 292 _S_allocate_result(const std::allocator<_Tp>& __a) 293 { 294 return _Ptr<_Result<_Res>>(new _Result<_Res>); 295 } 296 297 // Base class for various types of shared state created by an 298 // asynchronous provider (such as a std::promise) and shared with one 299 // or more associated futures. 300 class _State_baseV2 301 { 302 typedef _Ptr<_Result_base> _Ptr_type; 303 304 enum _Status : unsigned { 305 __not_ready, 306 __ready 307 }; 308 309 _Ptr_type _M_result; 310 __atomic_futex_unsigned<> _M_status; 311 atomic_flag _M_retrieved = ATOMIC_FLAG_INIT; 312 once_flag _M_once; 313 314 public: 315 _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready) 316 { } 317 _State_baseV2(const _State_baseV2&) = delete; 318 _State_baseV2& operator=(const _State_baseV2&) = delete; 319 virtual ~_State_baseV2() = default; 320 321 _Result_base& 322 wait() 323 { 324 // Run any deferred function or join any asynchronous thread: 325 _M_complete_async(); 326 // Acquire MO makes sure this synchronizes with the thread that made 327 // the future ready. 328 _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire); 329 return *_M_result; 330 } 331 332 template<typename _Rep, typename _Period> 333 future_status 334 wait_for(const chrono::duration<_Rep, _Period>& __rel) 335 { 336 // First, check if the future has been made ready. Use acquire MO 337 // to synchronize with the thread that made it ready. 338 if (_M_status._M_load(memory_order_acquire) == _Status::__ready) 339 return future_status::ready; 340 if (_M_is_deferred_future()) 341 return future_status::deferred; 342 if (_M_status._M_load_when_equal_for(_Status::__ready, 343 memory_order_acquire, __rel)) 344 { 345 // _GLIBCXX_RESOLVE_LIB_DEFECTS 346 // 2100. timed waiting functions must also join 347 // This call is a no-op by default except on an async future, 348 // in which case the async thread is joined. It's also not a 349 // no-op for a deferred future, but such a future will never 350 // reach this point because it returns future_status::deferred 351 // instead of waiting for the future to become ready (see 352 // above). Async futures synchronize in this call, so we need 353 // no further synchronization here. 354 _M_complete_async(); 355 356 return future_status::ready; 357 } 358 return future_status::timeout; 359 } 360 361 template<typename _Clock, typename _Duration> 362 future_status 363 wait_until(const chrono::time_point<_Clock, _Duration>& __abs) 364 { 365 // First, check if the future has been made ready. Use acquire MO 366 // to synchronize with the thread that made it ready. 367 if (_M_status._M_load(memory_order_acquire) == _Status::__ready) 368 return future_status::ready; 369 if (_M_is_deferred_future()) 370 return future_status::deferred; 371 if (_M_status._M_load_when_equal_until(_Status::__ready, 372 memory_order_acquire, __abs)) 373 { 374 // _GLIBCXX_RESOLVE_LIB_DEFECTS 375 // 2100. timed waiting functions must also join 376 // See wait_for(...) above. 377 _M_complete_async(); 378 379 return future_status::ready; 380 } 381 return future_status::timeout; 382 } 383 384 // Provide a result to the shared state and make it ready. 385 // Calls at most once: _M_result = __res(); 386 void 387 _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false) 388 { 389 bool __did_set = false; 390 // all calls to this function are serialized, 391 // side-effects of invoking __res only happen once 392 call_once(_M_once, &_State_baseV2::_M_do_set, this, 393 std::__addressof(__res), std::__addressof(__did_set)); 394 if (__did_set) 395 // Use release MO to synchronize with observers of the ready state. 396 _M_status._M_store_notify_all(_Status::__ready, 397 memory_order_release); 398 else if (!__ignore_failure) 399 __throw_future_error(int(future_errc::promise_already_satisfied)); 400 } 401 402 // Provide a result to the shared state but delay making it ready 403 // until the calling thread exits. 404 // Calls at most once: _M_result = __res(); 405 void 406 _M_set_delayed_result(function<_Ptr_type()> __res, 407 weak_ptr<_State_baseV2> __self) 408 { 409 bool __did_set = false; 410 unique_ptr<_Make_ready> __mr{new _Make_ready}; 411 // all calls to this function are serialized, 412 // side-effects of invoking __res only happen once 413 call_once(_M_once, &_State_baseV2::_M_do_set, this, 414 std::__addressof(__res), std::__addressof(__did_set)); 415 if (!__did_set) 416 __throw_future_error(int(future_errc::promise_already_satisfied)); 417 __mr->_M_shared_state = std::move(__self); 418 __mr->_M_set(); 419 __mr.release(); 420 } 421 422 // Abandon this shared state. 423 void 424 _M_break_promise(_Ptr_type __res) 425 { 426 if (static_cast<bool>(__res)) 427 { 428 error_code __ec(make_error_code(future_errc::broken_promise)); 429 __res->_M_error = make_exception_ptr(future_error(__ec)); 430 // This function is only called when the last asynchronous result 431 // provider is abandoning this shared state, so noone can be 432 // trying to make the shared state ready at the same time, and 433 // we can access _M_result directly instead of through call_once. 434 _M_result.swap(__res); 435 // Use release MO to synchronize with observers of the ready state. 436 _M_status._M_store_notify_all(_Status::__ready, 437 memory_order_release); 438 } 439 } 440 441 // Called when this object is first passed to a future. 442 void 443 _M_set_retrieved_flag() 444 { 445 if (_M_retrieved.test_and_set()) 446 __throw_future_error(int(future_errc::future_already_retrieved)); 447 } 448 449 template<typename _Res, typename _Arg> 450 struct _Setter; 451 452 // set lvalues 453 template<typename _Res, typename _Arg> 454 struct _Setter<_Res, _Arg&> 455 { 456 // check this is only used by promise<R>::set_value(const R&) 457 // or promise<R&>::set_value(R&) 458 static_assert(is_same<_Res, _Arg&>::value // promise<R&> 459 || is_same<const _Res, _Arg>::value, // promise<R> 460 "Invalid specialisation"); 461 462 // Used by std::promise to copy construct the result. 463 typename promise<_Res>::_Ptr_type operator()() const 464 { 465 _State_baseV2::_S_check(_M_promise->_M_future); 466 _M_promise->_M_storage->_M_set(*_M_arg); 467 return std::move(_M_promise->_M_storage); 468 } 469 promise<_Res>* _M_promise; 470 _Arg* _M_arg; 471 }; 472 473 // set rvalues 474 template<typename _Res> 475 struct _Setter<_Res, _Res&&> 476 { 477 // Used by std::promise to move construct the result. 478 typename promise<_Res>::_Ptr_type operator()() const 479 { 480 _State_baseV2::_S_check(_M_promise->_M_future); 481 _M_promise->_M_storage->_M_set(std::move(*_M_arg)); 482 return std::move(_M_promise->_M_storage); 483 } 484 promise<_Res>* _M_promise; 485 _Res* _M_arg; 486 }; 487 488 struct __exception_ptr_tag { }; 489 490 // set exceptions 491 template<typename _Res> 492 struct _Setter<_Res, __exception_ptr_tag> 493 { 494 // Used by std::promise to store an exception as the result. 495 typename promise<_Res>::_Ptr_type operator()() const 496 { 497 _State_baseV2::_S_check(_M_promise->_M_future); 498 _M_promise->_M_storage->_M_error = *_M_ex; 499 return std::move(_M_promise->_M_storage); 500 } 501 502 promise<_Res>* _M_promise; 503 exception_ptr* _M_ex; 504 }; 505 506 template<typename _Res, typename _Arg> 507 static _Setter<_Res, _Arg&&> 508 __setter(promise<_Res>* __prom, _Arg&& __arg) 509 { 510 return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) }; 511 } 512 513 template<typename _Res> 514 static _Setter<_Res, __exception_ptr_tag> 515 __setter(exception_ptr& __ex, promise<_Res>* __prom) 516 { 517 return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex }; 518 } 519 520 template<typename _Tp> 521 static void 522 _S_check(const shared_ptr<_Tp>& __p) 523 { 524 if (!static_cast<bool>(__p)) 525 __throw_future_error((int)future_errc::no_state); 526 } 527 528 private: 529 // The function invoked with std::call_once(_M_once, ...). 530 void 531 _M_do_set(function<_Ptr_type()>* __f, bool* __did_set) 532 { 533 _Ptr_type __res = (*__f)(); 534 // Notify the caller that we did try to set; if we do not throw an 535 // exception, the caller will be aware that it did set (e.g., see 536 // _M_set_result). 537 *__did_set = true; 538 _M_result.swap(__res); // nothrow 539 } 540 541 // Wait for completion of async function. 542 virtual void _M_complete_async() { } 543 544 // Return true if state corresponds to a deferred function. 545 virtual bool _M_is_deferred_future() const { return false; } 546 547 struct _Make_ready final : __at_thread_exit_elt 548 { 549 weak_ptr<_State_baseV2> _M_shared_state; 550 static void _S_run(void*); 551 void _M_set(); 552 }; 553 }; 554 555#ifdef _GLIBCXX_ASYNC_ABI_COMPAT 556 class _State_base; 557 class _Async_state_common; 558#else 559 using _State_base = _State_baseV2; 560 class _Async_state_commonV2; 561#endif 562 563 template<typename _BoundFn, typename = typename _BoundFn::result_type> 564 class _Deferred_state; 565 566 template<typename _BoundFn, typename = typename _BoundFn::result_type> 567 class _Async_state_impl; 568 569 template<typename _Signature> 570 class _Task_state_base; 571 572 template<typename _Fn, typename _Alloc, typename _Signature> 573 class _Task_state; 574 575 template<typename _BoundFn> 576 static std::shared_ptr<_State_base> 577 _S_make_deferred_state(_BoundFn&& __fn); 578 579 template<typename _BoundFn> 580 static std::shared_ptr<_State_base> 581 _S_make_async_state(_BoundFn&& __fn); 582 583 template<typename _Res_ptr, typename _Fn, 584 typename _Res = typename _Res_ptr::element_type::result_type> 585 struct _Task_setter; 586 587 template<typename _Res_ptr, typename _BoundFn> 588 static _Task_setter<_Res_ptr, _BoundFn> 589 _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call) 590 { 591 return { std::__addressof(__ptr), std::__addressof(__call) }; 592 } 593 }; 594 595 /// Partial specialization for reference types. 596 template<typename _Res> 597 struct __future_base::_Result<_Res&> : __future_base::_Result_base 598 { 599 typedef _Res& result_type; 600 601 _Result() noexcept : _M_value_ptr() { } 602 603 void 604 _M_set(_Res& __res) noexcept 605 { _M_value_ptr = std::addressof(__res); } 606 607 _Res& _M_get() noexcept { return *_M_value_ptr; } 608 609 private: 610 _Res* _M_value_ptr; 611 612 void _M_destroy() { delete this; } 613 }; 614 615 /// Explicit specialization for void. 616 template<> 617 struct __future_base::_Result<void> : __future_base::_Result_base 618 { 619 typedef void result_type; 620 621 private: 622 void _M_destroy() { delete this; } 623 }; 624 625#ifndef _GLIBCXX_ASYNC_ABI_COMPAT 626 627 // Allow _Setter objects to be stored locally in std::function 628 template<typename _Res, typename _Arg> 629 struct __is_location_invariant 630 <__future_base::_State_base::_Setter<_Res, _Arg>> 631 : true_type { }; 632 633 // Allow _Task_setter objects to be stored locally in std::function 634 template<typename _Res_ptr, typename _Fn, typename _Res> 635 struct __is_location_invariant 636 <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>> 637 : true_type { }; 638 639 /// Common implementation for future and shared_future. 640 template<typename _Res> 641 class __basic_future : public __future_base 642 { 643 protected: 644 typedef shared_ptr<_State_base> __state_type; 645 typedef __future_base::_Result<_Res>& __result_type; 646 647 private: 648 __state_type _M_state; 649 650 public: 651 // Disable copying. 652 __basic_future(const __basic_future&) = delete; 653 __basic_future& operator=(const __basic_future&) = delete; 654 655 bool 656 valid() const noexcept { return static_cast<bool>(_M_state); } 657 658 void 659 wait() const 660 { 661 _State_base::_S_check(_M_state); 662 _M_state->wait(); 663 } 664 665 template<typename _Rep, typename _Period> 666 future_status 667 wait_for(const chrono::duration<_Rep, _Period>& __rel) const 668 { 669 _State_base::_S_check(_M_state); 670 return _M_state->wait_for(__rel); 671 } 672 673 template<typename _Clock, typename _Duration> 674 future_status 675 wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const 676 { 677 _State_base::_S_check(_M_state); 678 return _M_state->wait_until(__abs); 679 } 680 681 protected: 682 /// Wait for the state to be ready and rethrow any stored exception 683 __result_type 684 _M_get_result() const 685 { 686 _State_base::_S_check(_M_state); 687 _Result_base& __res = _M_state->wait(); 688 if (!(__res._M_error == 0)) 689 rethrow_exception(__res._M_error); 690 return static_cast<__result_type>(__res); 691 } 692 693 void _M_swap(__basic_future& __that) noexcept 694 { 695 _M_state.swap(__that._M_state); 696 } 697 698 // Construction of a future by promise::get_future() 699 explicit 700 __basic_future(const __state_type& __state) : _M_state(__state) 701 { 702 _State_base::_S_check(_M_state); 703 _M_state->_M_set_retrieved_flag(); 704 } 705 706 // Copy construction from a shared_future 707 explicit 708 __basic_future(const shared_future<_Res>&) noexcept; 709 710 // Move construction from a shared_future 711 explicit 712 __basic_future(shared_future<_Res>&&) noexcept; 713 714 // Move construction from a future 715 explicit 716 __basic_future(future<_Res>&&) noexcept; 717 718 constexpr __basic_future() noexcept : _M_state() { } 719 720 struct _Reset 721 { 722 explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { } 723 ~_Reset() { _M_fut._M_state.reset(); } 724 __basic_future& _M_fut; 725 }; 726 }; 727 728 729 /// Primary template for future. 730 template<typename _Res> 731 class future : public __basic_future<_Res> 732 { 733 friend class promise<_Res>; 734 template<typename> friend class packaged_task; 735 template<typename _Fn, typename... _Args> 736 friend future<__async_result_of<_Fn, _Args...>> 737 async(launch, _Fn&&, _Args&&...); 738 739 typedef __basic_future<_Res> _Base_type; 740 typedef typename _Base_type::__state_type __state_type; 741 742 explicit 743 future(const __state_type& __state) : _Base_type(__state) { } 744 745 public: 746 constexpr future() noexcept : _Base_type() { } 747 748 /// Move constructor 749 future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } 750 751 // Disable copying 752 future(const future&) = delete; 753 future& operator=(const future&) = delete; 754 755 future& operator=(future&& __fut) noexcept 756 { 757 future(std::move(__fut))._M_swap(*this); 758 return *this; 759 } 760 761 /// Retrieving the value 762 _Res 763 get() 764 { 765 typename _Base_type::_Reset __reset(*this); 766 return std::move(this->_M_get_result()._M_value()); 767 } 768 769 shared_future<_Res> share(); 770 }; 771 772 /// Partial specialization for future<R&> 773 template<typename _Res> 774 class future<_Res&> : public __basic_future<_Res&> 775 { 776 friend class promise<_Res&>; 777 template<typename> friend class packaged_task; 778 template<typename _Fn, typename... _Args> 779 friend future<__async_result_of<_Fn, _Args...>> 780 async(launch, _Fn&&, _Args&&...); 781 782 typedef __basic_future<_Res&> _Base_type; 783 typedef typename _Base_type::__state_type __state_type; 784 785 explicit 786 future(const __state_type& __state) : _Base_type(__state) { } 787 788 public: 789 constexpr future() noexcept : _Base_type() { } 790 791 /// Move constructor 792 future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } 793 794 // Disable copying 795 future(const future&) = delete; 796 future& operator=(const future&) = delete; 797 798 future& operator=(future&& __fut) noexcept 799 { 800 future(std::move(__fut))._M_swap(*this); 801 return *this; 802 } 803 804 /// Retrieving the value 805 _Res& 806 get() 807 { 808 typename _Base_type::_Reset __reset(*this); 809 return this->_M_get_result()._M_get(); 810 } 811 812 shared_future<_Res&> share(); 813 }; 814 815 /// Explicit specialization for future<void> 816 template<> 817 class future<void> : public __basic_future<void> 818 { 819 friend class promise<void>; 820 template<typename> friend class packaged_task; 821 template<typename _Fn, typename... _Args> 822 friend future<__async_result_of<_Fn, _Args...>> 823 async(launch, _Fn&&, _Args&&...); 824 825 typedef __basic_future<void> _Base_type; 826 typedef typename _Base_type::__state_type __state_type; 827 828 explicit 829 future(const __state_type& __state) : _Base_type(__state) { } 830 831 public: 832 constexpr future() noexcept : _Base_type() { } 833 834 /// Move constructor 835 future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } 836 837 // Disable copying 838 future(const future&) = delete; 839 future& operator=(const future&) = delete; 840 841 future& operator=(future&& __fut) noexcept 842 { 843 future(std::move(__fut))._M_swap(*this); 844 return *this; 845 } 846 847 /// Retrieving the value 848 void 849 get() 850 { 851 typename _Base_type::_Reset __reset(*this); 852 this->_M_get_result(); 853 } 854 855 shared_future<void> share(); 856 }; 857 858 859 /// Primary template for shared_future. 860 template<typename _Res> 861 class shared_future : public __basic_future<_Res> 862 { 863 typedef __basic_future<_Res> _Base_type; 864 865 public: 866 constexpr shared_future() noexcept : _Base_type() { } 867 868 /// Copy constructor 869 shared_future(const shared_future& __sf) : _Base_type(__sf) { } 870 871 /// Construct from a future rvalue 872 shared_future(future<_Res>&& __uf) noexcept 873 : _Base_type(std::move(__uf)) 874 { } 875 876 /// Construct from a shared_future rvalue 877 shared_future(shared_future&& __sf) noexcept 878 : _Base_type(std::move(__sf)) 879 { } 880 881 shared_future& operator=(const shared_future& __sf) 882 { 883 shared_future(__sf)._M_swap(*this); 884 return *this; 885 } 886 887 shared_future& operator=(shared_future&& __sf) noexcept 888 { 889 shared_future(std::move(__sf))._M_swap(*this); 890 return *this; 891 } 892 893 /// Retrieving the value 894 const _Res& 895 get() const { return this->_M_get_result()._M_value(); } 896 }; 897 898 /// Partial specialization for shared_future<R&> 899 template<typename _Res> 900 class shared_future<_Res&> : public __basic_future<_Res&> 901 { 902 typedef __basic_future<_Res&> _Base_type; 903 904 public: 905 constexpr shared_future() noexcept : _Base_type() { } 906 907 /// Copy constructor 908 shared_future(const shared_future& __sf) : _Base_type(__sf) { } 909 910 /// Construct from a future rvalue 911 shared_future(future<_Res&>&& __uf) noexcept 912 : _Base_type(std::move(__uf)) 913 { } 914 915 /// Construct from a shared_future rvalue 916 shared_future(shared_future&& __sf) noexcept 917 : _Base_type(std::move(__sf)) 918 { } 919 920 shared_future& operator=(const shared_future& __sf) 921 { 922 shared_future(__sf)._M_swap(*this); 923 return *this; 924 } 925 926 shared_future& operator=(shared_future&& __sf) noexcept 927 { 928 shared_future(std::move(__sf))._M_swap(*this); 929 return *this; 930 } 931 932 /// Retrieving the value 933 _Res& 934 get() const { return this->_M_get_result()._M_get(); } 935 }; 936 937 /// Explicit specialization for shared_future<void> 938 template<> 939 class shared_future<void> : public __basic_future<void> 940 { 941 typedef __basic_future<void> _Base_type; 942 943 public: 944 constexpr shared_future() noexcept : _Base_type() { } 945 946 /// Copy constructor 947 shared_future(const shared_future& __sf) : _Base_type(__sf) { } 948 949 /// Construct from a future rvalue 950 shared_future(future<void>&& __uf) noexcept 951 : _Base_type(std::move(__uf)) 952 { } 953 954 /// Construct from a shared_future rvalue 955 shared_future(shared_future&& __sf) noexcept 956 : _Base_type(std::move(__sf)) 957 { } 958 959 shared_future& operator=(const shared_future& __sf) 960 { 961 shared_future(__sf)._M_swap(*this); 962 return *this; 963 } 964 965 shared_future& operator=(shared_future&& __sf) noexcept 966 { 967 shared_future(std::move(__sf))._M_swap(*this); 968 return *this; 969 } 970 971 // Retrieving the value 972 void 973 get() const { this->_M_get_result(); } 974 }; 975 976 // Now we can define the protected __basic_future constructors. 977 template<typename _Res> 978 inline __basic_future<_Res>:: 979 __basic_future(const shared_future<_Res>& __sf) noexcept 980 : _M_state(__sf._M_state) 981 { } 982 983 template<typename _Res> 984 inline __basic_future<_Res>:: 985 __basic_future(shared_future<_Res>&& __sf) noexcept 986 : _M_state(std::move(__sf._M_state)) 987 { } 988 989 template<typename _Res> 990 inline __basic_future<_Res>:: 991 __basic_future(future<_Res>&& __uf) noexcept 992 : _M_state(std::move(__uf._M_state)) 993 { } 994 995 template<typename _Res> 996 inline shared_future<_Res> 997 future<_Res>::share() 998 { return shared_future<_Res>(std::move(*this)); } 999 1000 template<typename _Res> 1001 inline shared_future<_Res&> 1002 future<_Res&>::share() 1003 { return shared_future<_Res&>(std::move(*this)); } 1004 1005 inline shared_future<void> 1006 future<void>::share() 1007 { return shared_future<void>(std::move(*this)); } 1008 1009 /// Primary template for promise 1010 template<typename _Res> 1011 class promise 1012 { 1013 typedef __future_base::_State_base _State; 1014 typedef __future_base::_Result<_Res> _Res_type; 1015 typedef __future_base::_Ptr<_Res_type> _Ptr_type; 1016 template<typename, typename> friend class _State::_Setter; 1017 1018 shared_ptr<_State> _M_future; 1019 _Ptr_type _M_storage; 1020 1021 public: 1022 promise() 1023 : _M_future(std::make_shared<_State>()), 1024 _M_storage(new _Res_type()) 1025 { } 1026 1027 promise(promise&& __rhs) noexcept 1028 : _M_future(std::move(__rhs._M_future)), 1029 _M_storage(std::move(__rhs._M_storage)) 1030 { } 1031 1032 template<typename _Allocator> 1033 promise(allocator_arg_t, const _Allocator& __a) 1034 : _M_future(std::allocate_shared<_State>(__a)), 1035 _M_storage(__future_base::_S_allocate_result<_Res>(__a)) 1036 { } 1037 1038 template<typename _Allocator> 1039 promise(allocator_arg_t, const _Allocator&, promise&& __rhs) 1040 : _M_future(std::move(__rhs._M_future)), 1041 _M_storage(std::move(__rhs._M_storage)) 1042 { } 1043 1044 promise(const promise&) = delete; 1045 1046 ~promise() 1047 { 1048 if (static_cast<bool>(_M_future) && !_M_future.unique()) 1049 _M_future->_M_break_promise(std::move(_M_storage)); 1050 } 1051 1052 // Assignment 1053 promise& 1054 operator=(promise&& __rhs) noexcept 1055 { 1056 promise(std::move(__rhs)).swap(*this); 1057 return *this; 1058 } 1059 1060 promise& operator=(const promise&) = delete; 1061 1062 void 1063 swap(promise& __rhs) noexcept 1064 { 1065 _M_future.swap(__rhs._M_future); 1066 _M_storage.swap(__rhs._M_storage); 1067 } 1068 1069 // Retrieving the result 1070 future<_Res> 1071 get_future() 1072 { return future<_Res>(_M_future); } 1073 1074 // Setting the result 1075 void 1076 set_value(const _Res& __r) 1077 { _M_future->_M_set_result(_State::__setter(this, __r)); } 1078 1079 void 1080 set_value(_Res&& __r) 1081 { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); } 1082 1083 void 1084 set_exception(exception_ptr __p) 1085 { _M_future->_M_set_result(_State::__setter(__p, this)); } 1086 1087 void 1088 set_value_at_thread_exit(const _Res& __r) 1089 { 1090 _M_future->_M_set_delayed_result(_State::__setter(this, __r), 1091 _M_future); 1092 } 1093 1094 void 1095 set_value_at_thread_exit(_Res&& __r) 1096 { 1097 _M_future->_M_set_delayed_result( 1098 _State::__setter(this, std::move(__r)), _M_future); 1099 } 1100 1101 void 1102 set_exception_at_thread_exit(exception_ptr __p) 1103 { 1104 _M_future->_M_set_delayed_result(_State::__setter(__p, this), 1105 _M_future); 1106 } 1107 }; 1108 1109 template<typename _Res> 1110 inline void 1111 swap(promise<_Res>& __x, promise<_Res>& __y) noexcept 1112 { __x.swap(__y); } 1113 1114 template<typename _Res, typename _Alloc> 1115 struct uses_allocator<promise<_Res>, _Alloc> 1116 : public true_type { }; 1117 1118 1119 /// Partial specialization for promise<R&> 1120 template<typename _Res> 1121 class promise<_Res&> 1122 { 1123 typedef __future_base::_State_base _State; 1124 typedef __future_base::_Result<_Res&> _Res_type; 1125 typedef __future_base::_Ptr<_Res_type> _Ptr_type; 1126 template<typename, typename> friend class _State::_Setter; 1127 1128 shared_ptr<_State> _M_future; 1129 _Ptr_type _M_storage; 1130 1131 public: 1132 promise() 1133 : _M_future(std::make_shared<_State>()), 1134 _M_storage(new _Res_type()) 1135 { } 1136 1137 promise(promise&& __rhs) noexcept 1138 : _M_future(std::move(__rhs._M_future)), 1139 _M_storage(std::move(__rhs._M_storage)) 1140 { } 1141 1142 template<typename _Allocator> 1143 promise(allocator_arg_t, const _Allocator& __a) 1144 : _M_future(std::allocate_shared<_State>(__a)), 1145 _M_storage(__future_base::_S_allocate_result<_Res&>(__a)) 1146 { } 1147 1148 template<typename _Allocator> 1149 promise(allocator_arg_t, const _Allocator&, promise&& __rhs) 1150 : _M_future(std::move(__rhs._M_future)), 1151 _M_storage(std::move(__rhs._M_storage)) 1152 { } 1153 1154 promise(const promise&) = delete; 1155 1156 ~promise() 1157 { 1158 if (static_cast<bool>(_M_future) && !_M_future.unique()) 1159 _M_future->_M_break_promise(std::move(_M_storage)); 1160 } 1161 1162 // Assignment 1163 promise& 1164 operator=(promise&& __rhs) noexcept 1165 { 1166 promise(std::move(__rhs)).swap(*this); 1167 return *this; 1168 } 1169 1170 promise& operator=(const promise&) = delete; 1171 1172 void 1173 swap(promise& __rhs) noexcept 1174 { 1175 _M_future.swap(__rhs._M_future); 1176 _M_storage.swap(__rhs._M_storage); 1177 } 1178 1179 // Retrieving the result 1180 future<_Res&> 1181 get_future() 1182 { return future<_Res&>(_M_future); } 1183 1184 // Setting the result 1185 void 1186 set_value(_Res& __r) 1187 { _M_future->_M_set_result(_State::__setter(this, __r)); } 1188 1189 void 1190 set_exception(exception_ptr __p) 1191 { _M_future->_M_set_result(_State::__setter(__p, this)); } 1192 1193 void 1194 set_value_at_thread_exit(_Res& __r) 1195 { 1196 _M_future->_M_set_delayed_result(_State::__setter(this, __r), 1197 _M_future); 1198 } 1199 1200 void 1201 set_exception_at_thread_exit(exception_ptr __p) 1202 { 1203 _M_future->_M_set_delayed_result(_State::__setter(__p, this), 1204 _M_future); 1205 } 1206 }; 1207 1208 /// Explicit specialization for promise<void> 1209 template<> 1210 class promise<void> 1211 { 1212 typedef __future_base::_State_base _State; 1213 typedef __future_base::_Result<void> _Res_type; 1214 typedef __future_base::_Ptr<_Res_type> _Ptr_type; 1215 template<typename, typename> friend class _State::_Setter; 1216 1217 shared_ptr<_State> _M_future; 1218 _Ptr_type _M_storage; 1219 1220 public: 1221 promise() 1222 : _M_future(std::make_shared<_State>()), 1223 _M_storage(new _Res_type()) 1224 { } 1225 1226 promise(promise&& __rhs) noexcept 1227 : _M_future(std::move(__rhs._M_future)), 1228 _M_storage(std::move(__rhs._M_storage)) 1229 { } 1230 1231 template<typename _Allocator> 1232 promise(allocator_arg_t, const _Allocator& __a) 1233 : _M_future(std::allocate_shared<_State>(__a)), 1234 _M_storage(__future_base::_S_allocate_result<void>(__a)) 1235 { } 1236 1237 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1238 // 2095. missing constructors needed for uses-allocator construction 1239 template<typename _Allocator> 1240 promise(allocator_arg_t, const _Allocator&, promise&& __rhs) 1241 : _M_future(std::move(__rhs._M_future)), 1242 _M_storage(std::move(__rhs._M_storage)) 1243 { } 1244 1245 promise(const promise&) = delete; 1246 1247 ~promise() 1248 { 1249 if (static_cast<bool>(_M_future) && !_M_future.unique()) 1250 _M_future->_M_break_promise(std::move(_M_storage)); 1251 } 1252 1253 // Assignment 1254 promise& 1255 operator=(promise&& __rhs) noexcept 1256 { 1257 promise(std::move(__rhs)).swap(*this); 1258 return *this; 1259 } 1260 1261 promise& operator=(const promise&) = delete; 1262 1263 void 1264 swap(promise& __rhs) noexcept 1265 { 1266 _M_future.swap(__rhs._M_future); 1267 _M_storage.swap(__rhs._M_storage); 1268 } 1269 1270 // Retrieving the result 1271 future<void> 1272 get_future() 1273 { return future<void>(_M_future); } 1274 1275 // Setting the result 1276 void set_value(); 1277 1278 void 1279 set_exception(exception_ptr __p) 1280 { _M_future->_M_set_result(_State::__setter(__p, this)); } 1281 1282 void 1283 set_value_at_thread_exit(); 1284 1285 void 1286 set_exception_at_thread_exit(exception_ptr __p) 1287 { 1288 _M_future->_M_set_delayed_result(_State::__setter(__p, this), 1289 _M_future); 1290 } 1291 }; 1292 1293 // set void 1294 template<> 1295 struct __future_base::_State_base::_Setter<void, void> 1296 { 1297 promise<void>::_Ptr_type operator()() const 1298 { 1299 _State_base::_S_check(_M_promise->_M_future); 1300 return std::move(_M_promise->_M_storage); 1301 } 1302 1303 promise<void>* _M_promise; 1304 }; 1305 1306 inline void 1307 promise<void>::set_value() 1308 { _M_future->_M_set_result(_State::_Setter<void, void>{ this }); } 1309 1310 inline void 1311 promise<void>::set_value_at_thread_exit() 1312 { 1313 _M_future->_M_set_delayed_result(_State::_Setter<void, void>{this}, 1314 _M_future); 1315 } 1316 1317 template<typename _Ptr_type, typename _Fn, typename _Res> 1318 struct __future_base::_Task_setter 1319 { 1320 // Invoke the function and provide the result to the caller. 1321 _Ptr_type operator()() const 1322 { 1323 __try 1324 { 1325 (*_M_result)->_M_set((*_M_fn)()); 1326 } 1327 __catch(const __cxxabiv1::__forced_unwind&) 1328 { 1329 __throw_exception_again; // will cause broken_promise 1330 } 1331 __catch(...) 1332 { 1333 (*_M_result)->_M_error = current_exception(); 1334 } 1335 return std::move(*_M_result); 1336 } 1337 _Ptr_type* _M_result; 1338 _Fn* _M_fn; 1339 }; 1340 1341 template<typename _Ptr_type, typename _Fn> 1342 struct __future_base::_Task_setter<_Ptr_type, _Fn, void> 1343 { 1344 _Ptr_type operator()() const 1345 { 1346 __try 1347 { 1348 (*_M_fn)(); 1349 } 1350 __catch(const __cxxabiv1::__forced_unwind&) 1351 { 1352 __throw_exception_again; // will cause broken_promise 1353 } 1354 __catch(...) 1355 { 1356 (*_M_result)->_M_error = current_exception(); 1357 } 1358 return std::move(*_M_result); 1359 } 1360 _Ptr_type* _M_result; 1361 _Fn* _M_fn; 1362 }; 1363 1364 // Holds storage for a packaged_task's result. 1365 template<typename _Res, typename... _Args> 1366 struct __future_base::_Task_state_base<_Res(_Args...)> 1367 : __future_base::_State_base 1368 { 1369 typedef _Res _Res_type; 1370 1371 template<typename _Alloc> 1372 _Task_state_base(const _Alloc& __a) 1373 : _M_result(_S_allocate_result<_Res>(__a)) 1374 { } 1375 1376 // Invoke the stored task and make the state ready. 1377 virtual void 1378 _M_run(_Args&&... __args) = 0; 1379 1380 // Invoke the stored task and make the state ready at thread exit. 1381 virtual void 1382 _M_run_delayed(_Args&&... __args, weak_ptr<_State_base>) = 0; 1383 1384 virtual shared_ptr<_Task_state_base> 1385 _M_reset() = 0; 1386 1387 typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; 1388 _Ptr_type _M_result; 1389 }; 1390 1391 // Holds a packaged_task's stored task. 1392 template<typename _Fn, typename _Alloc, typename _Res, typename... _Args> 1393 struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final 1394 : __future_base::_Task_state_base<_Res(_Args...)> 1395 { 1396 template<typename _Fn2> 1397 _Task_state(_Fn2&& __fn, const _Alloc& __a) 1398 : _Task_state_base<_Res(_Args...)>(__a), 1399 _M_impl(std::forward<_Fn2>(__fn), __a) 1400 { } 1401 1402 private: 1403 virtual void 1404 _M_run(_Args&&... __args) 1405 { 1406 // bound arguments decay so wrap lvalue references 1407 auto __boundfn = std::__bind_simple(std::ref(_M_impl._M_fn), 1408 _S_maybe_wrap_ref(std::forward<_Args>(__args))...); 1409 this->_M_set_result(_S_task_setter(this->_M_result, __boundfn)); 1410 } 1411 1412 virtual void 1413 _M_run_delayed(_Args&&... __args, weak_ptr<_State_base> __self) 1414 { 1415 // bound arguments decay so wrap lvalue references 1416 auto __boundfn = std::__bind_simple(std::ref(_M_impl._M_fn), 1417 _S_maybe_wrap_ref(std::forward<_Args>(__args))...); 1418 this->_M_set_delayed_result(_S_task_setter(this->_M_result, __boundfn), 1419 std::move(__self)); 1420 } 1421 1422 virtual shared_ptr<_Task_state_base<_Res(_Args...)>> 1423 _M_reset(); 1424 1425 template<typename _Tp> 1426 static reference_wrapper<_Tp> 1427 _S_maybe_wrap_ref(_Tp& __t) 1428 { return std::ref(__t); } 1429 1430 template<typename _Tp> 1431 static 1432 typename enable_if<!is_lvalue_reference<_Tp>::value, _Tp>::type&& 1433 _S_maybe_wrap_ref(_Tp&& __t) 1434 { return std::forward<_Tp>(__t); } 1435 1436 struct _Impl : _Alloc 1437 { 1438 template<typename _Fn2> 1439 _Impl(_Fn2&& __fn, const _Alloc& __a) 1440 : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { } 1441 _Fn _M_fn; 1442 } _M_impl; 1443 }; 1444 1445 template<typename _Signature, typename _Fn, typename _Alloc> 1446 static shared_ptr<__future_base::_Task_state_base<_Signature>> 1447 __create_task_state(_Fn&& __fn, const _Alloc& __a) 1448 { 1449 typedef typename decay<_Fn>::type _Fn2; 1450 typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State; 1451 return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a); 1452 } 1453 1454 template<typename _Fn, typename _Alloc, typename _Res, typename... _Args> 1455 shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>> 1456 __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset() 1457 { 1458 return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn), 1459 static_cast<_Alloc&>(_M_impl)); 1460 } 1461 1462 template<typename _Task, typename _Fn, bool 1463 = is_same<_Task, typename decay<_Fn>::type>::value> 1464 struct __constrain_pkgdtask 1465 { typedef void __type; }; 1466 1467 template<typename _Task, typename _Fn> 1468 struct __constrain_pkgdtask<_Task, _Fn, true> 1469 { }; 1470 1471 /// packaged_task 1472 template<typename _Res, typename... _ArgTypes> 1473 class packaged_task<_Res(_ArgTypes...)> 1474 { 1475 typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type; 1476 shared_ptr<_State_type> _M_state; 1477 1478 public: 1479 // Construction and destruction 1480 packaged_task() noexcept { } 1481 1482 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1483 // 2095. missing constructors needed for uses-allocator construction 1484 template<typename _Allocator> 1485 packaged_task(allocator_arg_t, const _Allocator& __a) noexcept 1486 { } 1487 1488 template<typename _Fn, typename = typename 1489 __constrain_pkgdtask<packaged_task, _Fn>::__type> 1490 explicit 1491 packaged_task(_Fn&& __fn) 1492 : packaged_task(allocator_arg, std::allocator<int>(), 1493 std::forward<_Fn>(__fn)) 1494 { } 1495 1496 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1497 // 2097. packaged_task constructors should be constrained 1498 // 2407. [this constructor should not be] explicit 1499 template<typename _Fn, typename _Alloc, typename = typename 1500 __constrain_pkgdtask<packaged_task, _Fn>::__type> 1501 packaged_task(allocator_arg_t, const _Alloc& __a, _Fn&& __fn) 1502 : _M_state(__create_task_state<_Res(_ArgTypes...)>( 1503 std::forward<_Fn>(__fn), __a)) 1504 { } 1505 1506 ~packaged_task() 1507 { 1508 if (static_cast<bool>(_M_state) && !_M_state.unique()) 1509 _M_state->_M_break_promise(std::move(_M_state->_M_result)); 1510 } 1511 1512 // No copy 1513 packaged_task(const packaged_task&) = delete; 1514 packaged_task& operator=(const packaged_task&) = delete; 1515 1516 template<typename _Allocator> 1517 packaged_task(allocator_arg_t, const _Allocator&, 1518 const packaged_task&) = delete; 1519 1520 // Move support 1521 packaged_task(packaged_task&& __other) noexcept 1522 { this->swap(__other); } 1523 1524 template<typename _Allocator> 1525 packaged_task(allocator_arg_t, const _Allocator&, 1526 packaged_task&& __other) noexcept 1527 { this->swap(__other); } 1528 1529 packaged_task& operator=(packaged_task&& __other) noexcept 1530 { 1531 packaged_task(std::move(__other)).swap(*this); 1532 return *this; 1533 } 1534 1535 void 1536 swap(packaged_task& __other) noexcept 1537 { _M_state.swap(__other._M_state); } 1538 1539 bool 1540 valid() const noexcept 1541 { return static_cast<bool>(_M_state); } 1542 1543 // Result retrieval 1544 future<_Res> 1545 get_future() 1546 { return future<_Res>(_M_state); } 1547 1548 // Execution 1549 void 1550 operator()(_ArgTypes... __args) 1551 { 1552 __future_base::_State_base::_S_check(_M_state); 1553 _M_state->_M_run(std::forward<_ArgTypes>(__args)...); 1554 } 1555 1556 void 1557 make_ready_at_thread_exit(_ArgTypes... __args) 1558 { 1559 __future_base::_State_base::_S_check(_M_state); 1560 _M_state->_M_run_delayed(std::forward<_ArgTypes>(__args)..., _M_state); 1561 } 1562 1563 void 1564 reset() 1565 { 1566 __future_base::_State_base::_S_check(_M_state); 1567 packaged_task __tmp; 1568 __tmp._M_state = _M_state; 1569 _M_state = _M_state->_M_reset(); 1570 } 1571 }; 1572 1573 /// swap 1574 template<typename _Res, typename... _ArgTypes> 1575 inline void 1576 swap(packaged_task<_Res(_ArgTypes...)>& __x, 1577 packaged_task<_Res(_ArgTypes...)>& __y) noexcept 1578 { __x.swap(__y); } 1579 1580 template<typename _Res, typename _Alloc> 1581 struct uses_allocator<packaged_task<_Res>, _Alloc> 1582 : public true_type { }; 1583 1584 1585 // Shared state created by std::async(). 1586 // Holds a deferred function and storage for its result. 1587 template<typename _BoundFn, typename _Res> 1588 class __future_base::_Deferred_state final 1589 : public __future_base::_State_base 1590 { 1591 public: 1592 explicit 1593 _Deferred_state(_BoundFn&& __fn) 1594 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) 1595 { } 1596 1597 private: 1598 typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; 1599 _Ptr_type _M_result; 1600 _BoundFn _M_fn; 1601 1602 // Run the deferred function. 1603 virtual void 1604 _M_complete_async() 1605 { 1606 // Multiple threads can call a waiting function on the future and 1607 // reach this point at the same time. The call_once in _M_set_result 1608 // ensures only the first one run the deferred function, stores the 1609 // result in _M_result, swaps that with the base _M_result and makes 1610 // the state ready. Tell _M_set_result to ignore failure so all later 1611 // calls do nothing. 1612 _M_set_result(_S_task_setter(_M_result, _M_fn), true); 1613 } 1614 1615 // Caller should check whether the state is ready first, because this 1616 // function will return true even after the deferred function has run. 1617 virtual bool _M_is_deferred_future() const { return true; } 1618 }; 1619 1620 // Common functionality hoisted out of the _Async_state_impl template. 1621 class __future_base::_Async_state_commonV2 1622 : public __future_base::_State_base 1623 { 1624 protected: 1625 ~_Async_state_commonV2() = default; 1626 1627 // Make waiting functions block until the thread completes, as if joined. 1628 // 1629 // This function is used by wait() to satisfy the first requirement below 1630 // and by wait_for() / wait_until() to satisfy the second. 1631 // 1632 // [futures.async]: 1633 // 1634 // — a call to a waiting function on an asynchronous return object that 1635 // shares the shared state created by this async call shall block until 1636 // the associated thread has completed, as if joined, or else time out. 1637 // 1638 // — the associated thread completion synchronizes with the return from 1639 // the first function that successfully detects the ready status of the 1640 // shared state or with the return from the last function that releases 1641 // the shared state, whichever happens first. 1642 virtual void _M_complete_async() { _M_join(); } 1643 1644 void _M_join() { std::call_once(_M_once, &thread::join, &_M_thread); } 1645 1646 thread _M_thread; 1647 once_flag _M_once; 1648 }; 1649 1650 // Shared state created by std::async(). 1651 // Starts a new thread that runs a function and makes the shared state ready. 1652 template<typename _BoundFn, typename _Res> 1653 class __future_base::_Async_state_impl final 1654 : public __future_base::_Async_state_commonV2 1655 { 1656 public: 1657 explicit 1658 _Async_state_impl(_BoundFn&& __fn) 1659 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) 1660 { 1661 _M_thread = std::thread{ [this] { 1662 __try 1663 { 1664 _M_set_result(_S_task_setter(_M_result, _M_fn)); 1665 } 1666 __catch (const __cxxabiv1::__forced_unwind&) 1667 { 1668 // make the shared state ready on thread cancellation 1669 if (static_cast<bool>(_M_result)) 1670 this->_M_break_promise(std::move(_M_result)); 1671 __throw_exception_again; 1672 } 1673 } }; 1674 } 1675 1676 // Must not destroy _M_result and _M_fn until the thread finishes. 1677 // Call join() directly rather than through _M_join() because no other 1678 // thread can be referring to this state if it is being destroyed. 1679 ~_Async_state_impl() { if (_M_thread.joinable()) _M_thread.join(); } 1680 1681 private: 1682 typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; 1683 _Ptr_type _M_result; 1684 _BoundFn _M_fn; 1685 }; 1686 1687 template<typename _BoundFn> 1688 inline std::shared_ptr<__future_base::_State_base> 1689 __future_base::_S_make_deferred_state(_BoundFn&& __fn) 1690 { 1691 typedef typename remove_reference<_BoundFn>::type __fn_type; 1692 typedef _Deferred_state<__fn_type> __state_type; 1693 return std::make_shared<__state_type>(std::move(__fn)); 1694 } 1695 1696 template<typename _BoundFn> 1697 inline std::shared_ptr<__future_base::_State_base> 1698 __future_base::_S_make_async_state(_BoundFn&& __fn) 1699 { 1700 typedef typename remove_reference<_BoundFn>::type __fn_type; 1701 typedef _Async_state_impl<__fn_type> __state_type; 1702 return std::make_shared<__state_type>(std::move(__fn)); 1703 } 1704 1705 1706 /// async 1707 template<typename _Fn, typename... _Args> 1708 future<__async_result_of<_Fn, _Args...>> 1709 async(launch __policy, _Fn&& __fn, _Args&&... __args) 1710 { 1711 std::shared_ptr<__future_base::_State_base> __state; 1712 if ((__policy & launch::async) == launch::async) 1713 { 1714 __try 1715 { 1716 __state = __future_base::_S_make_async_state(std::__bind_simple( 1717 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); 1718 } 1719#if __cpp_exceptions 1720 catch(const system_error& __e) 1721 { 1722 if (__e.code() != errc::resource_unavailable_try_again 1723 || (__policy & launch::deferred) != launch::deferred) 1724 throw; 1725 } 1726#endif 1727 } 1728 if (!__state) 1729 { 1730 __state = __future_base::_S_make_deferred_state(std::__bind_simple( 1731 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); 1732 } 1733 return future<__async_result_of<_Fn, _Args...>>(__state); 1734 } 1735 1736 /// async, potential overload 1737 template<typename _Fn, typename... _Args> 1738 inline future<__async_result_of<_Fn, _Args...>> 1739 async(_Fn&& __fn, _Args&&... __args) 1740 { 1741 return std::async(launch::async|launch::deferred, 1742 std::forward<_Fn>(__fn), 1743 std::forward<_Args>(__args)...); 1744 } 1745 1746#endif // _GLIBCXX_ASYNC_ABI_COMPAT 1747#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 1748 // && ATOMIC_INT_LOCK_FREE 1749 1750 // @} group futures 1751_GLIBCXX_END_NAMESPACE_VERSION 1752} // namespace 1753 1754#endif // C++11 1755 1756#endif // _GLIBCXX_FUTURE 1757