blob: 6857e9edb68b6bb88f0f97312cc7794ac87dc626 [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>
Sergey Dmitroukfff544e2014-12-08 14:50:21 +0000102#include <sched.h>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000103
Howard Hinnant08e17472011-10-17 20:05:10 +0000104#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000105#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000106#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000107
Howard Hinnanta785e4e2010-08-21 21:01:59 +0000108#define __STDCPP_THREADS__ __cplusplus
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000109
Jonathan Roelofs8d86b2e2014-09-05 19:45:05 +0000110#ifdef _LIBCPP_HAS_NO_THREADS
111#error <thread> is not supported on this single threaded system
112#else // !_LIBCPP_HAS_NO_THREADS
113
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000114_LIBCPP_BEGIN_NAMESPACE_STD
115
Eric Fiselier0376dfa2015-08-18 19:40:38 +0000116template <class _Tp> class __thread_specific_ptr;
117class _LIBCPP_TYPE_VIS __thread_struct;
118class _LIBCPP_HIDDEN __thread_struct_imp;
119class __assoc_sub_state;
120
121_LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
122
123class _LIBCPP_TYPE_VIS __thread_struct
124{
125 __thread_struct_imp* __p_;
126
127 __thread_struct(const __thread_struct&);
128 __thread_struct& operator=(const __thread_struct&);
129public:
130 __thread_struct();
131 ~__thread_struct();
132
133 void notify_all_at_thread_exit(condition_variable*, mutex*);
134 void __make_ready_at_thread_exit(__assoc_sub_state*);
135};
136
Howard Hinnant47499b12010-08-27 20:10:19 +0000137template <class _Tp>
138class __thread_specific_ptr
139{
140 pthread_key_t __key_;
141
Eric Fiselier0376dfa2015-08-18 19:40:38 +0000142 // Only __thread_local_data() may construct a __thread_specific_ptr
143 // and only with _Tp == __thread_struct.
Eric Fiselierf99b59c2015-08-19 03:38:41 +0000144 static_assert((is_same<_Tp, __thread_struct>::value), "");
Eric Fiselier0376dfa2015-08-18 19:40:38 +0000145 __thread_specific_ptr();
146 friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
147
Howard Hinnant47499b12010-08-27 20:10:19 +0000148 __thread_specific_ptr(const __thread_specific_ptr&);
149 __thread_specific_ptr& operator=(const __thread_specific_ptr&);
150
151 static void __at_thread_exit(void*);
152public:
153 typedef _Tp* pointer;
154
Howard Hinnant47499b12010-08-27 20:10:19 +0000155 ~__thread_specific_ptr();
156
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000157 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000158 pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000159 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000160 pointer operator*() const {return *get();}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000161 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant47499b12010-08-27 20:10:19 +0000162 pointer operator->() const {return get();}
163 pointer release();
164 void reset(pointer __p = nullptr);
165};
166
167template <class _Tp>
168void
169__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
170{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000171 delete static_cast<pointer>(__p);
Howard Hinnant47499b12010-08-27 20:10:19 +0000172}
173
174template <class _Tp>
175__thread_specific_ptr<_Tp>::__thread_specific_ptr()
176{
177 int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
Howard Hinnant2c0d3ed2013-03-28 15:00:04 +0000178#ifndef _LIBCPP_NO_EXCEPTIONS
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000179 if (__ec)
180 throw system_error(error_code(__ec, system_category()),
181 "__thread_specific_ptr construction failed");
Howard Hinnant2c0d3ed2013-03-28 15:00:04 +0000182#endif
Howard Hinnant47499b12010-08-27 20:10:19 +0000183}
184
185template <class _Tp>
186__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
187{
Eric Fiselier0376dfa2015-08-18 19:40:38 +0000188 // __thread_specific_ptr is only created with a static storage duration
189 // so this destructor is only invoked during program termination. Invoking
190 // pthread_key_delete(__key_) may prevent other threads from deleting their
191 // thread local data. For this reason we leak the key.
Howard Hinnant47499b12010-08-27 20:10:19 +0000192}
193
194template <class _Tp>
195typename __thread_specific_ptr<_Tp>::pointer
196__thread_specific_ptr<_Tp>::release()
197{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000198 pointer __p = get();
199 pthread_setspecific(__key_, 0);
200 return __p;
Howard Hinnant47499b12010-08-27 20:10:19 +0000201}
202
203template <class _Tp>
204void
205__thread_specific_ptr<_Tp>::reset(pointer __p)
206{
Howard Hinnant8db4aca2011-10-17 20:08:59 +0000207 pointer __p_old = get();
208 pthread_setspecific(__key_, __p);
209 delete __p_old;
Howard Hinnant47499b12010-08-27 20:10:19 +0000210}
211
Howard Hinnant83eade62013-03-06 23:30:19 +0000212class _LIBCPP_TYPE_VIS thread;
213class _LIBCPP_TYPE_VIS __thread_id;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000214
215namespace this_thread
216{
217
Howard Hinnant33be35e2012-09-14 00:39:16 +0000218_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000219
220} // this_thread
221
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000222template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
Howard Hinnant40c13d32011-12-05 00:08:45 +0000223
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000224class _LIBCPP_TYPE_VIS_ONLY __thread_id
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000225{
Howard Hinnantadff4892010-05-24 17:49:41 +0000226 // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
227 // NULL is the no-thread value on Darwin. Someone needs to check
228 // on other platforms. We assume 0 works everywhere for now.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000229 pthread_t __id_;
230
231public:
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000232 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000233 __thread_id() _NOEXCEPT : __id_(0) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000234
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000235 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000236 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000237 {return __x.__id_ == __y.__id_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000238 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000239 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000240 {return !(__x == __y);}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000241 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000242 bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000243 {return __x.__id_ < __y.__id_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000244 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000245 bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000246 {return !(__y < __x);}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000247 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000248 bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000249 {return __y < __x ;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000250 friend _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000251 bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000252 {return !(__x < __y);}
253
254 template<class _CharT, class _Traits>
255 friend
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000256 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000257 basic_ostream<_CharT, _Traits>&
258 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
259 {return __os << __id.__id_;}
260
261private:
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000262 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000263 __thread_id(pthread_t __id) : __id_(__id) {}
264
Howard Hinnant96c60b42012-08-19 15:13:16 +0000265 friend __thread_id this_thread::get_id() _NOEXCEPT;
Howard Hinnant83eade62013-03-06 23:30:19 +0000266 friend class _LIBCPP_TYPE_VIS thread;
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000267 friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000268};
269
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000270template<>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000271struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000272 : public unary_function<__thread_id, size_t>
273{
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000274 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000275 size_t operator()(__thread_id __v) const
276 {
Howard Hinnant40c13d32011-12-05 00:08:45 +0000277 return hash<pthread_t>()(__v.__id_);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000278 }
279};
280
281namespace this_thread
282{
283
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000284inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000285__thread_id
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000286get_id() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000287{
288 return pthread_self();
289}
290
291} // this_thread
292
Howard Hinnant83eade62013-03-06 23:30:19 +0000293class _LIBCPP_TYPE_VIS thread
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000294{
295 pthread_t __t_;
296
Howard Hinnant60a0a8e2010-08-10 20:48:29 +0000297 thread(const thread&);
298 thread& operator=(const thread&);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000299public:
300 typedef __thread_id id;
301 typedef pthread_t native_handle_type;
302
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000303 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000304 thread() _NOEXCEPT : __t_(0) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000305#ifndef _LIBCPP_HAS_NO_VARIADICS
Howard Hinnant99968442011-11-29 18:15:50 +0000306 template <class _Fp, class ..._Args,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000307 class = typename enable_if
308 <
Howard Hinnant99968442011-11-29 18:15:50 +0000309 !is_same<typename decay<_Fp>::type, thread>::value
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000310 >::type
311 >
Howard Hinnant99968442011-11-29 18:15:50 +0000312 explicit thread(_Fp&& __f, _Args&&... __args);
Howard Hinnant324bb032010-08-22 00:02:43 +0000313#else // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnant99968442011-11-29 18:15:50 +0000314 template <class _Fp> explicit thread(_Fp __f);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000315#endif
316 ~thread();
317
Howard Hinnant73d21a42010-09-04 23:28:19 +0000318#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000319 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000320 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000321 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000322 thread& operator=(thread&& __t) _NOEXCEPT;
Howard Hinnant73d21a42010-09-04 23:28:19 +0000323#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000324
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000325 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000326 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000327
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000328 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000329 bool joinable() const _NOEXCEPT {return __t_ != 0;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000330 void join();
331 void detach();
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000332 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000333 id get_id() const _NOEXCEPT {return __t_;}
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000334 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000335 native_handle_type native_handle() _NOEXCEPT {return __t_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000336
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000337 static unsigned hardware_concurrency() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000338};
339
Howard Hinnant656bdc32011-05-16 18:40:35 +0000340#ifndef _LIBCPP_HAS_NO_VARIADICS
341
Howard Hinnant99968442011-11-29 18:15:50 +0000342template <class _Fp, class ..._Args, size_t ..._Indices>
Howard Hinnant656bdc32011-05-16 18:40:35 +0000343inline _LIBCPP_INLINE_VISIBILITY
344void
Howard Hinnantc5e89612013-04-03 20:29:45 +0000345__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
Howard Hinnant656bdc32011-05-16 18:40:35 +0000346{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000347 __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
Howard Hinnant656bdc32011-05-16 18:40:35 +0000348}
349
Howard Hinnant99968442011-11-29 18:15:50 +0000350template <class _Fp>
Howard Hinnant656bdc32011-05-16 18:40:35 +0000351void*
352__thread_proxy(void* __vp)
353{
354 __thread_local_data().reset(new __thread_struct);
Howard Hinnant99968442011-11-29 18:15:50 +0000355 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
356 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
Howard Hinnantc5e89612013-04-03 20:29:45 +0000357 __thread_execute(*__p, _Index());
Howard Hinnant656bdc32011-05-16 18:40:35 +0000358 return nullptr;
359}
360
Howard Hinnant99968442011-11-29 18:15:50 +0000361template <class _Fp, class ..._Args,
Howard Hinnant656bdc32011-05-16 18:40:35 +0000362 class
363 >
Howard Hinnant99968442011-11-29 18:15:50 +0000364thread::thread(_Fp&& __f, _Args&&... __args)
Howard Hinnant656bdc32011-05-16 18:40:35 +0000365{
Howard Hinnant99968442011-11-29 18:15:50 +0000366 typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
367 _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
Howard Hinnant0949eed2011-06-30 21:18:19 +0000368 __decay_copy(_VSTD::forward<_Args>(__args))...));
Howard Hinnant99968442011-11-29 18:15:50 +0000369 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
Howard Hinnant656bdc32011-05-16 18:40:35 +0000370 if (__ec == 0)
371 __p.release();
372 else
373 __throw_system_error(__ec, "thread constructor failed");
374}
375
376#else // _LIBCPP_HAS_NO_VARIADICS
377
Howard Hinnant99968442011-11-29 18:15:50 +0000378template <class _Fp>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000379void*
380__thread_proxy(void* __vp)
381{
Howard Hinnant5306d682010-10-14 19:18:04 +0000382 __thread_local_data().reset(new __thread_struct);
Howard Hinnant99968442011-11-29 18:15:50 +0000383 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000384 (*__p)();
385 return nullptr;
386}
387
Howard Hinnant99968442011-11-29 18:15:50 +0000388template <class _Fp>
389thread::thread(_Fp __f)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000390{
Howard Hinnant99968442011-11-29 18:15:50 +0000391 std::unique_ptr<_Fp> __p(new _Fp(__f));
392 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000393 if (__ec == 0)
394 __p.release();
395 else
396 __throw_system_error(__ec, "thread constructor failed");
397}
398
Howard Hinnant324bb032010-08-22 00:02:43 +0000399#endif // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000400
Howard Hinnant73d21a42010-09-04 23:28:19 +0000401#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000402
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000403inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000404thread&
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000405thread::operator=(thread&& __t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000406{
Howard Hinnanta6a062d2010-06-02 18:20:39 +0000407 if (__t_ != 0)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000408 terminate();
409 __t_ = __t.__t_;
Howard Hinnanta6a062d2010-06-02 18:20:39 +0000410 __t.__t_ = 0;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000411 return *this;
412}
413
Howard Hinnant73d21a42010-09-04 23:28:19 +0000414#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000415
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000416inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000417void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000418
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000419namespace this_thread
420{
421
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000422_LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& ns);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000423
424template <class _Rep, class _Period>
425void
426sleep_for(const chrono::duration<_Rep, _Period>& __d)
427{
428 using namespace chrono;
Howard Hinnantcf115d22012-08-30 19:14:33 +0000429 if (__d > duration<_Rep, _Period>::zero())
430 {
431 _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
432 nanoseconds __ns;
433 if (__d < _Max)
434 {
435 __ns = duration_cast<nanoseconds>(__d);
436 if (__ns < __d)
437 ++__ns;
438 }
439 else
440 __ns = nanoseconds::max();
441 sleep_for(__ns);
442 }
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000443}
444
445template <class _Clock, class _Duration>
446void
447sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
448{
449 using namespace chrono;
450 mutex __mut;
451 condition_variable __cv;
452 unique_lock<mutex> __lk(__mut);
453 while (_Clock::now() < __t)
454 __cv.wait_until(__lk, __t);
455}
456
457template <class _Duration>
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000458inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000459void
Howard Hinnantf8f85212010-11-20 19:16:30 +0000460sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000461{
462 using namespace chrono;
Howard Hinnantf8f85212010-11-20 19:16:30 +0000463 sleep_for(__t - steady_clock::now());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000464}
465
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000466inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnant6e1d8512012-07-21 16:50:47 +0000467void yield() _NOEXCEPT {sched_yield();}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000468
469} // this_thread
470
471_LIBCPP_END_NAMESPACE_STD
472
Jonathan Roelofs8d86b2e2014-09-05 19:45:05 +0000473#endif // !_LIBCPP_HAS_NO_THREADS
474
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000475#endif // _LIBCPP_THREAD