1 // thread -*- C++ -*-
2 
3 // Copyright (C) 2008-2018 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 
26 #define _GLIBCXX_THREAD_ABI_COMPAT 1
27 #include <thread>
28 #include <system_error>
29 #include <cerrno>
30 #include <cxxabi_forced.h>
31 
32 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
33 
34 #if defined(_GLIBCXX_USE_GET_NPROCS)
35 # include <sys/sysinfo.h>
36 # define _GLIBCXX_NPROCS get_nprocs()
37 #elif defined(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP)
38 # define _GLIBCXX_NPROCS pthread_num_processors_np()
39 #elif defined(_GLIBCXX_USE_SYSCTL_HW_NCPU)
40 # include <stddef.h>
41 # include <sys/sysctl.h>
get_nprocs()42 static inline int get_nprocs()
43 {
44  int count;
45  size_t size = sizeof(count);
46  int mib[] = { CTL_HW, HW_NCPU };
47  if (!sysctl(mib, 2, &count, &size, NULL, 0))
48    return count;
49  return 0;
50 }
51 # define _GLIBCXX_NPROCS get_nprocs()
52 #elif defined(_GLIBCXX_USE_SC_NPROCESSORS_ONLN)
53 # include <unistd.h>
54 # define _GLIBCXX_NPROCS sysconf(_SC_NPROCESSORS_ONLN)
55 #elif defined(_GLIBCXX_USE_SC_NPROC_ONLN)
56 # include <unistd.h>
57 # define _GLIBCXX_NPROCS sysconf(_SC_NPROC_ONLN)
58 #else
59 # define _GLIBCXX_NPROCS 0
60 #endif
61 
62 #ifndef _GLIBCXX_USE_NANOSLEEP
63 # ifdef _GLIBCXX_HAVE_SLEEP
64 #  include <unistd.h>
65 # elif defined(_GLIBCXX_HAVE_WIN32_SLEEP)
66 #  include <windows.h>
67 # else
68 #  error "No sleep function known for this target"
69 # endif
70 #endif
71 
72 namespace std _GLIBCXX_VISIBILITY(default)
73 {
74   extern "C"
75   {
76     static void*
execute_native_thread_routine(void * __p)77     execute_native_thread_routine(void* __p)
78     {
79       thread::_State_ptr __t{ static_cast<thread::_State*>(__p) };
80       __t->_M_run();
81       return nullptr;
82     }
83 
84 #if _GLIBCXX_THREAD_ABI_COMPAT
85     static void*
execute_native_thread_routine_compat(void * __p)86     execute_native_thread_routine_compat(void* __p)
87     {
88       thread::_Impl_base* __t = static_cast<thread::_Impl_base*>(__p);
89       thread::__shared_base_type __local;
90       // Now that a new thread has been created we can transfer ownership of
91       // the thread state to a local object, breaking the reference cycle
92       // created in thread::_M_start_thread.
93       __local.swap(__t->_M_this_ptr);
94       __t->_M_run();
95       return nullptr;
96     }
97 #endif
98   } // extern "C"
99 
100 _GLIBCXX_BEGIN_NAMESPACE_VERSION
101 
102   thread::_State::~_State() = default;
103 
104   void
join()105   thread::join()
106   {
107     int __e = EINVAL;
108 
109     if (_M_id != id())
110       __e = __gthread_join(_M_id._M_thread, 0);
111 
112     if (__e)
113       __throw_system_error(__e);
114 
115     _M_id = id();
116   }
117 
118   void
detach()119   thread::detach()
120   {
121     int __e = EINVAL;
122 
123     if (_M_id != id())
124       __e = __gthread_detach(_M_id._M_thread);
125 
126     if (__e)
127       __throw_system_error(__e);
128 
129     _M_id = id();
130   }
131 
132   void
_M_start_thread(_State_ptr state,void (*)())133   thread::_M_start_thread(_State_ptr state, void (*)())
134   {
135     const int err = __gthread_create(&_M_id._M_thread,
136 				     &execute_native_thread_routine,
137 				     state.get());
138     if (err)
139       __throw_system_error(err);
140     state.release();
141   }
142 
143 #if _GLIBCXX_THREAD_ABI_COMPAT
144   void
_M_start_thread(__shared_base_type __b)145   thread::_M_start_thread(__shared_base_type __b)
146   {
147     if (!__gthread_active_p())
148 #if __cpp_exceptions
149       throw system_error(make_error_code(errc::operation_not_permitted),
150 			 "Enable multithreading to use std::thread");
151 #else
152       __throw_system_error(int(errc::operation_not_permitted));
153 #endif
154 
155     _M_start_thread(std::move(__b), nullptr);
156   }
157 
158   void
_M_start_thread(__shared_base_type __b,void (*)())159   thread::_M_start_thread(__shared_base_type __b, void (*)())
160   {
161     auto ptr = __b.get();
162     // Create a reference cycle that will be broken in the new thread.
163     ptr->_M_this_ptr = std::move(__b);
164     int __e = __gthread_create(&_M_id._M_thread,
165 			       &execute_native_thread_routine_compat, ptr);
166     if (__e)
167     {
168       ptr->_M_this_ptr.reset();  // break reference cycle, destroying *ptr.
169       __throw_system_error(__e);
170     }
171   }
172 #endif
173 
174   unsigned int
hardware_concurrency()175   thread::hardware_concurrency() noexcept
176   {
177     int __n = _GLIBCXX_NPROCS;
178     if (__n < 0)
179       __n = 0;
180     return __n;
181   }
182 
183 namespace this_thread
184 {
185   void
__sleep_for(chrono::seconds __s,chrono::nanoseconds __ns)186   __sleep_for(chrono::seconds __s, chrono::nanoseconds __ns)
187   {
188 #ifdef _GLIBCXX_USE_NANOSLEEP
189     __gthread_time_t __ts =
190       {
191 	static_cast<std::time_t>(__s.count()),
192 	static_cast<long>(__ns.count())
193       };
194     while (::nanosleep(&__ts, &__ts) == -1 && errno == EINTR)
195       { }
196 #elif defined(_GLIBCXX_HAVE_SLEEP)
197 # ifdef _GLIBCXX_HAVE_USLEEP
198     ::sleep(__s.count());
199     if (__ns.count() > 0)
200       {
201         long __us = __ns.count() / 1000;
202         if (__us == 0)
203           __us = 1;
204         ::usleep(__us);
205       }
206 # else
207     ::sleep(__s.count() + (__ns.count() >= 1000000));
208 # endif
209 #elif defined(_GLIBCXX_HAVE_WIN32_SLEEP)
210     unsigned long ms = __ns.count() / 1000000;
211     if (__ns.count() > 0 && ms == 0)
212       ms = 1;
213     ::Sleep(chrono::milliseconds(__s).count() + ms);
214 #endif
215   }
216 }
217 
218 _GLIBCXX_END_NAMESPACE_VERSION
219 } // namespace std
220 
221 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
222