libstdc++
future
Go to the documentation of this file.
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 <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  && (ATOMIC_INT_LOCK_FREE > 1)
197 
198  /// Base class and enclosing scope.
200  {
201  /// Base class for results.
203  {
204  exception_ptr _M_error;
205 
206  _Result_base(const _Result_base&) = delete;
207  _Result_base& operator=(const _Result_base&) = delete;
208 
209  // _M_destroy() allows derived classes to control deallocation
210  virtual void _M_destroy() = 0;
211 
212  struct _Deleter
213  {
214  void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
215  };
216 
217  protected:
218  _Result_base();
219  virtual ~_Result_base();
220  };
221 
222  /// A unique_ptr for result objects.
223  template<typename _Res>
225 
226  /// A result object that has storage for an object of type _Res.
227  template<typename _Res>
229  {
230  private:
231  __gnu_cxx::__aligned_buffer<_Res> _M_storage;
232  bool _M_initialized;
233 
234  public:
235  typedef _Res result_type;
236 
237  _Result() noexcept : _M_initialized() { }
238 
239  ~_Result()
240  {
241  if (_M_initialized)
242  _M_value().~_Res();
243  }
244 
245  // Return lvalue, future will add const or rvalue-reference
246  _Res&
247  _M_value() noexcept { return *_M_storage._M_ptr(); }
248 
249  void
250  _M_set(const _Res& __res)
251  {
252  ::new (_M_storage._M_addr()) _Res(__res);
253  _M_initialized = true;
254  }
255 
256  void
257  _M_set(_Res&& __res)
258  {
259  ::new (_M_storage._M_addr()) _Res(std::move(__res));
260  _M_initialized = true;
261  }
262 
263  private:
264  void _M_destroy() { delete this; }
265  };
266 
267  /// A result object that uses an allocator.
268  template<typename _Res, typename _Alloc>
269  struct _Result_alloc final : _Result<_Res>, _Alloc
270  {
271  using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>;
272 
273  explicit
274  _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
275  { }
276 
277  private:
278  void _M_destroy()
279  {
280  __allocator_type __a(*this);
281  __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
282  this->~_Result_alloc();
283  }
284  };
285 
286  // Create a result object that uses an allocator.
287  template<typename _Res, typename _Allocator>
289  _S_allocate_result(const _Allocator& __a)
290  {
291  using __result_type = _Result_alloc<_Res, _Allocator>;
292  typename __result_type::__allocator_type __a2(__a);
293  auto __guard = std::__allocate_guarded(__a2);
294  __result_type* __p = ::new((void*)__guard.get()) __result_type{__a};
295  __guard = nullptr;
296  return _Ptr<__result_type>(__p);
297  }
298 
299  // Keep it simple for std::allocator.
300  template<typename _Res, typename _Tp>
301  static _Ptr<_Result<_Res>>
302  _S_allocate_result(const std::allocator<_Tp>& __a)
303  {
304  return _Ptr<_Result<_Res>>(new _Result<_Res>);
305  }
306 
307  // Base class for various types of shared state created by an
308  // asynchronous provider (such as a std::promise) and shared with one
309  // or more associated futures.
310  class _State_baseV2
311  {
312  typedef _Ptr<_Result_base> _Ptr_type;
313 
314  enum _Status : unsigned {
315  __not_ready,
316  __ready
317  };
318 
319  _Ptr_type _M_result;
320  __atomic_futex_unsigned<> _M_status;
321  atomic_flag _M_retrieved = ATOMIC_FLAG_INIT;
322  once_flag _M_once;
323 
324  public:
325  _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready)
326  { }
327  _State_baseV2(const _State_baseV2&) = delete;
328  _State_baseV2& operator=(const _State_baseV2&) = delete;
329  virtual ~_State_baseV2() = default;
330 
331  _Result_base&
332  wait()
333  {
334  // Run any deferred function or join any asynchronous thread:
335  _M_complete_async();
336  // Acquire MO makes sure this synchronizes with the thread that made
337  // the future ready.
338  _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire);
339  return *_M_result;
340  }
341 
342  template<typename _Rep, typename _Period>
344  wait_for(const chrono::duration<_Rep, _Period>& __rel)
345  {
346  // First, check if the future has been made ready. Use acquire MO
347  // to synchronize with the thread that made it ready.
348  if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
349  return future_status::ready;
350  if (_M_is_deferred_future())
351  return future_status::deferred;
352  if (_M_status._M_load_when_equal_for(_Status::__ready,
353  memory_order_acquire, __rel))
354  {
355  // _GLIBCXX_RESOLVE_LIB_DEFECTS
356  // 2100. timed waiting functions must also join
357  // This call is a no-op by default except on an async future,
358  // in which case the async thread is joined. It's also not a
359  // no-op for a deferred future, but such a future will never
360  // reach this point because it returns future_status::deferred
361  // instead of waiting for the future to become ready (see
362  // above). Async futures synchronize in this call, so we need
363  // no further synchronization here.
364  _M_complete_async();
365 
366  return future_status::ready;
367  }
368  return future_status::timeout;
369  }
370 
371  template<typename _Clock, typename _Duration>
373  wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
374  {
375  // First, check if the future has been made ready. Use acquire MO
376  // to synchronize with the thread that made it ready.
377  if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
378  return future_status::ready;
379  if (_M_is_deferred_future())
380  return future_status::deferred;
381  if (_M_status._M_load_when_equal_until(_Status::__ready,
382  memory_order_acquire, __abs))
383  {
384  // _GLIBCXX_RESOLVE_LIB_DEFECTS
385  // 2100. timed waiting functions must also join
386  // See wait_for(...) above.
387  _M_complete_async();
388 
389  return future_status::ready;
390  }
391  return future_status::timeout;
392  }
393 
394  // Provide a result to the shared state and make it ready.
395  // Calls at most once: _M_result = __res();
396  void
397  _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
398  {
399  bool __did_set = false;
400  // all calls to this function are serialized,
401  // side-effects of invoking __res only happen once
402  call_once(_M_once, &_State_baseV2::_M_do_set, this,
403  std::__addressof(__res), std::__addressof(__did_set));
404  if (__did_set)
405  // Use release MO to synchronize with observers of the ready state.
406  _M_status._M_store_notify_all(_Status::__ready,
407  memory_order_release);
408  else if (!__ignore_failure)
409  __throw_future_error(int(future_errc::promise_already_satisfied));
410  }
411 
412  // Provide a result to the shared state but delay making it ready
413  // until the calling thread exits.
414  // Calls at most once: _M_result = __res();
415  void
416  _M_set_delayed_result(function<_Ptr_type()> __res,
418  {
419  bool __did_set = false;
420  unique_ptr<_Make_ready> __mr{new _Make_ready};
421  // all calls to this function are serialized,
422  // side-effects of invoking __res only happen once
423  call_once(_M_once, &_State_baseV2::_M_do_set, this,
424  std::__addressof(__res), std::__addressof(__did_set));
425  if (!__did_set)
426  __throw_future_error(int(future_errc::promise_already_satisfied));
427  __mr->_M_shared_state = std::move(__self);
428  __mr->_M_set();
429  __mr.release();
430  }
431 
432  // Abandon this shared state.
433  void
434  _M_break_promise(_Ptr_type __res)
435  {
436  if (static_cast<bool>(__res))
437  {
438  __res->_M_error =
439  make_exception_ptr(future_error(future_errc::broken_promise));
440  // This function is only called when the last asynchronous result
441  // provider is abandoning this shared state, so noone can be
442  // trying to make the shared state ready at the same time, and
443  // we can access _M_result directly instead of through call_once.
444  _M_result.swap(__res);
445  // Use release MO to synchronize with observers of the ready state.
446  _M_status._M_store_notify_all(_Status::__ready,
447  memory_order_release);
448  }
449  }
450 
451  // Called when this object is first passed to a future.
452  void
453  _M_set_retrieved_flag()
454  {
455  if (_M_retrieved.test_and_set())
456  __throw_future_error(int(future_errc::future_already_retrieved));
457  }
458 
459  template<typename _Res, typename _Arg>
460  struct _Setter;
461 
462  // set lvalues
463  template<typename _Res, typename _Arg>
464  struct _Setter<_Res, _Arg&>
465  {
466  // check this is only used by promise<R>::set_value(const R&)
467  // or promise<R&>::set_value(R&)
468  static_assert(is_same<_Res, _Arg&>::value // promise<R&>
469  || is_same<const _Res, _Arg>::value, // promise<R>
470  "Invalid specialisation");
471 
472  // Used by std::promise to copy construct the result.
473  typename promise<_Res>::_Ptr_type operator()() const
474  {
475  _State_baseV2::_S_check(_M_promise->_M_future);
476  _M_promise->_M_storage->_M_set(*_M_arg);
477  return std::move(_M_promise->_M_storage);
478  }
479  promise<_Res>* _M_promise;
480  _Arg* _M_arg;
481  };
482 
483  // set rvalues
484  template<typename _Res>
485  struct _Setter<_Res, _Res&&>
486  {
487  // Used by std::promise to move construct the result.
488  typename promise<_Res>::_Ptr_type operator()() const
489  {
490  _State_baseV2::_S_check(_M_promise->_M_future);
491  _M_promise->_M_storage->_M_set(std::move(*_M_arg));
492  return std::move(_M_promise->_M_storage);
493  }
494  promise<_Res>* _M_promise;
495  _Res* _M_arg;
496  };
497 
498  struct __exception_ptr_tag { };
499 
500  // set exceptions
501  template<typename _Res>
502  struct _Setter<_Res, __exception_ptr_tag>
503  {
504  // Used by std::promise to store an exception as the result.
505  typename promise<_Res>::_Ptr_type operator()() const
506  {
507  _State_baseV2::_S_check(_M_promise->_M_future);
508  _M_promise->_M_storage->_M_error = *_M_ex;
509  return std::move(_M_promise->_M_storage);
510  }
511 
512  promise<_Res>* _M_promise;
513  exception_ptr* _M_ex;
514  };
515 
516  template<typename _Res, typename _Arg>
517  static _Setter<_Res, _Arg&&>
518  __setter(promise<_Res>* __prom, _Arg&& __arg)
519  {
520  return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) };
521  }
522 
523  template<typename _Res>
524  static _Setter<_Res, __exception_ptr_tag>
525  __setter(exception_ptr& __ex, promise<_Res>* __prom)
526  {
527  return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex };
528  }
529 
530  template<typename _Tp>
531  static void
532  _S_check(const shared_ptr<_Tp>& __p)
533  {
534  if (!static_cast<bool>(__p))
535  __throw_future_error((int)future_errc::no_state);
536  }
537 
538  private:
539  // The function invoked with std::call_once(_M_once, ...).
540  void
541  _M_do_set(function<_Ptr_type()>* __f, bool* __did_set)
542  {
543  _Ptr_type __res = (*__f)();
544  // Notify the caller that we did try to set; if we do not throw an
545  // exception, the caller will be aware that it did set (e.g., see
546  // _M_set_result).
547  *__did_set = true;
548  _M_result.swap(__res); // nothrow
549  }
550 
551  // Wait for completion of async function.
552  virtual void _M_complete_async() { }
553 
554  // Return true if state corresponds to a deferred function.
555  virtual bool _M_is_deferred_future() const { return false; }
556 
557  struct _Make_ready final : __at_thread_exit_elt
558  {
559  weak_ptr<_State_baseV2> _M_shared_state;
560  static void _S_run(void*);
561  void _M_set();
562  };
563  };
564 
565 #ifdef _GLIBCXX_ASYNC_ABI_COMPAT
566  class _State_base;
567  class _Async_state_common;
568 #else
569  using _State_base = _State_baseV2;
570  class _Async_state_commonV2;
571 #endif
572 
573  template<typename _BoundFn,
574  typename _Res = decltype(std::declval<_BoundFn&>()())>
575  class _Deferred_state;
576 
577  template<typename _BoundFn,
578  typename _Res = decltype(std::declval<_BoundFn&>()())>
579  class _Async_state_impl;
580 
581  template<typename _Signature>
582  class _Task_state_base;
583 
584  template<typename _Fn, typename _Alloc, typename _Signature>
585  class _Task_state;
586 
587  template<typename _BoundFn>
589  _S_make_deferred_state(_BoundFn&& __fn);
590 
591  template<typename _BoundFn>
593  _S_make_async_state(_BoundFn&& __fn);
594 
595  template<typename _Res_ptr, typename _Fn,
596  typename _Res = typename _Res_ptr::element_type::result_type>
597  struct _Task_setter;
598 
599  template<typename _Res_ptr, typename _BoundFn>
600  static _Task_setter<_Res_ptr, _BoundFn>
601  _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call)
602  {
603  return { std::__addressof(__ptr), std::__addressof(__call) };
604  }
605  };
606 
607  /// Partial specialization for reference types.
608  template<typename _Res>
610  {
611  typedef _Res& result_type;
612 
613  _Result() noexcept : _M_value_ptr() { }
614 
615  void
616  _M_set(_Res& __res) noexcept
617  { _M_value_ptr = std::addressof(__res); }
618 
619  _Res& _M_get() noexcept { return *_M_value_ptr; }
620 
621  private:
622  _Res* _M_value_ptr;
623 
624  void _M_destroy() { delete this; }
625  };
626 
627  /// Explicit specialization for void.
628  template<>
630  {
631  typedef void result_type;
632 
633  private:
634  void _M_destroy() { delete this; }
635  };
636 
637 #ifndef _GLIBCXX_ASYNC_ABI_COMPAT
638 
639  // Allow _Setter objects to be stored locally in std::function
640  template<typename _Res, typename _Arg>
642  <__future_base::_State_base::_Setter<_Res, _Arg>>
643  : true_type { };
644 
645  // Allow _Task_setter objects to be stored locally in std::function
646  template<typename _Res_ptr, typename _Fn, typename _Res>
648  <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>>
649  : true_type { };
650 
651  /// Common implementation for future and shared_future.
652  template<typename _Res>
653  class __basic_future : public __future_base
654  {
655  protected:
658 
659  private:
660  __state_type _M_state;
661 
662  public:
663  // Disable copying.
664  __basic_future(const __basic_future&) = delete;
665  __basic_future& operator=(const __basic_future&) = delete;
666 
667  bool
668  valid() const noexcept { return static_cast<bool>(_M_state); }
669 
670  void
671  wait() const
672  {
673  _State_base::_S_check(_M_state);
674  _M_state->wait();
675  }
676 
677  template<typename _Rep, typename _Period>
679  wait_for(const chrono::duration<_Rep, _Period>& __rel) const
680  {
681  _State_base::_S_check(_M_state);
682  return _M_state->wait_for(__rel);
683  }
684 
685  template<typename _Clock, typename _Duration>
687  wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
688  {
689  _State_base::_S_check(_M_state);
690  return _M_state->wait_until(__abs);
691  }
692 
693  protected:
694  /// Wait for the state to be ready and rethrow any stored exception
695  __result_type
697  {
698  _State_base::_S_check(_M_state);
699  _Result_base& __res = _M_state->wait();
700  if (!(__res._M_error == 0))
701  rethrow_exception(__res._M_error);
702  return static_cast<__result_type>(__res);
703  }
704 
705  void _M_swap(__basic_future& __that) noexcept
706  {
707  _M_state.swap(__that._M_state);
708  }
709 
710  // Construction of a future by promise::get_future()
711  explicit
712  __basic_future(const __state_type& __state) : _M_state(__state)
713  {
714  _State_base::_S_check(_M_state);
715  _M_state->_M_set_retrieved_flag();
716  }
717 
718  // Copy construction from a shared_future
719  explicit
720  __basic_future(const shared_future<_Res>&) noexcept;
721 
722  // Move construction from a shared_future
723  explicit
725 
726  // Move construction from a future
727  explicit
728  __basic_future(future<_Res>&&) noexcept;
729 
730  constexpr __basic_future() noexcept : _M_state() { }
731 
732  struct _Reset
733  {
734  explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { }
735  ~_Reset() { _M_fut._M_state.reset(); }
736  __basic_future& _M_fut;
737  };
738  };
739 
740 
741  /// Primary template for future.
742  template<typename _Res>
743  class future : public __basic_future<_Res>
744  {
745  friend class promise<_Res>;
746  template<typename> friend class packaged_task;
747  template<typename _Fn, typename... _Args>
748  friend future<__async_result_of<_Fn, _Args...>>
749  async(launch, _Fn&&, _Args&&...);
750 
751  typedef __basic_future<_Res> _Base_type;
752  typedef typename _Base_type::__state_type __state_type;
753 
754  explicit
755  future(const __state_type& __state) : _Base_type(__state) { }
756 
757  public:
758  constexpr future() noexcept : _Base_type() { }
759 
760  /// Move constructor
761  future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
762 
763  // Disable copying
764  future(const future&) = delete;
765  future& operator=(const future&) = delete;
766 
767  future& operator=(future&& __fut) noexcept
768  {
769  future(std::move(__fut))._M_swap(*this);
770  return *this;
771  }
772 
773  /// Retrieving the value
774  _Res
775  get()
776  {
777  typename _Base_type::_Reset __reset(*this);
778  return std::move(this->_M_get_result()._M_value());
779  }
780 
781  shared_future<_Res> share() noexcept;
782  };
783 
784  /// Partial specialization for future<R&>
785  template<typename _Res>
786  class future<_Res&> : public __basic_future<_Res&>
787  {
788  friend class promise<_Res&>;
789  template<typename> friend class packaged_task;
790  template<typename _Fn, typename... _Args>
791  friend future<__async_result_of<_Fn, _Args...>>
792  async(launch, _Fn&&, _Args&&...);
793 
795  typedef typename _Base_type::__state_type __state_type;
796 
797  explicit
798  future(const __state_type& __state) : _Base_type(__state) { }
799 
800  public:
801  constexpr future() noexcept : _Base_type() { }
802 
803  /// Move constructor
804  future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
805 
806  // Disable copying
807  future(const future&) = delete;
808  future& operator=(const future&) = delete;
809 
810  future& operator=(future&& __fut) noexcept
811  {
812  future(std::move(__fut))._M_swap(*this);
813  return *this;
814  }
815 
816  /// Retrieving the value
817  _Res&
818  get()
819  {
820  typename _Base_type::_Reset __reset(*this);
821  return this->_M_get_result()._M_get();
822  }
823 
824  shared_future<_Res&> share() noexcept;
825  };
826 
827  /// Explicit specialization for future<void>
828  template<>
829  class future<void> : public __basic_future<void>
830  {
831  friend class promise<void>;
832  template<typename> friend class packaged_task;
833  template<typename _Fn, typename... _Args>
834  friend future<__async_result_of<_Fn, _Args...>>
835  async(launch, _Fn&&, _Args&&...);
836 
838  typedef typename _Base_type::__state_type __state_type;
839 
840  explicit
841  future(const __state_type& __state) : _Base_type(__state) { }
842 
843  public:
844  constexpr future() noexcept : _Base_type() { }
845 
846  /// Move constructor
847  future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
848 
849  // Disable copying
850  future(const future&) = delete;
851  future& operator=(const future&) = delete;
852 
853  future& operator=(future&& __fut) noexcept
854  {
855  future(std::move(__fut))._M_swap(*this);
856  return *this;
857  }
858 
859  /// Retrieving the value
860  void
861  get()
862  {
863  typename _Base_type::_Reset __reset(*this);
864  this->_M_get_result();
865  }
866 
867  shared_future<void> share() noexcept;
868  };
869 
870 
871  /// Primary template for shared_future.
872  template<typename _Res>
873  class shared_future : public __basic_future<_Res>
874  {
876 
877  public:
878  constexpr shared_future() noexcept : _Base_type() { }
879 
880  /// Copy constructor
881  shared_future(const shared_future& __sf) : _Base_type(__sf) { }
882 
883  /// Construct from a future rvalue
884  shared_future(future<_Res>&& __uf) noexcept
885  : _Base_type(std::move(__uf))
886  { }
887 
888  /// Construct from a shared_future rvalue
889  shared_future(shared_future&& __sf) noexcept
890  : _Base_type(std::move(__sf))
891  { }
892 
893  shared_future& operator=(const shared_future& __sf)
894  {
895  shared_future(__sf)._M_swap(*this);
896  return *this;
897  }
898 
899  shared_future& operator=(shared_future&& __sf) noexcept
900  {
901  shared_future(std::move(__sf))._M_swap(*this);
902  return *this;
903  }
904 
905  /// Retrieving the value
906  const _Res&
907  get() const { return this->_M_get_result()._M_value(); }
908  };
909 
910  /// Partial specialization for shared_future<R&>
911  template<typename _Res>
912  class shared_future<_Res&> : public __basic_future<_Res&>
913  {
915 
916  public:
917  constexpr shared_future() noexcept : _Base_type() { }
918 
919  /// Copy constructor
920  shared_future(const shared_future& __sf) : _Base_type(__sf) { }
921 
922  /// Construct from a future rvalue
923  shared_future(future<_Res&>&& __uf) noexcept
924  : _Base_type(std::move(__uf))
925  { }
926 
927  /// Construct from a shared_future rvalue
928  shared_future(shared_future&& __sf) noexcept
929  : _Base_type(std::move(__sf))
930  { }
931 
932  shared_future& operator=(const shared_future& __sf)
933  {
934  shared_future(__sf)._M_swap(*this);
935  return *this;
936  }
937 
938  shared_future& operator=(shared_future&& __sf) noexcept
939  {
940  shared_future(std::move(__sf))._M_swap(*this);
941  return *this;
942  }
943 
944  /// Retrieving the value
945  _Res&
946  get() const { return this->_M_get_result()._M_get(); }
947  };
948 
949  /// Explicit specialization for shared_future<void>
950  template<>
951  class shared_future<void> : public __basic_future<void>
952  {
954 
955  public:
956  constexpr shared_future() noexcept : _Base_type() { }
957 
958  /// Copy constructor
959  shared_future(const shared_future& __sf) : _Base_type(__sf) { }
960 
961  /// Construct from a future rvalue
962  shared_future(future<void>&& __uf) noexcept
963  : _Base_type(std::move(__uf))
964  { }
965 
966  /// Construct from a shared_future rvalue
967  shared_future(shared_future&& __sf) noexcept
968  : _Base_type(std::move(__sf))
969  { }
970 
971  shared_future& operator=(const shared_future& __sf)
972  {
973  shared_future(__sf)._M_swap(*this);
974  return *this;
975  }
976 
977  shared_future& operator=(shared_future&& __sf) noexcept
978  {
979  shared_future(std::move(__sf))._M_swap(*this);
980  return *this;
981  }
982 
983  // Retrieving the value
984  void
985  get() const { this->_M_get_result(); }
986  };
987 
988  // Now we can define the protected __basic_future constructors.
989  template<typename _Res>
991  __basic_future(const shared_future<_Res>& __sf) noexcept
992  : _M_state(__sf._M_state)
993  { }
994 
995  template<typename _Res>
997  __basic_future(shared_future<_Res>&& __sf) noexcept
998  : _M_state(std::move(__sf._M_state))
999  { }
1000 
1001  template<typename _Res>
1002  inline __basic_future<_Res>::
1003  __basic_future(future<_Res>&& __uf) noexcept
1004  : _M_state(std::move(__uf._M_state))
1005  { }
1006 
1007  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1008  // 2556. Wide contract for future::share()
1009  template<typename _Res>
1010  inline shared_future<_Res>
1011  future<_Res>::share() noexcept
1012  { return shared_future<_Res>(std::move(*this)); }
1013 
1014  template<typename _Res>
1015  inline shared_future<_Res&>
1016  future<_Res&>::share() noexcept
1017  { return shared_future<_Res&>(std::move(*this)); }
1018 
1019  inline shared_future<void>
1020  future<void>::share() noexcept
1021  { return shared_future<void>(std::move(*this)); }
1022 
1023  /// Primary template for promise
1024  template<typename _Res>
1025  class promise
1026  {
1027  typedef __future_base::_State_base _State;
1028  typedef __future_base::_Result<_Res> _Res_type;
1029  typedef __future_base::_Ptr<_Res_type> _Ptr_type;
1030  template<typename, typename> friend class _State::_Setter;
1031 
1032  shared_ptr<_State> _M_future;
1033  _Ptr_type _M_storage;
1034 
1035  public:
1036  promise()
1037  : _M_future(std::make_shared<_State>()),
1038  _M_storage(new _Res_type())
1039  { }
1040 
1041  promise(promise&& __rhs) noexcept
1042  : _M_future(std::move(__rhs._M_future)),
1043  _M_storage(std::move(__rhs._M_storage))
1044  { }
1045 
1046  template<typename _Allocator>
1047  promise(allocator_arg_t, const _Allocator& __a)
1048  : _M_future(std::allocate_shared<_State>(__a)),
1049  _M_storage(__future_base::_S_allocate_result<_Res>(__a))
1050  { }
1051 
1052  template<typename _Allocator>
1053  promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
1054  : _M_future(std::move(__rhs._M_future)),
1055  _M_storage(std::move(__rhs._M_storage))
1056  { }
1057 
1058  promise(const promise&) = delete;
1059 
1060  ~promise()
1061  {
1062  if (static_cast<bool>(_M_future) && !_M_future.unique())
1063  _M_future->_M_break_promise(std::move(_M_storage));
1064  }
1065 
1066  // Assignment
1067  promise&
1068  operator=(promise&& __rhs) noexcept
1069  {
1070  promise(std::move(__rhs)).swap(*this);
1071  return *this;
1072  }
1073 
1074  promise& operator=(const promise&) = delete;
1075 
1076  void
1077  swap(promise& __rhs) noexcept
1078  {
1079  _M_future.swap(__rhs._M_future);
1080  _M_storage.swap(__rhs._M_storage);
1081  }
1082 
1083  // Retrieving the result
1084  future<_Res>
1085  get_future()
1086  { return future<_Res>(_M_future); }
1087 
1088  // Setting the result
1089  void
1090  set_value(const _Res& __r)
1091  { _M_future->_M_set_result(_State::__setter(this, __r)); }
1092 
1093  void
1094  set_value(_Res&& __r)
1095  { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }
1096 
1097  void
1098  set_exception(exception_ptr __p)
1099  { _M_future->_M_set_result(_State::__setter(__p, this)); }
1100 
1101  void
1102  set_value_at_thread_exit(const _Res& __r)
1103  {
1104  _M_future->_M_set_delayed_result(_State::__setter(this, __r),
1105  _M_future);
1106  }
1107 
1108  void
1109  set_value_at_thread_exit(_Res&& __r)
1110  {
1111  _M_future->_M_set_delayed_result(
1112  _State::__setter(this, std::move(__r)), _M_future);
1113  }
1114 
1115  void
1116  set_exception_at_thread_exit(exception_ptr __p)
1117  {
1118  _M_future->_M_set_delayed_result(_State::__setter(__p, this),
1119  _M_future);
1120  }
1121  };
1122 
1123  template<typename _Res>
1124  inline void
1125  swap(promise<_Res>& __x, promise<_Res>& __y) noexcept
1126  { __x.swap(__y); }
1127 
1128  template<typename _Res, typename _Alloc>
1129  struct uses_allocator<promise<_Res>, _Alloc>
1130  : public true_type { };
1131 
1132 
1133  /// Partial specialization for promise<R&>
1134  template<typename _Res>
1135  class promise<_Res&>
1136  {
1137  typedef __future_base::_State_base _State;
1140  template<typename, typename> friend class _State::_Setter;
1141 
1142  shared_ptr<_State> _M_future;
1143  _Ptr_type _M_storage;
1144 
1145  public:
1146  promise()
1147  : _M_future(std::make_shared<_State>()),
1148  _M_storage(new _Res_type())
1149  { }
1150 
1151  promise(promise&& __rhs) noexcept
1152  : _M_future(std::move(__rhs._M_future)),
1153  _M_storage(std::move(__rhs._M_storage))
1154  { }
1155 
1156  template<typename _Allocator>
1157  promise(allocator_arg_t, const _Allocator& __a)
1158  : _M_future(std::allocate_shared<_State>(__a)),
1159  _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
1160  { }
1161 
1162  template<typename _Allocator>
1163  promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
1164  : _M_future(std::move(__rhs._M_future)),
1165  _M_storage(std::move(__rhs._M_storage))
1166  { }
1167 
1168  promise(const promise&) = delete;
1169 
1170  ~promise()
1171  {
1172  if (static_cast<bool>(_M_future) && !_M_future.unique())
1173  _M_future->_M_break_promise(std::move(_M_storage));
1174  }
1175 
1176  // Assignment
1177  promise&
1178  operator=(promise&& __rhs) noexcept
1179  {
1180  promise(std::move(__rhs)).swap(*this);
1181  return *this;
1182  }
1183 
1184  promise& operator=(const promise&) = delete;
1185 
1186  void
1187  swap(promise& __rhs) noexcept
1188  {
1189  _M_future.swap(__rhs._M_future);
1190  _M_storage.swap(__rhs._M_storage);
1191  }
1192 
1193  // Retrieving the result
1195  get_future()
1196  { return future<_Res&>(_M_future); }
1197 
1198  // Setting the result
1199  void
1200  set_value(_Res& __r)
1201  { _M_future->_M_set_result(_State::__setter(this, __r)); }
1202 
1203  void
1204  set_exception(exception_ptr __p)
1205  { _M_future->_M_set_result(_State::__setter(__p, this)); }
1206 
1207  void
1208  set_value_at_thread_exit(_Res& __r)
1209  {
1210  _M_future->_M_set_delayed_result(_State::__setter(this, __r),
1211  _M_future);
1212  }
1213 
1214  void
1215  set_exception_at_thread_exit(exception_ptr __p)
1216  {
1217  _M_future->_M_set_delayed_result(_State::__setter(__p, this),
1218  _M_future);
1219  }
1220  };
1221 
1222  /// Explicit specialization for promise<void>
1223  template<>
1224  class promise<void>
1225  {
1226  typedef __future_base::_State_base _State;
1229  template<typename, typename> friend class _State::_Setter;
1230 
1231  shared_ptr<_State> _M_future;
1232  _Ptr_type _M_storage;
1233 
1234  public:
1235  promise()
1236  : _M_future(std::make_shared<_State>()),
1237  _M_storage(new _Res_type())
1238  { }
1239 
1240  promise(promise&& __rhs) noexcept
1241  : _M_future(std::move(__rhs._M_future)),
1242  _M_storage(std::move(__rhs._M_storage))
1243  { }
1244 
1245  template<typename _Allocator>
1246  promise(allocator_arg_t, const _Allocator& __a)
1247  : _M_future(std::allocate_shared<_State>(__a)),
1248  _M_storage(__future_base::_S_allocate_result<void>(__a))
1249  { }
1250 
1251  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1252  // 2095. missing constructors needed for uses-allocator construction
1253  template<typename _Allocator>
1254  promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
1255  : _M_future(std::move(__rhs._M_future)),
1256  _M_storage(std::move(__rhs._M_storage))
1257  { }
1258 
1259  promise(const promise&) = delete;
1260 
1261  ~promise()
1262  {
1263  if (static_cast<bool>(_M_future) && !_M_future.unique())
1264  _M_future->_M_break_promise(std::move(_M_storage));
1265  }
1266 
1267  // Assignment
1268  promise&
1269  operator=(promise&& __rhs) noexcept
1270  {
1271  promise(std::move(__rhs)).swap(*this);
1272  return *this;
1273  }
1274 
1275  promise& operator=(const promise&) = delete;
1276 
1277  void
1278  swap(promise& __rhs) noexcept
1279  {
1280  _M_future.swap(__rhs._M_future);
1281  _M_storage.swap(__rhs._M_storage);
1282  }
1283 
1284  // Retrieving the result
1285  future<void>
1286  get_future()
1287  { return future<void>(_M_future); }
1288 
1289  // Setting the result
1290  void set_value();
1291 
1292  void
1293  set_exception(exception_ptr __p)
1294  { _M_future->_M_set_result(_State::__setter(__p, this)); }
1295 
1296  void
1297  set_value_at_thread_exit();
1298 
1299  void
1300  set_exception_at_thread_exit(exception_ptr __p)
1301  {
1302  _M_future->_M_set_delayed_result(_State::__setter(__p, this),
1303  _M_future);
1304  }
1305  };
1306 
1307  // set void
1308  template<>
1309  struct __future_base::_State_base::_Setter<void, void>
1310  {
1311  promise<void>::_Ptr_type operator()() const
1312  {
1313  _State_base::_S_check(_M_promise->_M_future);
1314  return std::move(_M_promise->_M_storage);
1315  }
1316 
1317  promise<void>* _M_promise;
1318  };
1319 
1320  inline void
1322  { _M_future->_M_set_result(_State::_Setter<void, void>{ this }); }
1323 
1324  inline void
1326  {
1327  _M_future->_M_set_delayed_result(_State::_Setter<void, void>{this},
1328  _M_future);
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  // && ATOMIC_INT_LOCK_FREE
1755 
1756  // @} group futures
1757 _GLIBCXX_END_NAMESPACE_VERSION
1758 } // namespace
1759 
1760 #endif // C++11
1761 
1762 #endif // _GLIBCXX_FUTURE
An opaque pointer to an arbitrary exception.
Definition: exception_ptr.h:83
future(future &&__uf) noexcept
Move constructor.
Definition: future:847
Explicit specialization for promise<void>
Definition: future:1224
A result object that uses an allocator.
Definition: future:269
future< __async_result_of< _Fn, _Args... > > async(launch __policy, _Fn &&__fn, _Args &&... __args)
async
Definition: future:1712
shared_future(const shared_future &__sf)
Copy constructor.
Definition: future:920
Common implementation for future and shared_future.
Definition: future:653
Primary template for future.
Definition: future:125
20.7.1.2 unique_ptr for single objects.
Definition: unique_ptr.h:153
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
Definition: future:928
thread
Definition: thread:62
Explicit specialization for void.
Definition: future:629
error_condition
Definition: system_error:223
future_errc
Error code for futures.
Definition: future:66
void swap(unique_ptr &__u) noexcept
Exchange the pointer and deleter with another object.
Definition: unique_ptr.h:369
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.
Explicit specialization for shared_future<void>
Definition: future:951
Base class for results.
Definition: future:202
Partial specialization for future<R&>
Definition: future:786
void rethrow_exception(exception_ptr) __attribute__((__noreturn__))
Throw the object pointed to by the exception_ptr.
ISO C++ entities toplevel namespace is std.
Exception type thrown by futures.
Definition: future:96
future(future &&__uf) noexcept
Move constructor.
Definition: future:804
A result object that has storage for an object of type _Res.
Definition: future:228
One of two subclasses of exception.
Definition: stdexcept:113
Partial specialization for shared_future<R&>
Definition: future:912
Base class and enclosing scope.
Definition: future:199
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
Definition: future:967
shared_future(const shared_future &__sf)
Copy constructor.
Definition: future:959
shared_future(future< void > &&__uf) noexcept
Construct from a future rvalue.
Definition: future:962
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:599
Declare uses_allocator so it can be specialized in <queue> etc.
Definition: memoryfwd.h:71
exception_ptr current_exception() noexcept
__allocated_ptr< _Alloc > __allocate_guarded(_Alloc &__a)
Allocate space for a single object using __a.
is_error_code_enum
Definition: system_error:53
integral_constant
Definition: type_traits:69
atomic_flag
Definition: atomic_base.h:160
__result_type _M_get_result() const
Wait for the state to be ready and rethrow any stored exception.
Definition: future:696
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:761
Partial specialization for reference types.
Definition: future:609
error_code
Definition: system_error:145
void swap(packaged_task< _Res(_ArgTypes...)> &__x, packaged_task< _Res(_ArgTypes...)> &__y) noexcept
swap
Definition: future:1579
shared_future(future< _Res &> &&__uf) noexcept
Construct from a future rvalue.
Definition: future:923
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:881
Primary template for shared_future.
Definition: future:128
future_status
Status code for futures.
Definition: future:174
once_flag
Definition: mutex:561
Thrown to indicate error code of underlying system.
Definition: system_error:340
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
Definition: cxxabi_forced.h:48
A smart pointer with reference-counted copy semantics.
constexpr result_of< _Callable &&(_Args &&...)>::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_callable< _Callable &&(_Args &&...)>::value)
Invoke a callable object.
Definition: invoke.h:89
Explicit specialization for future<void>
Definition: future:829
Primary template for promise.
Definition: future:134
launch
Launch code for futures.
Definition: future:137
shared_future(future< _Res > &&__uf) noexcept
Construct from a future rvalue.
Definition: future:884
The standard allocator, as per [20.4].
Definition: allocator.h:108
[allocator.tag]
Non-standard RAII type for managing pointers obtained from allocators.
Definition: allocated_ptr.h:46
shared_future(shared_future &&__sf) noexcept
Construct from a shared_future rvalue.
Definition: future:889