1// -*- C++ -*- 2//===--------------------------- thread -----------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_THREAD 12#define _LIBCPP_THREAD 13 14/* 15 16 thread synopsis 17 18#define __STDCPP_THREADS__ __cplusplus 19 20namespace std 21{ 22 23class thread 24{ 25public: 26 class id; 27 typedef pthread_t native_handle_type; 28 29 thread(); 30 template <class F, class ...Args> explicit thread(F&& f, Args&&... args); 31 ~thread(); 32 33 thread(const thread&) = delete; 34 thread(thread&& t); 35 36 thread& operator=(const thread&) = delete; 37 thread& operator=(thread&& t); 38 39 void swap(thread& t); 40 41 bool joinable() const; 42 void join(); 43 void detach(); 44 id get_id() const; 45 native_handle_type native_handle(); 46 47 static unsigned hardware_concurrency(); 48}; 49 50void swap(thread& x, thread& y); 51 52class thread::id 53{ 54public: 55 id(); 56}; 57 58bool operator==(thread::id x, thread::id y); 59bool operator!=(thread::id x, thread::id y); 60bool operator< (thread::id x, thread::id y); 61bool operator<=(thread::id x, thread::id y); 62bool operator> (thread::id x, thread::id y); 63bool operator>=(thread::id x, thread::id y); 64 65template<class charT, class traits> 66basic_ostream<charT, traits>& 67operator<<(basic_ostream<charT, traits>& out, thread::id id); 68 69namespace this_thread 70{ 71 72thread::id get_id(); 73 74void yield(); 75 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> 98#include <pthread.h> 99 100#pragma GCC system_header 101 102#define __STDCPP_THREADS__ __cplusplus 103 104_LIBCPP_BEGIN_NAMESPACE_STD 105 106template <class _Tp> 107class __thread_specific_ptr 108{ 109 pthread_key_t __key_; 110 111 __thread_specific_ptr(const __thread_specific_ptr&); 112 __thread_specific_ptr& operator=(const __thread_specific_ptr&); 113 114 static void __at_thread_exit(void*); 115public: 116 typedef _Tp* pointer; 117 118 __thread_specific_ptr(); 119 ~__thread_specific_ptr(); 120 121 _LIBCPP_INLINE_VISIBILITY 122 pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));} 123 _LIBCPP_INLINE_VISIBILITY 124 pointer operator*() const {return *get();} 125 _LIBCPP_INLINE_VISIBILITY 126 pointer operator->() const {return get();} 127 pointer release(); 128 void reset(pointer __p = nullptr); 129}; 130 131template <class _Tp> 132void 133__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p) 134{ 135 delete static_cast<pointer>(__p); 136} 137 138template <class _Tp> 139__thread_specific_ptr<_Tp>::__thread_specific_ptr() 140{ 141 int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit); 142 if (__ec) 143 throw system_error(error_code(__ec, system_category()), 144 "__thread_specific_ptr construction failed"); 145} 146 147template <class _Tp> 148__thread_specific_ptr<_Tp>::~__thread_specific_ptr() 149{ 150 pthread_key_delete(__key_); 151} 152 153template <class _Tp> 154typename __thread_specific_ptr<_Tp>::pointer 155__thread_specific_ptr<_Tp>::release() 156{ 157 pointer __p = get(); 158 pthread_setspecific(__key_, 0); 159 return __p; 160} 161 162template <class _Tp> 163void 164__thread_specific_ptr<_Tp>::reset(pointer __p) 165{ 166 pointer __p_old = get(); 167 pthread_setspecific(__key_, __p); 168 delete __p_old; 169} 170 171class thread; 172class __thread_id; 173 174namespace this_thread 175{ 176 177__thread_id get_id(); 178 179} // this_thread 180 181class _LIBCPP_VISIBLE __thread_id 182{ 183 // FIXME: pthread_t is a pointer on Darwin but a long on Linux. 184 // NULL is the no-thread value on Darwin. Someone needs to check 185 // on other platforms. We assume 0 works everywhere for now. 186 pthread_t __id_; 187 188public: 189 _LIBCPP_INLINE_VISIBILITY 190 __thread_id() : __id_(0) {} 191 192 friend _LIBCPP_INLINE_VISIBILITY 193 bool operator==(__thread_id __x, __thread_id __y) 194 {return __x.__id_ == __y.__id_;} 195 friend _LIBCPP_INLINE_VISIBILITY 196 bool operator!=(__thread_id __x, __thread_id __y) 197 {return !(__x == __y);} 198 friend _LIBCPP_INLINE_VISIBILITY 199 bool operator< (__thread_id __x, __thread_id __y) 200 {return __x.__id_ < __y.__id_;} 201 friend _LIBCPP_INLINE_VISIBILITY 202 bool operator<=(__thread_id __x, __thread_id __y) 203 {return !(__y < __x);} 204 friend _LIBCPP_INLINE_VISIBILITY 205 bool operator> (__thread_id __x, __thread_id __y) 206 {return __y < __x ;} 207 friend _LIBCPP_INLINE_VISIBILITY 208 bool operator>=(__thread_id __x, __thread_id __y) 209 {return !(__x < __y);} 210 211 template<class _CharT, class _Traits> 212 friend 213 _LIBCPP_INLINE_VISIBILITY 214 basic_ostream<_CharT, _Traits>& 215 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) 216 {return __os << __id.__id_;} 217 218private: 219 _LIBCPP_INLINE_VISIBILITY 220 __thread_id(pthread_t __id) : __id_(__id) {} 221 222 friend __thread_id this_thread::get_id(); 223 friend class _LIBCPP_VISIBLE thread; 224}; 225 226template<class _Tp> struct hash; 227 228template<> 229struct _LIBCPP_VISIBLE hash<__thread_id> 230 : public unary_function<__thread_id, size_t> 231{ 232 _LIBCPP_INLINE_VISIBILITY 233 size_t operator()(__thread_id __v) const 234 { 235 const size_t* const __p = reinterpret_cast<const size_t*>(&__v); 236 return *__p; 237 } 238}; 239 240namespace this_thread 241{ 242 243inline _LIBCPP_INLINE_VISIBILITY 244__thread_id 245get_id() 246{ 247 return pthread_self(); 248} 249 250} // this_thread 251 252class _LIBCPP_VISIBLE thread 253{ 254 pthread_t __t_; 255 256 thread(const thread&); 257 thread& operator=(const thread&); 258public: 259 typedef __thread_id id; 260 typedef pthread_t native_handle_type; 261 262 _LIBCPP_INLINE_VISIBILITY 263 thread() : __t_(0) {} 264#ifndef _LIBCPP_HAS_NO_VARIADICS 265 template <class _F, class ..._Args, 266 class = typename enable_if 267 < 268 !is_same<typename decay<_F>::type, thread>::value 269 >::type 270 > 271 explicit thread(_F&& __f, _Args&&... __args); 272#else // _LIBCPP_HAS_NO_VARIADICS 273 template <class _F> explicit thread(_F __f); 274#endif 275 ~thread(); 276 277#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 278 _LIBCPP_INLINE_VISIBILITY 279 thread(thread&& __t) : __t_(__t.__t_) {__t.__t_ = 0;} 280 thread& operator=(thread&& __t); 281#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 282 283 _LIBCPP_INLINE_VISIBILITY 284 void swap(thread& __t) {_STD::swap(__t_, __t.__t_);} 285 286 _LIBCPP_INLINE_VISIBILITY 287 bool joinable() const {return __t_ != 0;} 288 void join(); 289 void detach(); 290 _LIBCPP_INLINE_VISIBILITY 291 id get_id() const {return __t_;} 292 _LIBCPP_INLINE_VISIBILITY 293 native_handle_type native_handle() {return __t_;} 294 295 static unsigned hardware_concurrency(); 296}; 297 298class __assoc_sub_state; 299 300class _LIBCPP_HIDDEN __thread_struct_imp; 301 302class __thread_struct 303{ 304 __thread_struct_imp* __p_; 305 306 __thread_struct(const __thread_struct&); 307 __thread_struct& operator=(const __thread_struct&); 308public: 309 __thread_struct(); 310 ~__thread_struct(); 311 312 void notify_all_at_thread_exit(condition_variable*, mutex*); 313 void __make_ready_at_thread_exit(__assoc_sub_state*); 314}; 315 316__thread_specific_ptr<__thread_struct>& __thread_local_data(); 317 318template <class _F> 319void* 320__thread_proxy(void* __vp) 321{ 322 __thread_local_data().reset(new __thread_struct); 323 std::unique_ptr<_F> __p(static_cast<_F*>(__vp)); 324 (*__p)(); 325 return nullptr; 326} 327 328#ifndef _LIBCPP_HAS_NO_VARIADICS 329 330template <class _F, class ..._Args, 331 class 332 > 333thread::thread(_F&& __f, _Args&&... __args) 334{ 335 typedef decltype(bind(std::forward<_F>(__f), std::forward<_Args>(__args)...)) _G; 336 std::unique_ptr<_G> __p(new _G(bind(std::forward<_F>(__f), 337 std::forward<_Args>(__args)...))); 338 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_G>, __p.get()); 339 if (__ec == 0) 340 __p.release(); 341 else 342 __throw_system_error(__ec, "thread constructor failed"); 343} 344 345#else // _LIBCPP_HAS_NO_VARIADICS 346 347template <class _F> 348thread::thread(_F __f) 349{ 350 std::unique_ptr<_F> __p(new _F(__f)); 351 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_F>, __p.get()); 352 if (__ec == 0) 353 __p.release(); 354 else 355 __throw_system_error(__ec, "thread constructor failed"); 356} 357 358#endif // _LIBCPP_HAS_NO_VARIADICS 359 360#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 361 362inline _LIBCPP_INLINE_VISIBILITY 363thread& 364thread::operator=(thread&& __t) 365{ 366 if (__t_ != 0) 367 terminate(); 368 __t_ = __t.__t_; 369 __t.__t_ = 0; 370 return *this; 371} 372 373#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 374 375inline _LIBCPP_INLINE_VISIBILITY 376void swap(thread& __x, thread& __y) {__x.swap(__y);} 377 378namespace this_thread 379{ 380 381void sleep_for(const chrono::nanoseconds& ns); 382 383template <class _Rep, class _Period> 384void 385sleep_for(const chrono::duration<_Rep, _Period>& __d) 386{ 387 using namespace chrono; 388 nanoseconds __ns = duration_cast<nanoseconds>(__d); 389 if (__ns < __d) 390 ++__ns; 391 sleep_for(__ns); 392} 393 394template <class _Clock, class _Duration> 395void 396sleep_until(const chrono::time_point<_Clock, _Duration>& __t) 397{ 398 using namespace chrono; 399 mutex __mut; 400 condition_variable __cv; 401 unique_lock<mutex> __lk(__mut); 402 while (_Clock::now() < __t) 403 __cv.wait_until(__lk, __t); 404} 405 406template <class _Duration> 407inline _LIBCPP_INLINE_VISIBILITY 408void 409sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t) 410{ 411 using namespace chrono; 412 sleep_for(__t - steady_clock::now()); 413} 414 415inline _LIBCPP_INLINE_VISIBILITY 416void yield() {sched_yield();} 417 418} // this_thread 419 420_LIBCPP_END_NAMESPACE_STD 421 422#endif // _LIBCPP_THREAD 423