Line data Source code
1 : // <thread> -*- C++ -*-
2 :
3 : // Copyright (C) 2008-2013 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 include/thread
26 : * This is a Standard C++ Library header.
27 : */
28 :
29 : #ifndef _GLIBCXX_THREAD
30 : #define _GLIBCXX_THREAD 1
31 :
32 : #pragma GCC system_header
33 :
34 : #if __cplusplus < 201103L
35 : # include <bits/c++0x_warning.h>
36 : #else
37 :
38 : #include <chrono>
39 : #include <functional>
40 : #include <memory>
41 : #include <bits/functexcept.h>
42 : #include <bits/functional_hash.h>
43 : #include <bits/gthr.h>
44 :
45 : #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
46 :
47 : namespace std _GLIBCXX_VISIBILITY(default)
48 : {
49 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
50 :
51 : /**
52 : * @defgroup threads Threads
53 : * @ingroup concurrency
54 : *
55 : * Classes for thread support.
56 : * @{
57 : */
58 :
59 : /// thread
60 : class thread
61 : {
62 : public:
63 : typedef __gthread_t native_handle_type;
64 : struct _Impl_base;
65 : typedef shared_ptr<_Impl_base> __shared_base_type;
66 :
67 : /// thread::id
68 : class id
69 : {
70 : native_handle_type _M_thread;
71 :
72 : public:
73 49034 : id() noexcept : _M_thread() { }
74 :
75 : explicit
76 : id(native_handle_type __id) : _M_thread(__id) { }
77 :
78 : private:
79 : friend class thread;
80 : friend class hash<thread::id>;
81 :
82 : friend bool
83 24517 : operator==(thread::id __x, thread::id __y) noexcept
84 24517 : { return __gthread_equal(__x._M_thread, __y._M_thread); }
85 :
86 : friend bool
87 : operator<(thread::id __x, thread::id __y) noexcept
88 : { return __x._M_thread < __y._M_thread; }
89 :
90 : template<class _CharT, class _Traits>
91 : friend basic_ostream<_CharT, _Traits>&
92 : operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
93 : };
94 :
95 : // Simple base type that the templatized, derived class containing
96 : // an arbitrary functor can be converted to and called.
97 49013 : struct _Impl_base
98 : {
99 : __shared_base_type _M_this_ptr;
100 :
101 : inline virtual ~_Impl_base();
102 :
103 : virtual void _M_run() = 0;
104 : };
105 :
106 : template<typename _Callable>
107 24505 : struct _Impl : public _Impl_base
108 : {
109 : _Callable _M_func;
110 :
111 24507 : _Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
112 24507 : { }
113 :
114 : void
115 24506 : _M_run() { _M_func(); }
116 : };
117 :
118 : private:
119 : id _M_id;
120 :
121 : public:
122 : thread() noexcept = default;
123 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
124 : // 2097. packaged_task constructors should be constrained
125 : thread(thread&) = delete;
126 : thread(const thread&) = delete;
127 :
128 10 : thread(thread&& __t) noexcept
129 10 : { swap(__t); }
130 :
131 : template<typename _Callable, typename... _Args>
132 : explicit
133 24507 : thread(_Callable&& __f, _Args&&... __args)
134 24507 : {
135 24507 : _M_start_thread(_M_make_routine(std::__bind_simple(
136 24507 : std::forward<_Callable>(__f),
137 24504 : std::forward<_Args>(__args)...)));
138 24507 : }
139 :
140 24517 : ~thread()
141 : {
142 24517 : if (joinable())
143 0 : std::terminate();
144 24517 : }
145 :
146 : thread& operator=(const thread&) = delete;
147 :
148 : thread& operator=(thread&& __t) noexcept
149 : {
150 : if (joinable())
151 : std::terminate();
152 : swap(__t);
153 : return *this;
154 : }
155 :
156 : void
157 10 : swap(thread& __t) noexcept
158 10 : { std::swap(_M_id, __t._M_id); }
159 :
160 : bool
161 24517 : joinable() const noexcept
162 24517 : { return !(_M_id == id()); }
163 :
164 : void
165 : join();
166 :
167 : void
168 : detach();
169 :
170 : thread::id
171 : get_id() const noexcept
172 : { return _M_id; }
173 :
174 : /** @pre thread is joinable
175 : */
176 : native_handle_type
177 : native_handle()
178 : { return _M_id._M_thread; }
179 :
180 : // Returns a value that hints at the number of hardware thread contexts.
181 : static unsigned int
182 : hardware_concurrency() noexcept;
183 :
184 : private:
185 : void
186 : _M_start_thread(__shared_base_type);
187 :
188 : template<typename _Callable>
189 : shared_ptr<_Impl<_Callable>>
190 24507 : _M_make_routine(_Callable&& __f)
191 : {
192 : // Create and allocate full data structure, not base.
193 24507 : return std::make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f));
194 : }
195 : };
196 :
197 : inline thread::_Impl_base::~_Impl_base() = default;
198 :
199 : inline void
200 : swap(thread& __x, thread& __y) noexcept
201 : { __x.swap(__y); }
202 :
203 : inline bool
204 : operator!=(thread::id __x, thread::id __y) noexcept
205 : { return !(__x == __y); }
206 :
207 : inline bool
208 : operator<=(thread::id __x, thread::id __y) noexcept
209 : { return !(__y < __x); }
210 :
211 : inline bool
212 : operator>(thread::id __x, thread::id __y) noexcept
213 : { return __y < __x; }
214 :
215 : inline bool
216 : operator>=(thread::id __x, thread::id __y) noexcept
217 : { return !(__x < __y); }
218 :
219 : // DR 889.
220 : /// std::hash specialization for thread::id.
221 : template<>
222 : struct hash<thread::id>
223 : : public __hash_base<size_t, thread::id>
224 : {
225 : size_t
226 : operator()(const thread::id& __id) const noexcept
227 : { return std::_Hash_impl::hash(__id._M_thread); }
228 : };
229 :
230 : template<class _CharT, class _Traits>
231 : inline basic_ostream<_CharT, _Traits>&
232 : operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
233 : {
234 : if (__id == thread::id())
235 : return __out << "thread::id of a non-executing thread";
236 : else
237 : return __out << __id._M_thread;
238 : }
239 :
240 : _GLIBCXX_END_NAMESPACE_VERSION
241 :
242 : /** @namespace std::this_thread
243 : * @brief ISO C++ 2011 entities sub-namespace for thread.
244 : * 30.3.2 Namespace this_thread.
245 : */
246 : namespace this_thread
247 : {
248 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
249 :
250 : /// get_id
251 : inline thread::id
252 : get_id() noexcept { return thread::id(__gthread_self()); }
253 :
254 : /// yield
255 : inline void
256 : yield() noexcept
257 : {
258 : #ifdef _GLIBCXX_USE_SCHED_YIELD
259 : __gthread_yield();
260 : #endif
261 : }
262 :
263 : void
264 : __sleep_for(chrono::seconds, chrono::nanoseconds);
265 :
266 : /// sleep_for
267 : template<typename _Rep, typename _Period>
268 : inline void
269 : sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
270 : {
271 : auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
272 : auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
273 : #ifdef _GLIBCXX_USE_NANOSLEEP
274 : __gthread_time_t __ts =
275 : {
276 : static_cast<std::time_t>(__s.count()),
277 : static_cast<long>(__ns.count())
278 : };
279 : ::nanosleep(&__ts, 0);
280 : #else
281 : __sleep_for(__s, __ns);
282 : #endif
283 : }
284 :
285 : /// sleep_until
286 : template<typename _Clock, typename _Duration>
287 : inline void
288 : sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
289 : { sleep_for(__atime - _Clock::now()); }
290 :
291 : _GLIBCXX_END_NAMESPACE_VERSION
292 : }
293 :
294 : // @} group threads
295 :
296 : } // namespace
297 :
298 : #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
299 :
300 : #endif // C++11
301 :
302 : #endif // _GLIBCXX_THREAD
|
