thread revision 249989
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() noexcept; 30 template <class F, class ...Args> explicit thread(F&& f, Args&&... args); 31 ~thread(); 32 33 thread(const thread&) = delete; 34 thread(thread&& t) noexcept; 35 36 thread& operator=(const thread&) = delete; 37 thread& operator=(thread&& t) noexcept; 38 39 void swap(thread& t) noexcept; 40 41 bool joinable() const noexcept; 42 void join(); 43 void detach(); 44 id get_id() const noexcept; 45 native_handle_type native_handle(); 46 47 static unsigned hardware_concurrency() noexcept; 48}; 49 50void swap(thread& x, thread& y) noexcept; 51 52class thread::id 53{ 54public: 55 id() noexcept; 56}; 57 58bool 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; 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() noexcept; 73 74void yield() noexcept; 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#ifndef _LIBCPP_HAS_NO_VARIADICS 99#include <tuple> 100#endif 101#include <pthread.h> 102 103#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 104#pragma GCC system_header 105#endif 106 107#define __STDCPP_THREADS__ __cplusplus 108 109_LIBCPP_BEGIN_NAMESPACE_STD 110 111template <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 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();} 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{ 140 delete static_cast<pointer>(__p); 141} 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); 147#ifndef _LIBCPP_NO_EXCEPTIONS 148 if (__ec) 149 throw system_error(error_code(__ec, system_category()), 150 "__thread_specific_ptr construction failed"); 151#endif 152} 153 154template <class _Tp> 155__thread_specific_ptr<_Tp>::~__thread_specific_ptr() 156{ 157 pthread_key_delete(__key_); 158} 159 160template <class _Tp> 161typename __thread_specific_ptr<_Tp>::pointer 162__thread_specific_ptr<_Tp>::release() 163{ 164 pointer __p = get(); 165 pthread_setspecific(__key_, 0); 166 return __p; 167} 168 169template <class _Tp> 170void 171__thread_specific_ptr<_Tp>::reset(pointer __p) 172{ 173 pointer __p_old = get(); 174 pthread_setspecific(__key_, __p); 175 delete __p_old; 176} 177 178class _LIBCPP_TYPE_VIS thread; 179class _LIBCPP_TYPE_VIS __thread_id; 180 181namespace this_thread 182{ 183 184_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT; 185 186} // this_thread 187 188class _LIBCPP_TYPE_VIS __thread_id; 189template<> struct _LIBCPP_TYPE_VIS hash<__thread_id>; 190 191class _LIBCPP_TYPE_VIS __thread_id 192{ 193 // 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. 196 pthread_t __id_; 197 198public: 199 _LIBCPP_INLINE_VISIBILITY 200 __thread_id() _NOEXCEPT : __id_(0) {} 201 202 friend _LIBCPP_INLINE_VISIBILITY 203 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT 204 {return __x.__id_ == __y.__id_;} 205 friend _LIBCPP_INLINE_VISIBILITY 206 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT 207 {return !(__x == __y);} 208 friend _LIBCPP_INLINE_VISIBILITY 209 bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT 210 {return __x.__id_ < __y.__id_;} 211 friend _LIBCPP_INLINE_VISIBILITY 212 bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT 213 {return !(__y < __x);} 214 friend _LIBCPP_INLINE_VISIBILITY 215 bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT 216 {return __y < __x ;} 217 friend _LIBCPP_INLINE_VISIBILITY 218 bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT 219 {return !(__x < __y);} 220 221 template<class _CharT, class _Traits> 222 friend 223 _LIBCPP_INLINE_VISIBILITY 224 basic_ostream<_CharT, _Traits>& 225 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) 226 {return __os << __id.__id_;} 227 228private: 229 _LIBCPP_INLINE_VISIBILITY 230 __thread_id(pthread_t __id) : __id_(__id) {} 231 232 friend __thread_id this_thread::get_id() _NOEXCEPT; 233 friend class _LIBCPP_TYPE_VIS thread; 234 friend struct _LIBCPP_TYPE_VIS hash<__thread_id>; 235}; 236 237template<> 238struct _LIBCPP_TYPE_VIS hash<__thread_id> 239 : public unary_function<__thread_id, size_t> 240{ 241 _LIBCPP_INLINE_VISIBILITY 242 size_t operator()(__thread_id __v) const 243 { 244 return hash<pthread_t>()(__v.__id_); 245 } 246}; 247 248namespace this_thread 249{ 250 251inline _LIBCPP_INLINE_VISIBILITY 252__thread_id 253get_id() _NOEXCEPT 254{ 255 return pthread_self(); 256} 257 258} // this_thread 259 260class _LIBCPP_TYPE_VIS thread 261{ 262 pthread_t __t_; 263 264 thread(const thread&); 265 thread& operator=(const thread&); 266public: 267 typedef __thread_id id; 268 typedef pthread_t native_handle_type; 269 270 _LIBCPP_INLINE_VISIBILITY 271 thread() _NOEXCEPT : __t_(0) {} 272#ifndef _LIBCPP_HAS_NO_VARIADICS 273 template <class _Fp, class ..._Args, 274 class = typename enable_if 275 < 276 !is_same<typename decay<_Fp>::type, thread>::value 277 >::type 278 > 279 explicit thread(_Fp&& __f, _Args&&... __args); 280#else // _LIBCPP_HAS_NO_VARIADICS 281 template <class _Fp> explicit thread(_Fp __f); 282#endif 283 ~thread(); 284 285#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 286 _LIBCPP_INLINE_VISIBILITY 287 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;} 288 thread& operator=(thread&& __t) _NOEXCEPT; 289#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 290 291 _LIBCPP_INLINE_VISIBILITY 292 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);} 293 294 _LIBCPP_INLINE_VISIBILITY 295 bool joinable() const _NOEXCEPT {return __t_ != 0;} 296 void join(); 297 void detach(); 298 _LIBCPP_INLINE_VISIBILITY 299 id get_id() const _NOEXCEPT {return __t_;} 300 _LIBCPP_INLINE_VISIBILITY 301 native_handle_type native_handle() _NOEXCEPT {return __t_;} 302 303 static unsigned hardware_concurrency() _NOEXCEPT; 304}; 305 306class __assoc_sub_state; 307 308class _LIBCPP_HIDDEN __thread_struct_imp; 309 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 320 void notify_all_at_thread_exit(condition_variable*, mutex*); 321 void __make_ready_at_thread_exit(__assoc_sub_state*); 322}; 323 324__thread_specific_ptr<__thread_struct>& __thread_local_data(); 325 326#ifndef _LIBCPP_HAS_NO_VARIADICS 327 328template <class _Fp, class ..._Args, size_t ..._Indices> 329inline _LIBCPP_INLINE_VISIBILITY 330void 331__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>) 332{ 333 __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...); 334} 335 336template <class _Fp> 337void* 338__thread_proxy(void* __vp) 339{ 340 __thread_local_data().reset(new __thread_struct); 341 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); 342 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index; 343 __thread_execute(*__p, _Index()); 344 return nullptr; 345} 346 347template <class _Fp, class ..._Args, 348 class 349 > 350thread::thread(_Fp&& __f, _Args&&... __args) 351{ 352 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)), 354 __decay_copy(_VSTD::forward<_Args>(__args))...)); 355 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get()); 356 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 364template <class _Fp> 365void* 366__thread_proxy(void* __vp) 367{ 368 __thread_local_data().reset(new __thread_struct); 369 std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); 370 (*__p)(); 371 return nullptr; 372} 373 374template <class _Fp> 375thread::thread(_Fp __f) 376{ 377 std::unique_ptr<_Fp> __p(new _Fp(__f)); 378 int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get()); 379 if (__ec == 0) 380 __p.release(); 381 else 382 __throw_system_error(__ec, "thread constructor failed"); 383} 384 385#endif // _LIBCPP_HAS_NO_VARIADICS 386 387#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 388 389inline _LIBCPP_INLINE_VISIBILITY 390thread& 391thread::operator=(thread&& __t) _NOEXCEPT 392{ 393 if (__t_ != 0) 394 terminate(); 395 __t_ = __t.__t_; 396 __t.__t_ = 0; 397 return *this; 398} 399 400#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 401 402inline _LIBCPP_INLINE_VISIBILITY 403void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);} 404 405namespace 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; 415 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 } 429} 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> 444inline _LIBCPP_INLINE_VISIBILITY 445void 446sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t) 447{ 448 using namespace chrono; 449 sleep_for(__t - steady_clock::now()); 450} 451 452inline _LIBCPP_INLINE_VISIBILITY 453void yield() _NOEXCEPT {sched_yield();} 454 455} // this_thread 456 457_LIBCPP_END_NAMESPACE_STD 458 459#endif // _LIBCPP_THREAD 460