OSDN Git Service

2010-11-23 Benjamin Kosnik <bkoz@redhat.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / std / future
1 // <future> -*- C++ -*-
2
3 // Copyright (C) 2009, 2010 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 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 #ifndef __GXX_EXPERIMENTAL_CXX0X__
35 # include <bits/c++0x_warning.h>
36 #else
37
38 #include <functional>
39 #include <memory>
40 #include <mutex>
41 #include <thread>
42 #include <condition_variable>
43 #include <system_error>
44 #include <exception>
45 #include <atomic>
46 #include <bits/functexcept.h>
47
48 _GLIBCXX_BEGIN_NAMESPACE(std)
49
50   /**
51    * @defgroup futures Futures
52    * @ingroup concurrency
53    *
54    * Classes for futures support.
55    * @{
56    */
57
58   /// Error code for futures
59   enum class future_errc
60   {
61     broken_promise,
62     future_already_retrieved,
63     promise_already_satisfied,
64     no_state
65   };
66
67   /// Specialization.
68   template<>
69     struct is_error_code_enum<future_errc> : public true_type { };
70
71   /// Points to a statically-allocated object derived from error_category.
72   const error_category&
73   future_category();
74
75   /// Overload for make_error_code.
76   inline error_code 
77   make_error_code(future_errc __errc)
78   { return error_code(static_cast<int>(__errc), future_category()); }
79
80   /// Overload for make_error_condition.
81   inline error_condition 
82   make_error_condition(future_errc __errc)
83   { return error_condition(static_cast<int>(__errc), future_category()); }
84
85   /**
86    *  @brief Exception type thrown by futures.
87    *  @ingroup exceptions
88    */
89   class future_error : public logic_error
90   {
91     error_code                  _M_code;
92
93   public:
94     explicit future_error(error_code __ec)
95     : logic_error("std::future_error"), _M_code(__ec)
96     { }
97
98     virtual ~future_error() throw();
99
100     virtual const char* 
101     what() const throw();
102
103     const error_code& 
104     code() const throw() { return _M_code; }
105   };
106
107   // Forward declarations.
108   template<typename _Res>
109     class future;
110
111   template<typename _Res>
112     class shared_future;
113
114   template<typename _Res>
115     class atomic_future;
116
117   template<typename _Signature> 
118     class packaged_task;
119
120   template<typename _Res>
121     class promise;
122
123   /// Launch code for futures
124   enum class launch 
125   { 
126     any, 
127     async, 
128     sync 
129   };
130
131   /// Status code for futures
132   enum class future_status 
133   {
134     ready,
135     timeout,
136     deferred
137   };
138
139   template<typename _Fn, typename... _Args>
140     future<typename result_of<_Fn(_Args...)>::type>
141     async(launch __policy, _Fn&& __fn, _Args&&... __args);
142
143   template<typename _Fn, typename... _Args>
144     typename
145     enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
146               future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
147              >::type
148     async(_Fn&& __fn, _Args&&... __args);
149
150 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
151   && defined(_GLIBCXX_ATOMIC_BUILTINS_4)
152
153   /// Base class and enclosing scope.
154   struct __future_base
155   {
156     /// Base class for results.
157     struct _Result_base
158     {
159       exception_ptr             _M_error;
160
161       _Result_base() = default;
162       _Result_base(const _Result_base&) = delete;
163       _Result_base& operator=(const _Result_base&) = delete;
164
165       // _M_destroy() allows derived classes to control deallocation
166       virtual void _M_destroy() = 0;
167
168       struct _Deleter
169       {
170         void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
171       };
172
173     protected:
174       ~_Result_base();
175     };
176
177     /// Result.
178     template<typename _Res>
179       struct _Result : _Result_base
180       {
181       private:
182         typedef alignment_of<_Res>                              __a_of;
183         typedef aligned_storage<sizeof(_Res), __a_of::value>    __align_storage;
184         typedef typename __align_storage::type                  __align_type;
185
186         __align_type            _M_storage;
187         bool                    _M_initialized;
188
189       public:
190         _Result() : _M_initialized() { }
191         
192         ~_Result()
193         {
194           if (_M_initialized)
195             _M_value().~_Res();
196         }
197
198         // Return lvalue, future will add const or rvalue-reference
199         _Res& 
200         _M_value() { return *static_cast<_Res*>(_M_addr()); }
201
202         void
203         _M_set(const _Res& __res)
204         {
205           ::new (_M_addr()) _Res(__res);
206           _M_initialized = true;
207         }
208
209         void
210         _M_set(_Res&& __res)
211         {
212           ::new (_M_addr()) _Res(std::move(__res));
213           _M_initialized = true;
214         }
215
216       private:
217         void _M_destroy() { delete this; }
218
219         void* _M_addr() { return static_cast<void*>(&_M_storage); }
220     };
221
222     // TODO: use template alias when available
223     /*
224       template<typename _Res>
225       using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
226     */
227     /// A unique_ptr based on the instantiating type.
228     template<typename _Res>
229       struct _Ptr
230       {
231         typedef unique_ptr<_Res, _Result_base::_Deleter> type;
232       };
233
234     /// Result_alloc.
235     template<typename _Res, typename _Alloc>
236       struct _Result_alloc : _Result<_Res>, _Alloc
237       {
238         typedef typename _Alloc::template rebind<_Result_alloc>::other
239           __allocator_type;
240
241         explicit
242         _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
243         { }
244         
245       private:
246         void _M_destroy()
247         {
248           __allocator_type __a(*this);
249           __a.destroy(this);
250           __a.deallocate(this, 1);
251         }
252       };
253
254     template<typename _Res, typename _Allocator>
255       static typename _Ptr<_Result_alloc<_Res, _Allocator>>::type
256       _S_allocate_result(const _Allocator& __a)
257       {
258         typedef _Result_alloc<_Res, _Allocator> __result_type;
259         typename __result_type::__allocator_type __a2(__a);
260         __result_type* __p = __a2.allocate(1);
261         __try
262         {
263           __a2.construct(__p, __a);
264         }
265         __catch(...)
266         {
267           __a2.deallocate(__p, 1);
268           __throw_exception_again;
269         }
270         return typename _Ptr<__result_type>::type(__p);
271       }
272
273
274     /// Shared state between a promise and one or more associated futures.
275     class _State
276     {
277       typedef _Ptr<_Result_base>::type _Ptr_type;
278
279       _Ptr_type                 _M_result;
280       mutex                     _M_mutex;
281       condition_variable        _M_cond;
282       atomic_flag               _M_retrieved;
283       once_flag                 _M_once;
284
285     public:
286       _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
287
288       _State(const _State&) = delete;
289       _State& operator=(const _State&) = delete;
290
291       _Result_base&
292       wait()
293       {
294         _M_run_deferred();
295         unique_lock<mutex> __lock(_M_mutex);
296         if (!_M_ready())
297           _M_cond.wait(__lock, std::bind<bool>(&_State::_M_ready, this));
298         return *_M_result;
299       }
300
301       template<typename _Rep, typename _Period>
302         bool
303         wait_for(const chrono::duration<_Rep, _Period>& __rel)
304         {
305           unique_lock<mutex> __lock(_M_mutex);
306           auto __bound = std::bind<bool>(&_State::_M_ready, this);
307           return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound);
308         }
309
310       template<typename _Clock, typename _Duration>
311         bool
312         wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
313         {
314           unique_lock<mutex> __lock(_M_mutex);
315           auto __bound = std::bind<bool>(&_State::_M_ready, this);
316           return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound);
317         }
318
319       void
320       _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
321       {
322         bool __set = __ignore_failure;
323         // all calls to this function are serialized,
324         // side-effects of invoking __res only happen once
325         call_once(_M_once, &_State::_M_do_set, this, ref(__res),
326             ref(__set));
327         if (!__set)
328           __throw_future_error(int(future_errc::promise_already_satisfied));
329       }
330
331       void
332       _M_break_promise(_Ptr_type __res)
333       {
334         if (static_cast<bool>(__res))
335           {
336             error_code __ec(make_error_code(future_errc::broken_promise));
337             __res->_M_error = copy_exception(future_error(__ec));
338             {
339               lock_guard<mutex> __lock(_M_mutex);
340               _M_result.swap(__res);
341             }
342             _M_cond.notify_all();
343           }
344       }
345
346       // Called when this object is passed to a future.
347       void
348       _M_set_retrieved_flag()
349       {
350         if (_M_retrieved.test_and_set())
351           __throw_future_error(int(future_errc::future_already_retrieved));
352       }
353
354       template<typename _Res, typename _Arg>
355         struct _Setter;
356
357       // set lvalues
358       template<typename _Res, typename _Arg>
359         struct _Setter<_Res, _Arg&>
360         {
361           // check this is only used by promise<R>::set_value(const R&)
362           // or promise<R>::set_value(R&)
363           static_assert(is_same<_Res, _Arg&>::value  // promise<R&>
364               || is_same<const _Res, _Arg>::value,  // promise<R>
365               "Invalid specialisation");
366
367           typename promise<_Res>::_Ptr_type operator()()
368           {
369             _State::_S_check(_M_promise->_M_future);
370             _M_promise->_M_storage->_M_set(_M_arg);
371             return std::move(_M_promise->_M_storage);
372           }
373           promise<_Res>*    _M_promise;
374           _Arg&             _M_arg;
375         };
376
377       // set rvalues
378       template<typename _Res>
379         struct _Setter<_Res, _Res&&>
380         {
381           typename promise<_Res>::_Ptr_type operator()()
382           {
383             _State::_S_check(_M_promise->_M_future);
384             _M_promise->_M_storage->_M_set(std::move(_M_arg));
385             return std::move(_M_promise->_M_storage);
386           }
387           promise<_Res>*    _M_promise;
388           _Res&             _M_arg;
389         };
390
391       struct __exception_ptr_tag { };
392
393       // set exceptions
394       template<typename _Res>
395         struct _Setter<_Res, __exception_ptr_tag>
396         {
397           typename promise<_Res>::_Ptr_type operator()()
398           {
399             _State::_S_check(_M_promise->_M_future);
400             _M_promise->_M_storage->_M_error = _M_ex;
401             return std::move(_M_promise->_M_storage);
402           }
403
404           promise<_Res>*   _M_promise;
405           exception_ptr&    _M_ex;
406         };
407
408       template<typename _Res, typename _Arg>
409         static _Setter<_Res, _Arg&&>
410         __setter(promise<_Res>* __prom, _Arg&& __arg)
411         {
412           return _Setter<_Res, _Arg&&>{ __prom, __arg };
413         }
414
415       template<typename _Res>
416         static _Setter<_Res, __exception_ptr_tag>
417         __setter(exception_ptr& __ex, promise<_Res>* __prom)
418         {
419           return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex };
420         }
421
422       static _Setter<void, void>
423       __setter(promise<void>* __prom);
424
425       template<typename _Tp>
426         static bool
427         _S_check(const shared_ptr<_Tp>& __p)
428         {
429           if (!static_cast<bool>(__p))
430             __throw_future_error((int)future_errc::no_state);
431         }
432
433     private:
434       void
435       _M_do_set(function<_Ptr_type()>& __f, bool& __set)
436       {
437         _Ptr_type __res = __f();
438         {
439           lock_guard<mutex> __lock(_M_mutex);
440           _M_result.swap(__res);
441         }
442         _M_cond.notify_all();
443         __set = true;
444       }
445
446       bool _M_ready() const { return static_cast<bool>(_M_result); }
447
448       virtual void _M_run_deferred() { }
449     };
450
451     template<typename _Res>
452       class _Deferred_state;
453
454     template<typename _Res>
455       class _Async_state;
456
457     template<typename _Signature>
458       class _Task_state;
459
460     template<typename _StateT, typename _Res = typename _StateT::_Res_type>
461       struct _Task_setter;
462   };
463
464   inline __future_base::_Result_base::~_Result_base() = default;
465
466   /// Partial specialization for reference types.
467   template<typename _Res>
468     struct __future_base::_Result<_Res&> : __future_base::_Result_base
469     {
470       _Result() : _M_value_ptr() { }
471
472       void _M_set(_Res& __res) { _M_value_ptr = &__res; }
473
474       _Res& _M_get() { return *_M_value_ptr; }
475
476     private:
477       _Res*                     _M_value_ptr;
478       
479       void _M_destroy() { delete this; }
480     };
481
482   /// Explicit specialization for void.
483   template<>
484     struct __future_base::_Result<void> : __future_base::_Result_base
485     {
486     private:
487       void _M_destroy() { delete this; }
488     };
489
490
491   /// Common implementation for future and shared_future.
492   template<typename _Res>
493     class __basic_future : public __future_base
494     {
495     protected:
496       typedef shared_ptr<_State>                __state_type;
497       typedef __future_base::_Result<_Res>&     __result_type;
498
499     private:
500       __state_type              _M_state;
501
502     public:
503       // Disable copying.
504       __basic_future(const __basic_future&) = delete;
505       __basic_future& operator=(const __basic_future&) = delete;
506
507       bool 
508       valid() const { return static_cast<bool>(_M_state); }
509
510       void 
511       wait() const { _M_state->wait(); }
512
513       template<typename _Rep, typename _Period>
514         bool
515         wait_for(const chrono::duration<_Rep, _Period>& __rel) const
516         { return _M_state->wait_for(__rel); }
517
518       template<typename _Clock, typename _Duration>
519         bool
520         wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
521         { return _M_state->wait_until(__abs); }
522
523     protected:
524       /// Wait for the state to be ready and rethrow any stored exception
525       __result_type
526       _M_get_result()
527       {
528         _Result_base& __res = _M_state->wait();
529         if (!(__res._M_error == 0))
530           rethrow_exception(__res._M_error);
531         return static_cast<__result_type>(__res);
532       }
533
534       void _M_swap(__basic_future& __that)
535       {
536         _M_state.swap(__that._M_state);
537       }
538
539       // Construction of a future by promise::get_future()
540       explicit
541       __basic_future(const __state_type& __state) : _M_state(__state)
542       {
543         _State::_S_check(_M_state);
544         _M_state->_M_set_retrieved_flag();
545       }
546
547       // Copy construction from a shared_future
548       explicit
549       __basic_future(const shared_future<_Res>&);
550
551       // Move construction from a shared_future
552       explicit
553       __basic_future(shared_future<_Res>&&);
554
555       // Move construction from a future
556       explicit
557       __basic_future(future<_Res>&&);
558
559       constexpr __basic_future() : _M_state() { }
560
561       struct _Reset
562       {
563         explicit _Reset(__basic_future& __fut) : _M_fut(__fut) { }
564         ~_Reset() { _M_fut._M_state.reset(); }
565         __basic_future& _M_fut;
566       };
567     };
568
569
570   /// Primary template for future.
571   template<typename _Res>
572     class future : public __basic_future<_Res>
573     {
574       friend class promise<_Res>;
575       template<typename> friend class packaged_task;
576       template<typename _Fn, typename... _Args>
577         friend future<typename result_of<_Fn(_Args...)>::type>
578         async(launch, _Fn&&, _Args&&...);
579
580       typedef __basic_future<_Res> _Base_type;
581       typedef typename _Base_type::__state_type __state_type;
582
583       explicit
584       future(const __state_type& __state) : _Base_type(__state) { }
585
586     public:
587       constexpr future() : _Base_type() { }
588
589       /// Move constructor
590       future(future&& __uf) : _Base_type(std::move(__uf)) { }
591
592       // Disable copying
593       future(const future&) = delete;
594       future& operator=(const future&) = delete;
595
596       future& operator=(future&& __fut)
597       {
598         future(std::move(__fut))._M_swap(*this);
599         return *this;
600       }
601
602       /// Retrieving the value
603       _Res
604       get()
605       {
606         typename _Base_type::_Reset __reset(*this);
607         return std::move(this->_M_get_result()._M_value());
608       }
609     };
610  
611   /// Partial specialization for future<R&>
612   template<typename _Res>
613     class future<_Res&> : public __basic_future<_Res&>
614     {
615       friend class promise<_Res&>;
616       template<typename> friend class packaged_task;
617       template<typename _Fn, typename... _Args>
618         friend future<typename result_of<_Fn(_Args...)>::type>
619         async(launch, _Fn&&, _Args&&...);
620
621       typedef __basic_future<_Res&> _Base_type;
622       typedef typename _Base_type::__state_type __state_type;
623
624       explicit
625       future(const __state_type& __state) : _Base_type(__state) { }
626
627     public:
628       constexpr future() : _Base_type() { }
629
630       /// Move constructor
631       future(future&& __uf) : _Base_type(std::move(__uf)) { }
632
633       // Disable copying
634       future(const future&) = delete;
635       future& operator=(const future&) = delete;
636
637       future& operator=(future&& __fut)
638       {
639         future(std::move(__fut))._M_swap(*this);
640         return *this;
641       }
642
643       /// Retrieving the value
644       _Res& 
645       get()
646       {
647         typename _Base_type::_Reset __reset(*this);
648         return this->_M_get_result()._M_get();
649       }
650     };
651
652   /// Explicit specialization for future<void>
653   template<>
654     class future<void> : public __basic_future<void>
655     {
656       friend class promise<void>;
657       template<typename> friend class packaged_task;
658       template<typename _Fn, typename... _Args>
659         friend future<typename result_of<_Fn(_Args...)>::type>
660         async(launch, _Fn&&, _Args&&...);
661
662       typedef __basic_future<void> _Base_type;
663       typedef typename _Base_type::__state_type __state_type;
664
665       explicit
666       future(const __state_type& __state) : _Base_type(__state) { }
667
668     public:
669       constexpr future() : _Base_type() { }
670
671       /// Move constructor
672       future(future&& __uf) : _Base_type(std::move(__uf)) { }
673
674       // Disable copying
675       future(const future&) = delete;
676       future& operator=(const future&) = delete;
677
678       future& operator=(future&& __fut)
679       {
680         future(std::move(__fut))._M_swap(*this);
681         return *this;
682       }
683
684       /// Retrieving the value
685       void 
686       get()
687       {
688         typename _Base_type::_Reset __reset(*this);
689         this->_M_get_result();
690       }
691     };
692
693
694   /// Primary template for shared_future.
695   template<typename _Res>
696     class shared_future : public __basic_future<_Res>
697     {
698       typedef __basic_future<_Res> _Base_type;
699
700     public:
701       constexpr shared_future() : _Base_type() { }
702
703       /// Copy constructor
704       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
705
706       /// Construct from a future rvalue
707       shared_future(future<_Res>&& __uf)
708       : _Base_type(std::move(__uf))
709       { }
710
711       /// Construct from a shared_future rvalue
712       shared_future(shared_future&& __sf)
713       : _Base_type(std::move(__sf))
714       { }
715
716       shared_future& operator=(const shared_future& __sf)
717       {
718         shared_future(__sf)._M_swap(*this);
719         return *this;
720       }
721
722       shared_future& operator=(shared_future&& __sf)
723       {
724         shared_future(std::move(__sf))._M_swap(*this);
725         return *this;
726       }
727
728       /// Retrieving the value
729       const _Res&
730       get()
731       {
732         typename _Base_type::__result_type __r = this->_M_get_result();
733         _Res& __rs(__r._M_value());
734         return __rs;
735       }
736     };
737  
738   /// Partial specialization for shared_future<R&>
739   template<typename _Res>
740     class shared_future<_Res&> : public __basic_future<_Res&>
741     {
742       typedef __basic_future<_Res&>           _Base_type;
743
744     public:
745       constexpr shared_future() : _Base_type() { }
746
747       /// Copy constructor
748       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
749
750       /// Construct from a future rvalue
751       shared_future(future<_Res&>&& __uf)
752       : _Base_type(std::move(__uf))
753       { }
754
755       /// Construct from a shared_future rvalue
756       shared_future(shared_future&& __sf)
757       : _Base_type(std::move(__sf))
758       { }
759
760       shared_future& operator=(const shared_future& __sf)
761       {
762         shared_future(__sf)._M_swap(*this);
763         return *this;
764       }
765
766       shared_future& operator=(shared_future&& __sf)
767       {
768         shared_future(std::move(__sf))._M_swap(*this);
769         return *this;
770       }
771
772       /// Retrieving the value
773       _Res& 
774       get() { return this->_M_get_result()._M_get(); }
775     };
776
777   /// Explicit specialization for shared_future<void>
778   template<>
779     class shared_future<void> : public __basic_future<void>
780     {
781       typedef __basic_future<void> _Base_type;
782
783     public:
784       constexpr shared_future() : _Base_type() { }
785
786       /// Copy constructor
787       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
788
789       /// Construct from a future rvalue
790       shared_future(future<void>&& __uf)
791       : _Base_type(std::move(__uf))
792       { }
793
794       /// Construct from a shared_future rvalue
795       shared_future(shared_future&& __sf)
796       : _Base_type(std::move(__sf))
797       { }
798
799       shared_future& operator=(const shared_future& __sf)
800       {
801         shared_future(__sf)._M_swap(*this);
802         return *this;
803       }
804
805       shared_future& operator=(shared_future&& __sf)
806       {
807         shared_future(std::move(__sf))._M_swap(*this);
808         return *this;
809       }
810
811       // Retrieving the value
812       void 
813       get() { this->_M_get_result(); }
814     };
815
816   // Now we can define the protected __basic_future constructors.
817   template<typename _Res>
818     inline __basic_future<_Res>::
819     __basic_future(const shared_future<_Res>& __sf)
820     : _M_state(__sf._M_state)
821     { }
822
823   template<typename _Res>
824     inline __basic_future<_Res>::
825     __basic_future(shared_future<_Res>&& __sf)
826     : _M_state(std::move(__sf._M_state))
827     { }
828
829   template<typename _Res>
830     inline __basic_future<_Res>::
831     __basic_future(future<_Res>&& __uf)
832     : _M_state(std::move(__uf._M_state))
833     { }
834
835
836   /// Primary template for promise
837   template<typename _Res>
838     class promise
839     {
840       typedef __future_base::_State             _State;
841       typedef __future_base::_Result<_Res>      _Res_type;
842       typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
843       template<typename, typename> friend class _State::_Setter;
844       
845       shared_ptr<_State>                        _M_future;
846       _Ptr_type                                 _M_storage;
847
848     public:
849       promise()
850       : _M_future(std::make_shared<_State>()),
851         _M_storage(new _Res_type())
852       { }
853
854       promise(promise&& __rhs)
855       : _M_future(std::move(__rhs._M_future)),
856         _M_storage(std::move(__rhs._M_storage))
857       { }
858
859       template<typename _Allocator>
860         promise(allocator_arg_t, const _Allocator& __a)
861         : _M_future(std::allocate_shared<_State>(__a)),
862           _M_storage(__future_base::_S_allocate_result<_Res>(__a))
863         { }
864
865       promise(const promise&) = delete;
866
867       ~promise()
868       {
869         if (static_cast<bool>(_M_future) && !_M_future.unique())
870           _M_future->_M_break_promise(std::move(_M_storage));
871       }
872
873       // Assignment
874       promise&
875       operator=(promise&& __rhs)
876       {
877         promise(std::move(__rhs)).swap(*this);
878         return *this;
879       }
880
881       promise& operator=(const promise&) = delete;
882
883       void
884       swap(promise& __rhs)
885       {
886         _M_future.swap(__rhs._M_future);
887         _M_storage.swap(__rhs._M_storage);
888       }
889
890       // Retrieving the result
891       future<_Res>
892       get_future()
893       { return future<_Res>(_M_future); }
894
895       // Setting the result
896       void
897       set_value(const _Res& __r)
898       {
899         auto __setter = _State::__setter(this, __r);
900         _M_future->_M_set_result(std::move(__setter));
901       }
902
903       void
904       set_value(_Res&& __r)
905       {
906         auto __setter = _State::__setter(this, std::move(__r));
907         _M_future->_M_set_result(std::move(__setter));
908       }
909
910       void
911       set_exception(exception_ptr __p)
912       {
913         auto __setter = _State::__setter(__p, this);
914         _M_future->_M_set_result(std::move(__setter));
915       }
916     };
917
918   template<typename _Res>
919     inline void
920     swap(promise<_Res>& __x, promise<_Res>& __y)
921     { __x.swap(__y); }
922
923   template<typename _Res, typename _Alloc>
924     struct uses_allocator<promise<_Res>, _Alloc>
925     : public true_type { };
926
927
928   /// Partial specialization for promise<R&>
929   template<typename _Res>
930     class promise<_Res&>
931     {
932       typedef __future_base::_State             _State;
933       typedef __future_base::_Result<_Res&>     _Res_type;
934       typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
935       template<typename, typename> friend class _State::_Setter;
936
937       shared_ptr<_State>                        _M_future;
938       _Ptr_type                                 _M_storage;
939
940     public:
941       promise()
942       : _M_future(std::make_shared<_State>()),
943         _M_storage(new _Res_type())
944       { }
945
946       promise(promise&& __rhs)
947       : _M_future(std::move(__rhs._M_future)), 
948         _M_storage(std::move(__rhs._M_storage))
949       { }
950
951       template<typename _Allocator>
952         promise(allocator_arg_t, const _Allocator& __a)
953         : _M_future(std::allocate_shared<_State>(__a)),
954           _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
955         { }
956
957       promise(const promise&) = delete;
958
959       ~promise()
960       {
961         if (static_cast<bool>(_M_future) && !_M_future.unique())
962           _M_future->_M_break_promise(std::move(_M_storage));
963       }
964
965       // Assignment
966       promise&
967       operator=(promise&& __rhs)
968       {
969         promise(std::move(__rhs)).swap(*this);
970         return *this;
971       }
972
973       promise& operator=(const promise&) = delete;
974
975       void
976       swap(promise& __rhs)
977       {
978         _M_future.swap(__rhs._M_future);
979         _M_storage.swap(__rhs._M_storage);
980       }
981
982       // Retrieving the result
983       future<_Res&>
984       get_future()
985       { return future<_Res&>(_M_future); }
986
987       // Setting the result
988       void
989       set_value(_Res& __r)
990       {
991         auto __setter = _State::__setter(this, __r);
992         _M_future->_M_set_result(std::move(__setter));
993       }
994
995       void
996       set_exception(exception_ptr __p)
997       {
998         auto __setter = _State::__setter(__p, this);
999         _M_future->_M_set_result(std::move(__setter));
1000       }
1001     };
1002
1003   /// Explicit specialization for promise<void>
1004   template<>
1005     class promise<void>
1006     {
1007       typedef __future_base::_State             _State;
1008       typedef __future_base::_Result<void>      _Res_type;
1009       typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
1010       template<typename, typename> friend class _State::_Setter;
1011
1012       shared_ptr<_State>                        _M_future;
1013       _Ptr_type                                 _M_storage;
1014
1015     public:
1016       promise()
1017       : _M_future(std::make_shared<_State>()),
1018         _M_storage(new _Res_type())
1019       { }
1020
1021       promise(promise&& __rhs)
1022       : _M_future(std::move(__rhs._M_future)),
1023         _M_storage(std::move(__rhs._M_storage))
1024       { }
1025
1026       template<typename _Allocator>
1027         promise(allocator_arg_t, const _Allocator& __a)
1028         : _M_future(std::allocate_shared<_State>(__a)),
1029           _M_storage(__future_base::_S_allocate_result<void>(__a))
1030         { }
1031
1032       promise(const promise&) = delete;
1033
1034       ~promise()
1035       {
1036         if (static_cast<bool>(_M_future) && !_M_future.unique())
1037           _M_future->_M_break_promise(std::move(_M_storage));
1038       }
1039
1040       // Assignment
1041       promise&
1042       operator=(promise&& __rhs)
1043       {
1044         promise(std::move(__rhs)).swap(*this);
1045         return *this;
1046       }
1047
1048       promise& operator=(const promise&) = delete;
1049
1050       void
1051       swap(promise& __rhs)
1052       {
1053         _M_future.swap(__rhs._M_future);
1054         _M_storage.swap(__rhs._M_storage);
1055       }
1056
1057       // Retrieving the result
1058       future<void>
1059       get_future()
1060       { return future<void>(_M_future); }
1061
1062       // Setting the result
1063       void set_value();
1064
1065       void
1066       set_exception(exception_ptr __p)
1067       {
1068         auto __setter = _State::__setter(__p, this);
1069         _M_future->_M_set_result(std::move(__setter));
1070       }
1071     };
1072
1073   // set void
1074   template<>
1075     struct __future_base::_State::_Setter<void, void>
1076     {
1077       promise<void>::_Ptr_type operator()()
1078       {
1079         _State::_S_check(_M_promise->_M_future);
1080         return std::move(_M_promise->_M_storage);
1081       }
1082
1083       promise<void>*    _M_promise;
1084     };
1085
1086   inline __future_base::_State::_Setter<void, void>
1087   __future_base::_State::__setter(promise<void>* __prom)
1088   {
1089     return _Setter<void, void>{ __prom };
1090   }
1091
1092   inline void
1093   promise<void>::set_value()
1094   {
1095     auto __setter = _State::__setter(this);
1096     _M_future->_M_set_result(std::move(__setter));
1097   }
1098
1099
1100   template<typename _StateT, typename _Res>
1101     struct __future_base::_Task_setter
1102     {
1103       typename _StateT::_Ptr_type operator()()
1104       {
1105         __try
1106           {
1107             _M_state->_M_result->_M_set(_M_fn());
1108           }
1109         __catch(...)
1110           {
1111             _M_state->_M_result->_M_error = current_exception();
1112           }
1113         return std::move(_M_state->_M_result);
1114       }
1115       _StateT*                  _M_state;
1116       std::function<_Res()>     _M_fn;
1117     };
1118
1119   template<typename _StateT>
1120     struct __future_base::_Task_setter<_StateT, void>
1121     {
1122       typename _StateT::_Ptr_type operator()()
1123       {
1124         __try
1125           {
1126             _M_fn();
1127           }
1128         __catch(...)
1129           {
1130             _M_state->_M_result->_M_error = current_exception();
1131           }
1132         return std::move(_M_state->_M_result);
1133       }
1134       _StateT*                  _M_state;
1135       std::function<void()>     _M_fn;
1136     };
1137
1138   template<typename _Res, typename... _Args>
1139     struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State
1140     {
1141       typedef _Res _Res_type;
1142
1143       _Task_state(std::function<_Res(_Args...)> __task)
1144       : _M_result(new _Result<_Res>()), _M_task(std::move(__task))
1145       { }
1146
1147       template<typename _Func, typename _Alloc>
1148         _Task_state(_Func&& __task, const _Alloc& __a)
1149         : _M_result(_S_allocate_result<_Res>(__a)),
1150           _M_task(allocator_arg, __a, std::move(__task))
1151         { }
1152
1153       void
1154       _M_run(_Args... __args)
1155       {
1156         // bound arguments decay so wrap lvalue references
1157         auto __bound = std::bind<_Res>(std::ref(_M_task),
1158             _S_maybe_wrap_ref(std::forward<_Args>(__args))...);
1159         _Task_setter<_Task_state> __setter{ this, std::move(__bound) };
1160         _M_set_result(std::move(__setter));
1161       }
1162
1163       template<typename, typename> friend class _Task_setter;
1164       typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1165       _Ptr_type _M_result;
1166       std::function<_Res(_Args...)> _M_task;
1167
1168       template<typename _Tp>
1169         static reference_wrapper<_Tp>
1170         _S_maybe_wrap_ref(_Tp& __t)
1171         { return std::ref(__t); }
1172
1173       template<typename _Tp>
1174         static typename enable_if<!is_lvalue_reference<_Tp>::value,
1175                         _Tp>::type&&
1176         _S_maybe_wrap_ref(_Tp&& __t)
1177         { return std::forward<_Tp>(__t); }
1178     };
1179
1180   /// packaged_task
1181   template<typename _Res, typename... _ArgTypes>
1182     class packaged_task<_Res(_ArgTypes...)>
1183     {
1184       typedef __future_base::_Task_state<_Res(_ArgTypes...)>  _State_type;
1185       shared_ptr<_State_type>                   _M_state;
1186
1187     public:
1188       typedef _Res result_type;
1189
1190       // Construction and destruction
1191       packaged_task() { }
1192
1193       template<typename _Fn>
1194         explicit
1195         packaged_task(const _Fn& __fn)
1196         : _M_state(std::make_shared<_State_type>(__fn))
1197         { }
1198
1199       template<typename _Fn>
1200         explicit
1201         packaged_task(_Fn&& __fn)
1202         : _M_state(std::make_shared<_State_type>(std::move(__fn)))
1203         { }
1204
1205       explicit
1206       packaged_task(_Res(*__fn)(_ArgTypes...))
1207       : _M_state(std::make_shared<_State_type>(__fn))
1208       { }
1209
1210       template<typename _Fn, typename _Allocator>
1211         explicit
1212         packaged_task(allocator_arg_t __tag, const _Allocator& __a, _Fn __fn)
1213         : _M_state(std::allocate_shared<_State_type>(__a, std::move(__fn)))
1214         { }
1215
1216       ~packaged_task()
1217       {
1218         if (static_cast<bool>(_M_state) && !_M_state.unique())
1219           _M_state->_M_break_promise(std::move(_M_state->_M_result));
1220       }
1221
1222       // No copy
1223       packaged_task(packaged_task&) = delete;
1224       packaged_task& operator=(packaged_task&) = delete;
1225
1226       // Move support
1227       packaged_task(packaged_task&& __other)
1228       { this->swap(__other); }
1229
1230       packaged_task& operator=(packaged_task&& __other)
1231       {
1232         packaged_task(std::move(__other)).swap(*this);
1233         return *this;
1234       }
1235
1236       void
1237       swap(packaged_task& __other)
1238       { _M_state.swap(__other._M_state); }
1239
1240       explicit operator bool() const { return static_cast<bool>(_M_state); }
1241
1242       // Result retrieval
1243       future<_Res>
1244       get_future()
1245       { return future<_Res>(_M_state); }
1246
1247       // Execution
1248       void
1249       operator()(_ArgTypes... __args)
1250       {
1251         __future_base::_State::_S_check(_M_state);
1252         _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
1253       }
1254
1255       void
1256       reset()
1257       {
1258         __future_base::_State::_S_check(_M_state);
1259         packaged_task(std::move(_M_state->_M_task)).swap(*this);
1260       }
1261     };
1262
1263   /// swap
1264   template<typename _Res, typename... _ArgTypes>
1265     inline void
1266     swap(packaged_task<_Res(_ArgTypes...)>& __x,
1267          packaged_task<_Res(_ArgTypes...)>& __y)
1268     { __x.swap(__y); }
1269
1270   template<typename _Res, typename _Alloc>
1271     struct uses_allocator<packaged_task<_Res>, _Alloc>
1272     : public true_type { };
1273
1274
1275   template<typename _Res>
1276     class __future_base::_Deferred_state : public __future_base::_State
1277     {
1278     public:
1279       typedef _Res _Res_type;
1280
1281       explicit
1282       _Deferred_state(std::function<_Res()>&& __fn)
1283       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1284       { }
1285
1286     private:
1287       template<typename, typename> friend class _Task_setter;
1288       typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1289       _Ptr_type _M_result;
1290       std::function<_Res()> _M_fn;
1291
1292       virtual void
1293       _M_run_deferred()
1294       {
1295         _Task_setter<_Deferred_state> __setter{ this, _M_fn };
1296         // safe to call multiple times so ignore failure
1297         _M_set_result(std::move(__setter), true);
1298       }
1299     };
1300
1301   template<typename _Res>
1302     class __future_base::_Async_state : public __future_base::_State
1303     {
1304     public:
1305       typedef _Res _Res_type;
1306
1307       explicit 
1308       _Async_state(std::function<_Res()>&& __fn)
1309       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)),
1310         _M_thread(mem_fn(&_Async_state::_M_do_run), this)
1311       { }
1312
1313       ~_Async_state() { _M_thread.join(); }
1314
1315     private:
1316       void _M_do_run()
1317       {
1318         _Task_setter<_Async_state> __setter{ this, std::move(_M_fn) };
1319         _M_set_result(std::move(__setter));
1320       }
1321
1322       template<typename, typename> friend class _Task_setter;
1323       typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1324       _Ptr_type _M_result;
1325       std::function<_Res()> _M_fn;
1326       thread _M_thread;
1327     };
1328
1329   /// async 
1330   template<typename _Fn, typename... _Args>
1331     future<typename result_of<_Fn(_Args...)>::type>
1332     async(launch __policy, _Fn&& __fn, _Args&&... __args)
1333     {
1334       typedef typename result_of<_Fn(_Args...)>::type result_type;
1335       std::shared_ptr<__future_base::_State> __state;
1336       if (__policy == launch::async)
1337         {
1338           typedef typename __future_base::_Async_state<result_type> _State;
1339           __state = std::make_shared<_State>(std::bind<result_type>(
1340               std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1341         }
1342       else
1343         {
1344           typedef typename __future_base::_Deferred_state<result_type> _State;
1345           __state = std::make_shared<_State>(std::bind<result_type>(
1346               std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1347         }
1348       return future<result_type>(__state);
1349     }
1350
1351   /// async, potential overload
1352   template<typename _Fn, typename... _Args>
1353     inline typename
1354     enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
1355               future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
1356              >::type
1357     async(_Fn&& __fn, _Args&&... __args)
1358     {
1359       return async(launch::any, std::forward<_Fn>(__fn),
1360                    std::forward<_Args>(__args)...);
1361     }
1362
1363 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
1364        // && _GLIBCXX_ATOMIC_BUILTINS_4
1365
1366   // @} group futures
1367 _GLIBCXX_END_NAMESPACE
1368
1369 #endif // __GXX_EXPERIMENTAL_CXX0X__
1370
1371 #endif // _GLIBCXX_FUTURE