blob: f41ea2902055d5d2024ad9b20022ea515ac909b1 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001// -*- C++ -*-
2//===--------------------------- thread -----------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00005//
Howard Hinnantb64f8b02010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_THREAD
12#define _LIBCPP_THREAD
13
14/*
15
16 thread synopsis
17
Howard Hinnanta785e4e2010-08-21 21:01:59 +000018#define __STDCPP_THREADS__ __cplusplus
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000019
20namespace std
21{
22
23class thread
24{
25public:
26 class id;
27 typedef pthread_t native_handle_type;
28
Howard Hinnant6e1d8512012-07-21 16:50:47 +000029 thread() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000030 template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
31 ~thread();
32
33 thread(const thread&) = delete;
Howard Hinnant6e1d8512012-07-21 16:50:47 +000034 thread(thread&& t) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000035
36 thread& operator=(const thread&) = delete;
Howard Hinnant6e1d8512012-07-21 16:50:47 +000037 thread& operator=(thread&& t) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000038
Howard Hinnant6e1d8512012-07-21 16:50:47 +000039 void swap(thread& t) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000040
Howard Hinnant6e1d8512012-07-21 16:50:47 +000041 bool joinable() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000042 void join();
43 void detach();
Howard Hinnant6e1d8512012-07-21 16:50:47 +000044 id get_id() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000045 native_handle_type native_handle();
46
Howard Hinnant6e1d8512012-07-21 16:50:47 +000047 static unsigned hardware_concurrency() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000048};
49
Howard Hinnant6e1d8512012-07-21 16:50:47 +000050void swap(thread& x, thread& y) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000051
52class thread::id
53{
54public:
Howard Hinnant6e1d8512012-07-21 16:50:47 +000055 id() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000056};
57
Howard Hinnant6e1d8512012-07-21 16:50:47 +000058bool operator==(thread::id x, thread::id y) noexcept;
59bool operator!=(thread::id x, thread::id y) noexcept;
60bool operator< (thread::id x, thread::id y) noexcept;
61bool operator<=(thread::id x, thread::id y) noexcept;
62bool operator> (thread::id x, thread::id y) noexcept;
63bool operator>=(thread::id x, thread::id y) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000064
65template<class charT, class traits>
66basic_ostream<charT, traits>&
67operator<<(basic_ostream<charT, traits>& out, thread::id id);
68
69namespace this_thread
70{
71
Howard Hinnant6e1d8512012-07-21 16:50:47 +000072thread::id get_id() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000073
Howard Hinnant6e1d8512012-07-21 16:50:47 +000074void yield() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000075
76template <class Clock, class Duration>
77void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
78
79template <class Rep, class Period>
80void sleep_for(const chrono::duration<Rep, Period>& rel_time);
81
82} // this_thread
83
84} // std
85
86*/
87
88#include <__config>
89#include <iosfwd>
90#include <__functional_base>
91#include <type_traits>
92#include <cstddef>
93#include <functional>
94#include <memory>
95#include <system_error>
96#include <chrono>
97#include <__mutex_base>
Howard Hinnant656bdc32011-05-16 18:40:35 +000098#ifndef _LIBCPP_HAS_NO_VARIADICS
99#include <tuple>
100#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000101#include <pthread.h>
102
Howard Hinnant08e17472011-10-17 20:05:10 +0000103#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000104#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000105#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000106
Howard Hinnanta785e4e2010-08-21 21:01:59 +0000107#define __STDCPP_THREADS__ __cplusplus
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000108
109_LIBCPP_BEGIN_NAMESPACE_STD
110
Howard Hinnant47499b12010-08-27 20:10:19 +0000111template <class _Tp>
112class __thread_specific_ptr
113{
114 pthread_key_t __key_;
115
116 __thread_specific_ptr(const __thread_specific_ptr&);
117 __thread_specific_ptr& operator=(const __thread_specific_ptr&);
118
119 static void __at_thread_exit(void*);
120public:
121 typedef _Tp* pointer;
122
123 __thread_specific_ptr();
124 ~__thread_specific_ptr();
125
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000126 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000127 pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000128 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000129 pointer operator*() const {return *get();}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000130 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000131 pointer operator->() const {return get();}
132 pointer release();
133 void reset(pointer __p = nullptr);
134};
135
136template <class _Tp>
137void
138__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
139{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000140 delete static_cast<pointer>(__p);
Howard Hinnant47499b12010-08-27 20:10:19 +0000141}
142
143template <class _Tp>
144__thread_specific_ptr<_Tp>::__thread_specific_ptr()
145{
146 int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
Howard Hinnant2c0d3ed2013-03-28 15:00:04 +0000147#ifndef _LIBCPP_NO_EXCEPTIONS
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000148 if (__ec)
149 throw system_error(error_code(__ec, system_category()),
150 "__thread_specific_ptr construction failed");
Howard Hinnant2c0d3ed2013-03-28 15:00:04 +0000151#endif
Howard Hinnant47499b12010-08-27 20:10:19 +0000152}
153
154template <class _Tp>
155__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
156{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000157 pthread_key_delete(__key_);
Howard Hinnant47499b12010-08-27 20:10:19 +0000158}
159
160template <class _Tp>
161typename __thread_specific_ptr<_Tp>::pointer
162__thread_specific_ptr<_Tp>::release()
163{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000164 pointer __p = get();
165 pthread_setspecific(__key_, 0);
166 return __p;
Howard Hinnant47499b12010-08-27 20:10:19 +0000167}
168
169template <class _Tp>
170void
171__thread_specific_ptr<_Tp>::reset(pointer __p)
172{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000173 pointer __p_old = get();
174 pthread_setspecific(__key_, __p);
175 delete __p_old;
Howard Hinnant47499b12010-08-27 20:10:19 +0000176}
177
Howard Hinnant83eade62013-03-06 23:30:19 +0000178class _LIBCPP_TYPE_VIS thread;
179class _LIBCPP_TYPE_VIS __thread_id;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000180
181namespace this_thread
182{
183
Howard Hinnant33be35e2012-09-14 00:39:16 +0000184_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000185
186} // this_thread
187
Howard Hinnant83eade62013-03-06 23:30:19 +0000188class _LIBCPP_TYPE_VIS __thread_id;
189template<> struct _LIBCPP_TYPE_VIS hash<__thread_id>;
Howard Hinnant40c13d32011-12-05 00:08:45 +0000190
Howard Hinnant83eade62013-03-06 23:30:19 +0000191class _LIBCPP_TYPE_VIS __thread_id
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000192{
Howard Hinnantadff4892010-05-24 17:49:41 +0000193 // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
194 // NULL is the no-thread value on Darwin. Someone needs to check
195 // on other platforms. We assume 0 works everywhere for now.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000196 pthread_t __id_;
197
198public:
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000199 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000200 __thread_id() _NOEXCEPT : __id_(0) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000201
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000202 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000203 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000204 {return __x.__id_ == __y.__id_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000205 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000206 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000207 {return !(__x == __y);}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000208 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000209 bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000210 {return __x.__id_ < __y.__id_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000211 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000212 bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000213 {return !(__y < __x);}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000214 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000215 bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000216 {return __y < __x ;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000217 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000218 bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000219 {return !(__x < __y);}
220
221 template<class _CharT, class _Traits>
222 friend
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000223 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000224 basic_ostream<_CharT, _Traits>&
225 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
226 {return __os << __id.__id_;}
227
228private:
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000229 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000230 __thread_id(pthread_t __id) : __id_(__id) {}
231
Howard Hinnant96c60b42012-08-19 15:13:16 +0000232 friend __thread_id this_thread::get_id() _NOEXCEPT;
Howard Hinnant83eade62013-03-06 23:30:19 +0000233 friend class _LIBCPP_TYPE_VIS thread;
234 friend struct _LIBCPP_TYPE_VIS hash<__thread_id>;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000235};
236
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000237template<>
Howard Hinnant83eade62013-03-06 23:30:19 +0000238struct _LIBCPP_TYPE_VIS hash<__thread_id>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000239 : public unary_function<__thread_id, size_t>
240{
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000241 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000242 size_t operator()(__thread_id __v) const
243 {
Howard Hinnant40c13d32011-12-05 00:08:45 +0000244 return hash<pthread_t>()(__v.__id_);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000245 }
246};
247
248namespace this_thread
249{
250
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000251inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000252__thread_id
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000253get_id() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000254{
255 return pthread_self();
256}
257
258} // this_thread
259
Howard Hinnant83eade62013-03-06 23:30:19 +0000260class _LIBCPP_TYPE_VIS thread
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000261{
262 pthread_t __t_;
263
Howard Hinnant60a0a8e2010-08-10 20:48:29 +0000264 thread(const thread&);
265 thread& operator=(const thread&);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000266public:
267 typedef __thread_id id;
268 typedef pthread_t native_handle_type;
269
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000270 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000271 thread() _NOEXCEPT : __t_(0) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000272#ifndef _LIBCPP_HAS_NO_VARIADICS
Howard Hinnant99968442011-11-29 18:15:50 +0000273 template <class _Fp, class ..._Args,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000274 class = typename enable_if
275 <
Howard Hinnant99968442011-11-29 18:15:50 +0000276 !is_same<typename decay<_Fp>::type, thread>::value
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000277 >::type
278 >
Howard Hinnant99968442011-11-29 18:15:50 +0000279 explicit thread(_Fp&& __f, _Args&&... __args);
Howard Hinnant324bb032010-08-22 00:02:43 +0000280#else // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnant99968442011-11-29 18:15:50 +0000281 template <class _Fp> explicit thread(_Fp __f);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000282#endif
283 ~thread();
284
Howard Hinnant73d21a42010-09-04 23:28:19 +0000285#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000286 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000287 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
288 thread& operator=(thread&& __t) _NOEXCEPT;
Howard Hinnant73d21a42010-09-04 23:28:19 +0000289#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000290
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000291 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000292 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000293
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000294 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000295 bool joinable() const _NOEXCEPT {return __t_ != 0;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000296 void join();
297 void detach();
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000298 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000299 id get_id() const _NOEXCEPT {return __t_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000300 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000301 native_handle_type native_handle() _NOEXCEPT {return __t_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000302
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000303 static unsigned hardware_concurrency() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000304};
305
Howard Hinnant47499b12010-08-27 20:10:19 +0000306class __assoc_sub_state;
307
Howard Hinnant2d72b1e2010-12-17 14:46:43 +0000308class _LIBCPP_HIDDEN __thread_struct_imp;
Howard Hinnant47499b12010-08-27 20:10:19 +0000309
310class __thread_struct
311{
312 __thread_struct_imp* __p_;
313
314 __thread_struct(const __thread_struct&);
315 __thread_struct& operator=(const __thread_struct&);
316public:
317 __thread_struct();
318 ~__thread_struct();
319
Howard Hinnante6e4d012010-09-03 21:46:37 +0000320 void notify_all_at_thread_exit(condition_variable*, mutex*);
Howard Hinnant47499b12010-08-27 20:10:19 +0000321 void __make_ready_at_thread_exit(__assoc_sub_state*);
322};
323
Howard Hinnant5306d682010-10-14 19:18:04 +0000324__thread_specific_ptr<__thread_struct>& __thread_local_data();
Howard Hinnant47499b12010-08-27 20:10:19 +0000325
Howard Hinnant656bdc32011-05-16 18:40:35 +0000326#ifndef _LIBCPP_HAS_NO_VARIADICS
327
Howard Hinnant99968442011-11-29 18:15:50 +0000328template <class _Fp, class ..._Args, size_t ..._Indices>
Howard Hinnant656bdc32011-05-16 18:40:35 +0000329inline _LIBCPP_INLINE_VISIBILITY
330void
Howard Hinnantc5e89612013-04-03 20:29:45 +0000331__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
Howard Hinnant656bdc32011-05-16 18:40:35 +0000332{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000333 __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
Howard Hinnant656bdc32011-05-16 18:40:35 +0000334}
335
Howard Hinnant99968442011-11-29 18:15:50 +0000336template <class _Fp>
Howard Hinnant656bdc32011-05-16 18:40:35 +0000337void*
338__thread_proxy(void* __vp)
339{
340 __thread_local_data().reset(new __thread_struct);
Howard Hinnant99968442011-11-29 18:15:50 +0000341 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
342 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
Howard Hinnantc5e89612013-04-03 20:29:45 +0000343 __thread_execute(*__p, _Index());
Howard Hinnant656bdc32011-05-16 18:40:35 +0000344 return nullptr;
345}
346
Howard Hinnant99968442011-11-29 18:15:50 +0000347template <class _Fp, class ..._Args,
Howard Hinnant656bdc32011-05-16 18:40:35 +0000348 class
349 >
Howard Hinnant99968442011-11-29 18:15:50 +0000350thread::thread(_Fp&& __f, _Args&&... __args)
Howard Hinnant656bdc32011-05-16 18:40:35 +0000351{
Howard Hinnant99968442011-11-29 18:15:50 +0000352 typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
353 _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
Howard Hinnant0949eed2011-06-30 21:18:19 +0000354 __decay_copy(_VSTD::forward<_Args>(__args))...));
Howard Hinnant99968442011-11-29 18:15:50 +0000355 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
Howard Hinnant656bdc32011-05-16 18:40:35 +0000356 if (__ec == 0)
357 __p.release();
358 else
359 __throw_system_error(__ec, "thread constructor failed");
360}
361
362#else // _LIBCPP_HAS_NO_VARIADICS
363
Howard Hinnant99968442011-11-29 18:15:50 +0000364template <class _Fp>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000365void*
366__thread_proxy(void* __vp)
367{
Howard Hinnant5306d682010-10-14 19:18:04 +0000368 __thread_local_data().reset(new __thread_struct);
Howard Hinnant99968442011-11-29 18:15:50 +0000369 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000370 (*__p)();
371 return nullptr;
372}
373
Howard Hinnant99968442011-11-29 18:15:50 +0000374template <class _Fp>
375thread::thread(_Fp __f)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000376{
Howard Hinnant99968442011-11-29 18:15:50 +0000377 std::unique_ptr<_Fp> __p(new _Fp(__f));
378 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000379 if (__ec == 0)
380 __p.release();
381 else
382 __throw_system_error(__ec, "thread constructor failed");
383}
384
Howard Hinnant324bb032010-08-22 00:02:43 +0000385#endif // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000386
Howard Hinnant73d21a42010-09-04 23:28:19 +0000387#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000388
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000389inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000390thread&
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000391thread::operator=(thread&& __t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000392{
Howard Hinnanta6a062d2010-06-02 18:20:39 +0000393 if (__t_ != 0)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000394 terminate();
395 __t_ = __t.__t_;
Howard Hinnanta6a062d2010-06-02 18:20:39 +0000396 __t.__t_ = 0;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000397 return *this;
398}
399
Howard Hinnant73d21a42010-09-04 23:28:19 +0000400#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000401
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000402inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000403void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000404
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000405namespace this_thread
406{
407
408void sleep_for(const chrono::nanoseconds& ns);
409
410template <class _Rep, class _Period>
411void
412sleep_for(const chrono::duration<_Rep, _Period>& __d)
413{
414 using namespace chrono;
Howard Hinnantcf115d22012-08-30 19:14:33 +0000415 if (__d > duration<_Rep, _Period>::zero())
416 {
417 _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
418 nanoseconds __ns;
419 if (__d < _Max)
420 {
421 __ns = duration_cast<nanoseconds>(__d);
422 if (__ns < __d)
423 ++__ns;
424 }
425 else
426 __ns = nanoseconds::max();
427 sleep_for(__ns);
428 }
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000429}
430
431template <class _Clock, class _Duration>
432void
433sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
434{
435 using namespace chrono;
436 mutex __mut;
437 condition_variable __cv;
438 unique_lock<mutex> __lk(__mut);
439 while (_Clock::now() < __t)
440 __cv.wait_until(__lk, __t);
441}
442
443template <class _Duration>
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000444inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000445void
Howard Hinnantf8f85212010-11-20 19:16:30 +0000446sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000447{
448 using namespace chrono;
Howard Hinnantf8f85212010-11-20 19:16:30 +0000449 sleep_for(__t - steady_clock::now());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000450}
451
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000452inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000453void yield() _NOEXCEPT {sched_yield();}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000454
455} // this_thread
456
457_LIBCPP_END_NAMESPACE_STD
458
459#endif // _LIBCPP_THREAD