1 // -*- C++ -*- 2 //===--------------------------- thread -----------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP_THREAD 11 #define _LIBCPP_THREAD 12 13 /* 14 15 thread synopsis 16 17 namespace std 18 { 19 20 class thread 21 { 22 public: 23 class id; 24 typedef pthread_t native_handle_type; 25 26 thread() noexcept; 27 template <class F, class ...Args> explicit thread(F&& f, Args&&... args); 28 ~thread(); 29 30 thread(const thread&) = delete; 31 thread(thread&& t) noexcept; 32 33 thread& operator=(const thread&) = delete; 34 thread& operator=(thread&& t) noexcept; 35 36 void swap(thread& t) noexcept; 37 38 bool joinable() const noexcept; 39 void join(); 40 void detach(); 41 id get_id() const noexcept; 42 native_handle_type native_handle(); 43 44 static unsigned hardware_concurrency() noexcept; 45 }; 46 47 void swap(thread& x, thread& y) noexcept; 48 49 class thread::id 50 { 51 public: 52 id() noexcept; 53 }; 54 55 bool operator==(thread::id x, thread::id y) noexcept; 56 bool operator!=(thread::id x, thread::id y) noexcept; 57 bool operator< (thread::id x, thread::id 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 62 template<class charT, class traits> 63 basic_ostream<charT, traits>& 64 operator<<(basic_ostream<charT, traits>& out, thread::id id); 65 66 namespace this_thread 67 { 68 69 thread::id get_id() noexcept; 70 71 void yield() noexcept; 72 73 template <class Clock, class Duration> 74 void sleep_until(const chrono::time_point<Clock, Duration>& abs_time); 75 76 template <class Rep, class Period> 77 void sleep_for(const chrono::duration<Rep, Period>& rel_time); 78 79 } // this_thread 80 81 } // std 82 83 */ 84 85 #include <__config> 86 #include <iosfwd> 87 #include <__functional_base> 88 #include <type_traits> 89 #include <cstddef> 90 #include <functional> 91 #include <memory> 92 #include <system_error> 93 #include <chrono> 94 #include <__mutex_base> 95 #ifndef _LIBCPP_CXX03_LANG 96 #include <tuple> 97 #endif 98 #include <__threading_support> 99 #include <__debug> 100 101 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 102 #pragma GCC system_header 103 #endif 104 105 _LIBCPP_PUSH_MACROS 106 #include <__undef_macros> 107 108 #ifdef _LIBCPP_HAS_NO_THREADS 109 #error <thread> is not supported on this single threaded system 110 #else // !_LIBCPP_HAS_NO_THREADS 111 112 _LIBCPP_BEGIN_NAMESPACE_STD 113 114 template <class _Tp> class __thread_specific_ptr; 115 class _LIBCPP_TYPE_VIS __thread_struct; 116 class _LIBCPP_HIDDEN __thread_struct_imp; 117 class __assoc_sub_state; 118 119 _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data(); 120 121 class _LIBCPP_TYPE_VIS __thread_struct 122 { 123 __thread_struct_imp* __p_; 124 125 __thread_struct(const __thread_struct&); 126 __thread_struct& operator=(const __thread_struct&); 127 public: 128 __thread_struct(); 129 ~__thread_struct(); 130 131 void notify_all_at_thread_exit(condition_variable*, mutex*); 132 void __make_ready_at_thread_exit(__assoc_sub_state*); 133 }; 134 135 template <class _Tp> 136 class __thread_specific_ptr 137 { 138 __libcpp_tls_key __key_; 139 140 // Only __thread_local_data() may construct a __thread_specific_ptr 141 // and only with _Tp == __thread_struct. 142 static_assert((is_same<_Tp, __thread_struct>::value), ""); 143 __thread_specific_ptr(); 144 friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data(); 145 146 __thread_specific_ptr(const __thread_specific_ptr&); 147 __thread_specific_ptr& operator=(const __thread_specific_ptr&); 148 149 _LIBCPP_HIDDEN static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*); 150 151 public: 152 typedef _Tp* pointer; 153 154 ~__thread_specific_ptr(); 155 156 _LIBCPP_INLINE_VISIBILITY 157 pointer get() const {return static_cast<_Tp*>(__libcpp_tls_get(__key_));} 158 _LIBCPP_INLINE_VISIBILITY 159 pointer operator*() const {return *get();} 160 _LIBCPP_INLINE_VISIBILITY 161 pointer operator->() const {return get();} 162 void set_pointer(pointer __p); 163 }; 164 165 template <class _Tp> 166 void _LIBCPP_TLS_DESTRUCTOR_CC 167 __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p) 168 { 169 delete static_cast<pointer>(__p); 170 } 171 172 template <class _Tp> 173 __thread_specific_ptr<_Tp>::__thread_specific_ptr() 174 { 175 int __ec = 176 __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit); 177 if (__ec) 178 __throw_system_error(__ec, "__thread_specific_ptr construction failed"); 179 } 180 181 template <class _Tp> 182 __thread_specific_ptr<_Tp>::~__thread_specific_ptr() 183 { 184 // __thread_specific_ptr is only created with a static storage duration 185 // so this destructor is only invoked during program termination. Invoking 186 // pthread_key_delete(__key_) may prevent other threads from deleting their 187 // thread local data. For this reason we leak the key. 188 } 189 190 template <class _Tp> 191 void 192 __thread_specific_ptr<_Tp>::set_pointer(pointer __p) 193 { 194 _LIBCPP_ASSERT(get() == nullptr, 195 "Attempting to overwrite thread local data"); 196 __libcpp_tls_set(__key_, __p); 197 } 198 199 template<> 200 struct _LIBCPP_TEMPLATE_VIS hash<__thread_id> 201 : public unary_function<__thread_id, size_t> 202 { 203 _LIBCPP_INLINE_VISIBILITY 204 size_t operator()(__thread_id __v) const _NOEXCEPT 205 { 206 return hash<__libcpp_thread_id>()(__v.__id_); 207 } 208 }; 209 210 template<class _CharT, class _Traits> 211 _LIBCPP_INLINE_VISIBILITY 212 basic_ostream<_CharT, _Traits>& 213 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) 214 {return __os << __id.__id_;} 215 216 class _LIBCPP_TYPE_VIS thread 217 { 218 __libcpp_thread_t __t_; 219 220 thread(const thread&); 221 thread& operator=(const thread&); 222 public: 223 typedef __thread_id id; 224 typedef __libcpp_thread_t native_handle_type; 225 226 _LIBCPP_INLINE_VISIBILITY 227 thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {} 228 #ifndef _LIBCPP_CXX03_LANG 229 template <class _Fp, class ..._Args, 230 class = typename enable_if 231 < 232 !is_same<typename __uncvref<_Fp>::type, thread>::value 233 >::type 234 > 235 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 236 explicit thread(_Fp&& __f, _Args&&... __args); 237 #else // _LIBCPP_CXX03_LANG 238 template <class _Fp> 239 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 240 explicit thread(_Fp __f); 241 #endif 242 ~thread(); 243 244 _LIBCPP_INLINE_VISIBILITY 245 thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) { 246 __t.__t_ = _LIBCPP_NULL_THREAD; 247 } 248 249 _LIBCPP_INLINE_VISIBILITY 250 thread& operator=(thread&& __t) _NOEXCEPT { 251 if (!__libcpp_thread_isnull(&__t_)) 252 terminate(); 253 __t_ = __t.__t_; 254 __t.__t_ = _LIBCPP_NULL_THREAD; 255 return *this; 256 } 257 258 _LIBCPP_INLINE_VISIBILITY 259 void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);} 260 261 _LIBCPP_INLINE_VISIBILITY 262 bool joinable() const _NOEXCEPT {return !__libcpp_thread_isnull(&__t_);} 263 void join(); 264 void detach(); 265 _LIBCPP_INLINE_VISIBILITY 266 id get_id() const _NOEXCEPT {return __libcpp_thread_get_id(&__t_);} 267 _LIBCPP_INLINE_VISIBILITY 268 native_handle_type native_handle() _NOEXCEPT {return __t_;} 269 270 static unsigned hardware_concurrency() _NOEXCEPT; 271 }; 272 273 #ifndef _LIBCPP_CXX03_LANG 274 275 template <class _TSp, class _Fp, class ..._Args, size_t ..._Indices> 276 inline _LIBCPP_INLINE_VISIBILITY 277 void 278 __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>) 279 { 280 _VSTD::__invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...); 281 } 282 283 template <class _Fp> 284 _LIBCPP_INLINE_VISIBILITY 285 void* __thread_proxy(void* __vp) 286 { 287 // _Fp = tuple< unique_ptr<__thread_struct>, Functor, Args...> 288 unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); 289 __thread_local_data().set_pointer(_VSTD::get<0>(*__p.get()).release()); 290 typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index; 291 _VSTD::__thread_execute(*__p.get(), _Index()); 292 return nullptr; 293 } 294 295 template <class _Fp, class ..._Args, 296 class 297 > 298 thread::thread(_Fp&& __f, _Args&&... __args) 299 { 300 typedef unique_ptr<__thread_struct> _TSPtr; 301 _TSPtr __tsp(new __thread_struct); 302 typedef tuple<_TSPtr, typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp; 303 unique_ptr<_Gp> __p( 304 new _Gp(_VSTD::move(__tsp), 305 _VSTD::__decay_copy(_VSTD::forward<_Fp>(__f)), 306 _VSTD::__decay_copy(_VSTD::forward<_Args>(__args))...)); 307 int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get()); 308 if (__ec == 0) 309 __p.release(); 310 else 311 __throw_system_error(__ec, "thread constructor failed"); 312 } 313 314 #else // _LIBCPP_CXX03_LANG 315 316 template <class _Fp> 317 struct __thread_invoke_pair { 318 // This type is used to pass memory for thread local storage and a functor 319 // to a newly created thread because std::pair doesn't work with 320 // std::unique_ptr in C++03. 321 __thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {} 322 unique_ptr<__thread_struct> __tsp_; 323 _Fp __fn_; 324 }; 325 326 template <class _Fp> 327 void* __thread_proxy_cxx03(void* __vp) 328 { 329 unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); 330 __thread_local_data().set_pointer(__p->__tsp_.release()); 331 (__p->__fn_)(); 332 return nullptr; 333 } 334 335 template <class _Fp> 336 thread::thread(_Fp __f) 337 { 338 339 typedef __thread_invoke_pair<_Fp> _InvokePair; 340 typedef unique_ptr<_InvokePair> _PairPtr; 341 _PairPtr __pp(new _InvokePair(__f)); 342 int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get()); 343 if (__ec == 0) 344 __pp.release(); 345 else 346 __throw_system_error(__ec, "thread constructor failed"); 347 } 348 349 #endif // _LIBCPP_CXX03_LANG 350 351 inline _LIBCPP_INLINE_VISIBILITY 352 void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);} 353 354 namespace this_thread 355 { 356 357 _LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& __ns); 358 359 template <class _Rep, class _Period> 360 void 361 sleep_for(const chrono::duration<_Rep, _Period>& __d) 362 { 363 if (__d > chrono::duration<_Rep, _Period>::zero()) 364 { 365 // The standard guarantees a 64bit signed integer resolution for nanoseconds, 366 // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits> 367 // and issues with long double folding on PowerPC with GCC. 368 _LIBCPP_CONSTEXPR chrono::duration<long double> _Max = 369 chrono::duration<long double>(9223372036.0L); 370 chrono::nanoseconds __ns; 371 if (__d < _Max) 372 { 373 __ns = chrono::duration_cast<chrono::nanoseconds>(__d); 374 if (__ns < __d) 375 ++__ns; 376 } 377 else 378 __ns = chrono::nanoseconds::max(); 379 this_thread::sleep_for(__ns); 380 } 381 } 382 383 template <class _Clock, class _Duration> 384 void 385 sleep_until(const chrono::time_point<_Clock, _Duration>& __t) 386 { 387 mutex __mut; 388 condition_variable __cv; 389 unique_lock<mutex> __lk(__mut); 390 while (_Clock::now() < __t) 391 __cv.wait_until(__lk, __t); 392 } 393 394 template <class _Duration> 395 inline _LIBCPP_INLINE_VISIBILITY 396 void 397 sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t) 398 { 399 this_thread::sleep_for(__t - chrono::steady_clock::now()); 400 } 401 402 inline _LIBCPP_INLINE_VISIBILITY 403 void yield() _NOEXCEPT {__libcpp_thread_yield();} 404 405 } // this_thread 406 407 _LIBCPP_END_NAMESPACE_STD 408 409 #endif // !_LIBCPP_HAS_NO_THREADS 410 411 _LIBCPP_POP_MACROS 412 413 #endif // _LIBCPP_THREAD 414
Indexes created Sun Sep 27 00:26:35 UTC 2026