1// std::thread declarations -*- C++ -*- 
2 
3// Copyright (C) 2008-2021 Free Software Foundation, Inc. 
4// 
5// This file is part of the GNU ISO C++ Library. This library is free 
6// software; you can redistribute it and/or modify it under the 
7// terms of the GNU General Public License as published by the 
8// Free Software Foundation; either version 3, or (at your option) 
9// any later version. 
10 
11// This library is distributed in the hope that it will be useful, 
12// but WITHOUT ANY WARRANTY; without even the implied warranty of 
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
14// GNU General Public License for more details. 
15 
16// Under Section 7 of GPL version 3, you are granted additional 
17// permissions described in the GCC Runtime Library Exception, version 
18// 3.1, as published by the Free Software Foundation. 
19 
20// You should have received a copy of the GNU General Public License and 
21// a copy of the GCC Runtime Library Exception along with this program; 
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
23// <http://www.gnu.org/licenses/>. 
24 
25/** @file bits/std_thread.h 
26 * This is an internal header file, included by other library headers. 
27 * Do not attempt to use it directly. @headername{thread} 
28 */ 
29 
30#ifndef _GLIBCXX_THREAD_H 
31#define _GLIBCXX_THREAD_H 1 
32 
33#pragma GCC system_header 
34 
35#if __cplusplus >= 201103L 
36#include <bits/c++config.h> 
37 
38#include <exception> // std::terminate 
39#include <iosfwd> // std::basic_ostream 
40#include <tuple> // std::tuple 
41#include <bits/functional_hash.h> // std::hash 
42#include <bits/invoke.h> // std::__invoke 
43#include <bits/refwrap.h> // not required, but helpful to users 
44#include <bits/unique_ptr.h> // std::unique_ptr 
45 
46#ifdef _GLIBCXX_HAS_GTHREADS 
47# include <bits/gthr.h> 
48#else 
49# include <errno.h> 
50# include <bits/functexcept.h> 
51#endif 
52 
53namespace std _GLIBCXX_VISIBILITY(default) 
54{ 
55_GLIBCXX_BEGIN_NAMESPACE_VERSION 
56 
57 /** @addtogroup threads 
58 * @{ 
59 */ 
60 
61 /// thread 
62 class thread 
63 { 
64 public: 
65#ifdef _GLIBCXX_HAS_GTHREADS 
66 // Abstract base class for types that wrap arbitrary functors to be 
67 // invoked in the new thread of execution. 
68 struct _State 
69 { 
70 virtual ~_State(); 
71 virtual void _M_run() = 0; 
72 }; 
73 using _State_ptr = unique_ptr<_State>; 
74 
75 using native_handle_type = __gthread_t; 
76#else 
77 using native_handle_type = int; 
78#endif 
79 
80 /// thread::id 
81 class id 
82 { 
83 native_handle_type _M_thread; 
84 
85 public: 
86 id() noexcept : _M_thread() { } 
87 
88 explicit 
89 id(native_handle_type __id) : _M_thread(__id) { } 
90 
91 private: 
92 friend class thread; 
93 friend struct hash<id>; 
94 
95 friend bool 
96 operator==(id __x, id __y) noexcept; 
97 
98#if __cpp_lib_three_way_comparison 
99 friend strong_ordering 
100 operator<=>(id __x, id __y) noexcept; 
101#else 
102 friend bool 
103 operator<(id __x, id __y) noexcept; 
104#endif 
105 
106 template<class _CharT, class _Traits> 
107 friend basic_ostream<_CharT, _Traits>& 
108 operator<<(basic_ostream<_CharT, _Traits>& __out, id __id); 
109 }; 
110 
111 private: 
112 id _M_id; 
113 
114 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
115 // 2097. packaged_task constructors should be constrained 
116 // 3039. Unnecessary decay in thread and packaged_task 
117 template<typename _Tp> 
118 using __not_same = __not_<is_same<__remove_cvref_t<_Tp>, thread>>; 
119 
120 public: 
121 thread() noexcept = default; 
122 
123#ifdef _GLIBCXX_HAS_GTHREADS 
124 template<typename _Callable, typename... _Args, 
125 typename = _Require<__not_same<_Callable>>> 
126 explicit 
127 thread(_Callable&& __f, _Args&&... __args) 
128 { 
129 static_assert( __is_invocable<typename decay<_Callable>::type, 
130 typename decay<_Args>::type...>::value, 
131 "std::thread arguments must be invocable after conversion to rvalues" 
132 ); 
133 
134#ifdef GTHR_ACTIVE_PROXY 
135 // Create a reference to pthread_create, not just the gthr weak symbol. 
136 auto __depend = reinterpret_cast<void(*)()>(&pthread_create); 
137#else 
138 auto __depend = nullptr; 
139#endif 
140 using _Wrapper = _Call_wrapper<_Callable, _Args...>; 
141 // Create a call wrapper with DECAY_COPY(__f) as its target object 
142 // and DECAY_COPY(__args)... as its bound argument entities. 
143 _M_start_thread(_State_ptr(new _State_impl<_Wrapper>( 
144 std::forward<_Callable>(__f), std::forward<_Args>(__args)...)), 
145 __depend); 
146 } 
147#endif // _GLIBCXX_HAS_GTHREADS 
148 
149 ~thread() 
150 { 
151 if (joinable()) 
152 std::terminate(); 
153 } 
154 
155 thread(const thread&) = delete; 
156 
157 thread(thread&& __t) noexcept 
158 { swap(__t); } 
159 
160 thread& operator=(const thread&) = delete; 
161 
162 thread& operator=(thread&& __t) noexcept 
163 { 
164 if (joinable()) 
165 std::terminate(); 
166 swap(__t); 
167 return *this; 
168 } 
169 
170 void 
171 swap(thread& __t) noexcept 
172 { std::swap(a&: _M_id, b&: __t._M_id); } 
173 
174 bool 
175 joinable() const noexcept 
176 { return !(_M_id == id()); } 
177 
178 void 
179 join(); 
180 
181 void 
182 detach(); 
183 
184 id 
185 get_id() const noexcept 
186 { return _M_id; } 
187 
188 /** @pre thread is joinable 
189 */ 
190 native_handle_type 
191 native_handle() 
192 { return _M_id._M_thread; } 
193 
194 // Returns a value that hints at the number of hardware thread contexts. 
195 static unsigned int 
196 hardware_concurrency() noexcept; 
197 
198#ifdef _GLIBCXX_HAS_GTHREADS 
199 private: 
200 template<typename _Callable> 
201 struct _State_impl : public _State 
202 { 
203 _Callable _M_func; 
204 
205 template<typename... _Args> 
206 _State_impl(_Args&&... __args) 
207 : _M_func(std::forward<_Args>(__args)...) 
208 { } 
209 
210 void 
211 _M_run() { _M_func(); } 
212 }; 
213 
214 void 
215 _M_start_thread(_State_ptr, void (*)()); 
216 
217#if _GLIBCXX_THREAD_ABI_COMPAT 
218 public: 
219 struct _Impl_base; 
220 typedef shared_ptr<_Impl_base> __shared_base_type; 
221 struct _Impl_base 
222 { 
223 __shared_base_type _M_this_ptr; 
224 virtual ~_Impl_base() = default; 
225 virtual void _M_run() = 0; 
226 }; 
227 
228 private: 
229 void 
230 _M_start_thread(__shared_base_type, void (*)()); 
231 
232 void 
233 _M_start_thread(__shared_base_type); 
234#endif 
235 
236 private: 
237 // A call wrapper that does INVOKE(forwarded tuple elements...) 
238 template<typename _Tuple> 
239 struct _Invoker 
240 { 
241 template<typename... _Args> 
242 explicit 
243 _Invoker(_Args&&... __args) 
244 : _M_t(std::forward<_Args>(__args)...) 
245 { } 
246 
247 _Tuple _M_t; 
248 
249 template<typename> 
250 struct __result; 
251 template<typename _Fn, typename... _Args> 
252 struct __result<tuple<_Fn, _Args...>> 
253 : __invoke_result<_Fn, _Args...> 
254 { }; 
255 
256 template<size_t... _Ind> 
257 typename __result<_Tuple>::type 
258 _M_invoke(_Index_tuple<_Ind...>) 
259 { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); } 
260 
261 typename __result<_Tuple>::type 
262 operator()() 
263 { 
264 using _Indices 
265 = typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type; 
266 return _M_invoke(_Indices()); 
267 } 
268 }; 
269 
270 public: 
271 template<typename... _Tp> 
272 using _Call_wrapper = _Invoker<tuple<typename decay<_Tp>::type...>>; 
273#endif // _GLIBCXX_HAS_GTHREADS 
274 }; 
275 
276#ifndef _GLIBCXX_HAS_GTHREADS 
277 inline void thread::join() { std::__throw_system_error(EINVAL); } 
278 inline void thread::detach() { std::__throw_system_error(EINVAL); } 
279 inline unsigned int thread::hardware_concurrency() noexcept { return 0; } 
280#endif 
281 
282 inline void 
283 swap(thread& __x, thread& __y) noexcept 
284 { __x.swap(t&: __y); } 
285 
286 inline bool 
287 operator==(thread::id __x, thread::id __y) noexcept 
288 { 
289 // pthread_equal is undefined if either thread ID is not valid, so we 
290 // can't safely use __gthread_equal on default-constructed values (nor 
291 // the non-zero value returned by this_thread::get_id() for 
292 // single-threaded programs using GNU libc). Assume EqualityComparable. 
293 return __x._M_thread == __y._M_thread; 
294 } 
295 
296 // N.B. other comparison operators are defined in <thread> 
297 
298 // DR 889. 
299 /// std::hash specialization for thread::id. 
300 template<> 
301 struct hash<thread::id> 
302 : public __hash_base<size_t, thread::id> 
303 { 
304 size_t 
305 operator()(const thread::id& __id) const noexcept 
306 { return std::_Hash_impl::hash(val: __id._M_thread); } 
307 }; 
308 
309 namespace this_thread 
310 { 
311 /// this_thread::get_id 
312 inline thread::id 
313 get_id() noexcept 
314 { 
315#ifndef _GLIBCXX_HAS_GTHREADS 
316 return thread::id(1); 
317#elif defined _GLIBCXX_NATIVE_THREAD_ID 
318 return thread::id(_GLIBCXX_NATIVE_THREAD_ID); 
319#else 
320 return thread::id(__gthread_self()); 
321#endif 
322 } 
323 
324 /// this_thread::yield 
325 inline void 
326 yield() noexcept 
327 { 
328#if defined _GLIBCXX_HAS_GTHREADS && defined _GLIBCXX_USE_SCHED_YIELD 
329 __gthread_yield(); 
330#endif 
331 } 
332 
333 } // namespace this_thread 
334 
335 /// @} 
336 
337_GLIBCXX_END_NAMESPACE_VERSION 
338} // namespace 
339#endif // C++11 
340 
341#endif // _GLIBCXX_THREAD_H 
342