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
103 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
104 #pragma GCC system_header
107 #define __STDCPP_THREADS__ __cplusplus
109 _LIBCPP_BEGIN_NAMESPACE_STD
112 class __thread_specific_ptr
114 pthread_key_t __key_;
116 __thread_specific_ptr(const __thread_specific_ptr&);
117 __thread_specific_ptr& operator=(const __thread_specific_ptr&);
119 static void __at_thread_exit(void*);
121 typedef _Tp* pointer;
123 __thread_specific_ptr();
124 ~__thread_specific_ptr();
126 _LIBCPP_INLINE_VISIBILITY
127 pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
128 _LIBCPP_INLINE_VISIBILITY
129 pointer operator*() const {return *get();}
130 _LIBCPP_INLINE_VISIBILITY
131 pointer operator->() const {return get();}
133 void reset(pointer __p = nullptr);
138 __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
140 delete static_cast<pointer>(__p);
144 __thread_specific_ptr<_Tp>::__thread_specific_ptr()
146 int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
147 #ifndef _LIBCPP_NO_EXCEPTIONS
149 throw system_error(error_code(__ec, system_category()),
150 "__thread_specific_ptr construction failed");
155 __thread_specific_ptr<_Tp>::~__thread_specific_ptr()
157 pthread_key_delete(__key_);
161 typename __thread_specific_ptr<_Tp>::pointer
162 __thread_specific_ptr<_Tp>::release()
165 pthread_setspecific(__key_, 0);
171 __thread_specific_ptr<_Tp>::reset(pointer __p)
173 pointer __p_old = get();
174 pthread_setspecific(__key_, __p);
178 class _LIBCPP_TYPE_VIS thread;
179 class _LIBCPP_TYPE_VIS __thread_id;
181 namespace this_thread
184 _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
188 template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
190 class _LIBCPP_TYPE_VIS_ONLY __thread_id
192 // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
193 // NULL is the no-thread value on Darwin. Someone needs to check
194 // on other platforms. We assume 0 works everywhere for now.
198 _LIBCPP_INLINE_VISIBILITY
199 __thread_id() _NOEXCEPT : __id_(0) {}
201 friend _LIBCPP_INLINE_VISIBILITY
202 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
203 {return __x.__id_ == __y.__id_;}
204 friend _LIBCPP_INLINE_VISIBILITY
205 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
206 {return !(__x == __y);}
207 friend _LIBCPP_INLINE_VISIBILITY
208 bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
209 {return __x.__id_ < __y.__id_;}
210 friend _LIBCPP_INLINE_VISIBILITY
211 bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
212 {return !(__y < __x);}
213 friend _LIBCPP_INLINE_VISIBILITY
214 bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
216 friend _LIBCPP_INLINE_VISIBILITY
217 bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
218 {return !(__x < __y);}
220 template<class _CharT, class _Traits>
222 _LIBCPP_INLINE_VISIBILITY
223 basic_ostream<_CharT, _Traits>&
224 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
225 {return __os << __id.__id_;}
228 _LIBCPP_INLINE_VISIBILITY
229 __thread_id(pthread_t __id) : __id_(__id) {}
231 friend __thread_id this_thread::get_id() _NOEXCEPT;
232 friend class _LIBCPP_TYPE_VIS thread;
233 friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
237 struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
238 : public unary_function<__thread_id, size_t>
240 _LIBCPP_INLINE_VISIBILITY
241 size_t operator()(__thread_id __v) const
243 return hash<pthread_t>()(__v.__id_);
247 namespace this_thread
250 inline _LIBCPP_INLINE_VISIBILITY
254 return pthread_self();
259 class _LIBCPP_TYPE_VIS thread
263 thread(const thread&);
264 thread& operator=(const thread&);
266 typedef __thread_id id;
267 typedef pthread_t native_handle_type;
269 _LIBCPP_INLINE_VISIBILITY
270 thread() _NOEXCEPT : __t_(0) {}
271 #ifndef _LIBCPP_HAS_NO_VARIADICS
272 template <class _Fp, class ..._Args,
273 class = typename enable_if
275 !is_same<typename decay<_Fp>::type, thread>::value
278 explicit thread(_Fp&& __f, _Args&&... __args);
279 #else // _LIBCPP_HAS_NO_VARIADICS
280 template <class _Fp> explicit thread(_Fp __f);
284 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
285 _LIBCPP_INLINE_VISIBILITY
286 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
287 thread& operator=(thread&& __t) _NOEXCEPT;
288 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
290 _LIBCPP_INLINE_VISIBILITY
291 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
293 _LIBCPP_INLINE_VISIBILITY
294 bool joinable() const _NOEXCEPT {return __t_ != 0;}
297 _LIBCPP_INLINE_VISIBILITY
298 id get_id() const _NOEXCEPT {return __t_;}
299 _LIBCPP_INLINE_VISIBILITY
300 native_handle_type native_handle() _NOEXCEPT {return __t_;}
302 static unsigned hardware_concurrency() _NOEXCEPT;
305 class __assoc_sub_state;
307 class _LIBCPP_HIDDEN __thread_struct_imp;
309 class _LIBCPP_TYPE_VIS __thread_struct
311 __thread_struct_imp* __p_;
313 __thread_struct(const __thread_struct&);
314 __thread_struct& operator=(const __thread_struct&);
319 void notify_all_at_thread_exit(condition_variable*, mutex*);
320 void __make_ready_at_thread_exit(__assoc_sub_state*);
323 _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
325 #ifndef _LIBCPP_HAS_NO_VARIADICS
327 template <class _Fp, class ..._Args, size_t ..._Indices>
328 inline _LIBCPP_INLINE_VISIBILITY
330 __thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
332 __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
337 __thread_proxy(void* __vp)
339 __thread_local_data().reset(new __thread_struct);
340 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
341 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
342 __thread_execute(*__p, _Index());
346 template <class _Fp, class ..._Args,
349 thread::thread(_Fp&& __f, _Args&&... __args)
351 typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
352 _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
353 __decay_copy(_VSTD::forward<_Args>(__args))...));
354 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
358 __throw_system_error(__ec, "thread constructor failed");
361 #else // _LIBCPP_HAS_NO_VARIADICS
365 __thread_proxy(void* __vp)
367 __thread_local_data().reset(new __thread_struct);
368 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
374 thread::thread(_Fp __f)
376 std::unique_ptr<_Fp> __p(new _Fp(__f));
377 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
381 __throw_system_error(__ec, "thread constructor failed");
384 #endif // _LIBCPP_HAS_NO_VARIADICS
386 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
388 inline _LIBCPP_INLINE_VISIBILITY
390 thread::operator=(thread&& __t) _NOEXCEPT
399 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
401 inline _LIBCPP_INLINE_VISIBILITY
402 void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
404 namespace this_thread
407 _LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& ns);
409 template <class _Rep, class _Period>
411 sleep_for(const chrono::duration<_Rep, _Period>& __d)
413 using namespace chrono;
414 if (__d > duration<_Rep, _Period>::zero())
416 _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
420 __ns = duration_cast<nanoseconds>(__d);
425 __ns = nanoseconds::max();
430 template <class _Clock, class _Duration>
432 sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
434 using namespace chrono;
436 condition_variable __cv;
437 unique_lock<mutex> __lk(__mut);
438 while (_Clock::now() < __t)
439 __cv.wait_until(__lk, __t);
442 template <class _Duration>
443 inline _LIBCPP_INLINE_VISIBILITY
445 sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
447 using namespace chrono;
448 sleep_for(__t - steady_clock::now());
451 inline _LIBCPP_INLINE_VISIBILITY
452 void yield() _NOEXCEPT {sched_yield();}
456 _LIBCPP_END_NAMESPACE_STD
458 #endif // _LIBCPP_THREAD