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