2 //===--------------------------- thread -----------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_THREAD
12 #define _LIBCPP_THREAD
18 #define __STDCPP_THREADS__ __cplusplus
27 typedef pthread_t native_handle_type;
30 template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
33 thread(const thread&) = delete;
34 thread(thread&& t) noexcept;
36 thread& operator=(const thread&) = delete;
37 thread& operator=(thread&& t) noexcept;
39 void swap(thread& t) noexcept;
41 bool joinable() const noexcept;
44 id get_id() const noexcept;
45 native_handle_type native_handle();
47 static unsigned hardware_concurrency() noexcept;
50 void swap(thread& x, thread& y) noexcept;
58 bool operator==(thread::id x, thread::id y) noexcept;
59 bool operator!=(thread::id x, thread::id y) noexcept;
60 bool operator< (thread::id x, thread::id y) noexcept;
61 bool operator<=(thread::id x, thread::id y) noexcept;
62 bool operator> (thread::id x, thread::id y) noexcept;
63 bool operator>=(thread::id x, thread::id y) noexcept;
65 template<class charT, class traits>
66 basic_ostream<charT, traits>&
67 operator<<(basic_ostream<charT, traits>& out, thread::id id);
72 thread::id get_id() noexcept;
74 void yield() noexcept;
76 template <class Clock, class Duration>
77 void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
79 template <class Rep, class Period>
80 void sleep_for(const chrono::duration<Rep, Period>& rel_time);
90 #include <__functional_base>
91 #include <type_traits>
95 #include <system_error>
97 #include <__mutex_base>
98 #ifndef _LIBCPP_HAS_NO_VARIADICS
104 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
105 #pragma GCC system_header
108 #define __STDCPP_THREADS__ __cplusplus
110 #ifdef _LIBCPP_HAS_NO_THREADS
111 #error <thread> is not supported on this single threaded system
112 #else // !_LIBCPP_HAS_NO_THREADS
114 _LIBCPP_BEGIN_NAMESPACE_STD
117 class __thread_specific_ptr
119 pthread_key_t __key_;
121 __thread_specific_ptr(const __thread_specific_ptr&);
122 __thread_specific_ptr& operator=(const __thread_specific_ptr&);
124 static void __at_thread_exit(void*);
126 typedef _Tp* pointer;
128 __thread_specific_ptr();
129 ~__thread_specific_ptr();
131 _LIBCPP_INLINE_VISIBILITY
132 pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
133 _LIBCPP_INLINE_VISIBILITY
134 pointer operator*() const {return *get();}
135 _LIBCPP_INLINE_VISIBILITY
136 pointer operator->() const {return get();}
138 void reset(pointer __p = nullptr);
143 __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
145 delete static_cast<pointer>(__p);
149 __thread_specific_ptr<_Tp>::__thread_specific_ptr()
151 int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
152 #ifndef _LIBCPP_NO_EXCEPTIONS
154 throw system_error(error_code(__ec, system_category()),
155 "__thread_specific_ptr construction failed");
160 __thread_specific_ptr<_Tp>::~__thread_specific_ptr()
162 pthread_key_delete(__key_);
166 typename __thread_specific_ptr<_Tp>::pointer
167 __thread_specific_ptr<_Tp>::release()
170 pthread_setspecific(__key_, 0);
176 __thread_specific_ptr<_Tp>::reset(pointer __p)
178 pointer __p_old = get();
179 pthread_setspecific(__key_, __p);
183 class _LIBCPP_TYPE_VIS thread;
184 class _LIBCPP_TYPE_VIS __thread_id;
186 namespace this_thread
189 _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
193 template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
195 class _LIBCPP_TYPE_VIS_ONLY __thread_id
197 // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
198 // NULL is the no-thread value on Darwin. Someone needs to check
199 // on other platforms. We assume 0 works everywhere for now.
203 _LIBCPP_INLINE_VISIBILITY
204 __thread_id() _NOEXCEPT : __id_(0) {}
206 friend _LIBCPP_INLINE_VISIBILITY
207 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
208 {return __x.__id_ == __y.__id_;}
209 friend _LIBCPP_INLINE_VISIBILITY
210 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
211 {return !(__x == __y);}
212 friend _LIBCPP_INLINE_VISIBILITY
213 bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
214 {return __x.__id_ < __y.__id_;}
215 friend _LIBCPP_INLINE_VISIBILITY
216 bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
217 {return !(__y < __x);}
218 friend _LIBCPP_INLINE_VISIBILITY
219 bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
221 friend _LIBCPP_INLINE_VISIBILITY
222 bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
223 {return !(__x < __y);}
225 template<class _CharT, class _Traits>
227 _LIBCPP_INLINE_VISIBILITY
228 basic_ostream<_CharT, _Traits>&
229 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
230 {return __os << __id.__id_;}
233 _LIBCPP_INLINE_VISIBILITY
234 __thread_id(pthread_t __id) : __id_(__id) {}
236 friend __thread_id this_thread::get_id() _NOEXCEPT;
237 friend class _LIBCPP_TYPE_VIS thread;
238 friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
242 struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
243 : public unary_function<__thread_id, size_t>
245 _LIBCPP_INLINE_VISIBILITY
246 size_t operator()(__thread_id __v) const
248 return hash<pthread_t>()(__v.__id_);
252 namespace this_thread
255 inline _LIBCPP_INLINE_VISIBILITY
259 return pthread_self();
264 class _LIBCPP_TYPE_VIS thread
268 thread(const thread&);
269 thread& operator=(const thread&);
271 typedef __thread_id id;
272 typedef pthread_t native_handle_type;
274 _LIBCPP_INLINE_VISIBILITY
275 thread() _NOEXCEPT : __t_(0) {}
276 #ifndef _LIBCPP_HAS_NO_VARIADICS
277 template <class _Fp, class ..._Args,
278 class = typename enable_if
280 !is_same<typename decay<_Fp>::type, thread>::value
283 explicit thread(_Fp&& __f, _Args&&... __args);
284 #else // _LIBCPP_HAS_NO_VARIADICS
285 template <class _Fp> explicit thread(_Fp __f);
289 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
290 _LIBCPP_INLINE_VISIBILITY
291 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
292 thread& operator=(thread&& __t) _NOEXCEPT;
293 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
295 _LIBCPP_INLINE_VISIBILITY
296 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
298 _LIBCPP_INLINE_VISIBILITY
299 bool joinable() const _NOEXCEPT {return __t_ != 0;}
302 _LIBCPP_INLINE_VISIBILITY
303 id get_id() const _NOEXCEPT {return __t_;}
304 _LIBCPP_INLINE_VISIBILITY
305 native_handle_type native_handle() _NOEXCEPT {return __t_;}
307 static unsigned hardware_concurrency() _NOEXCEPT;
310 class __assoc_sub_state;
312 class _LIBCPP_HIDDEN __thread_struct_imp;
314 class _LIBCPP_TYPE_VIS __thread_struct
316 __thread_struct_imp* __p_;
318 __thread_struct(const __thread_struct&);
319 __thread_struct& operator=(const __thread_struct&);
324 void notify_all_at_thread_exit(condition_variable*, mutex*);
325 void __make_ready_at_thread_exit(__assoc_sub_state*);
328 _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
330 #ifndef _LIBCPP_HAS_NO_VARIADICS
332 template <class _Fp, class ..._Args, size_t ..._Indices>
333 inline _LIBCPP_INLINE_VISIBILITY
335 __thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
337 __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
342 __thread_proxy(void* __vp)
344 __thread_local_data().reset(new __thread_struct);
345 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
346 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
347 __thread_execute(*__p, _Index());
351 template <class _Fp, class ..._Args,
354 thread::thread(_Fp&& __f, _Args&&... __args)
356 typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
357 _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
358 __decay_copy(_VSTD::forward<_Args>(__args))...));
359 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
363 __throw_system_error(__ec, "thread constructor failed");
366 #else // _LIBCPP_HAS_NO_VARIADICS
370 __thread_proxy(void* __vp)
372 __thread_local_data().reset(new __thread_struct);
373 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
379 thread::thread(_Fp __f)
381 std::unique_ptr<_Fp> __p(new _Fp(__f));
382 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
386 __throw_system_error(__ec, "thread constructor failed");
389 #endif // _LIBCPP_HAS_NO_VARIADICS
391 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
393 inline _LIBCPP_INLINE_VISIBILITY
395 thread::operator=(thread&& __t) _NOEXCEPT
404 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
406 inline _LIBCPP_INLINE_VISIBILITY
407 void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
409 namespace this_thread
412 _LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& ns);
414 template <class _Rep, class _Period>
416 sleep_for(const chrono::duration<_Rep, _Period>& __d)
418 using namespace chrono;
419 if (__d > duration<_Rep, _Period>::zero())
421 _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
425 __ns = duration_cast<nanoseconds>(__d);
430 __ns = nanoseconds::max();
435 template <class _Clock, class _Duration>
437 sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
439 using namespace chrono;
441 condition_variable __cv;
442 unique_lock<mutex> __lk(__mut);
443 while (_Clock::now() < __t)
444 __cv.wait_until(__lk, __t);
447 template <class _Duration>
448 inline _LIBCPP_INLINE_VISIBILITY
450 sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
452 using namespace chrono;
453 sleep_for(__t - steady_clock::now());
456 inline _LIBCPP_INLINE_VISIBILITY
457 void yield() _NOEXCEPT {sched_yield();}
461 _LIBCPP_END_NAMESPACE_STD
463 #endif // !_LIBCPP_HAS_NO_THREADS
465 #endif // _LIBCPP_THREAD