blob: 74194ac4e361506ab7e31678bb0eeb0808e7ac3e [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001//===------------------------- thread.cpp----------------------------------===//
2//
Howard Hinnantc566dc32010-05-11 21:36:01 +00003// The LLVM Compiler Infrastructure
Howard Hinnantc51e1022010-05-11 19:42:16 +00004//
Howard Hinnantee11c312010-11-16 22:09:02 +00005// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantc51e1022010-05-11 19:42:16 +00007//
8//===----------------------------------------------------------------------===//
9
Jonathan Roelofs39cb6bf2014-09-05 19:45:05 +000010#include "__config"
11#ifndef _LIBCPP_HAS_NO_THREADS
12
Howard Hinnantc51e1022010-05-11 19:42:16 +000013#include "thread"
14#include "exception"
Howard Hinnant3820f6b2010-08-27 20:10:19 +000015#include "vector"
16#include "future"
Howard Hinnant9ce8dc52012-08-30 19:14:33 +000017#include "limits"
Howard Hinnantd031c582010-05-25 17:25:25 +000018#include <sys/types.h>
Ben Craig664df1f2016-01-29 13:53:23 +000019
20#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
21# include <sys/param.h>
22# if defined(BSD)
JF Bastien57daf9b2014-12-02 17:30:19 +000023# include <sys/sysctl.h>
Ben Craig664df1f2016-01-29 13:53:23 +000024# endif // defined(BSD)
25#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
26
Ed Schoutenf3034f72017-02-11 08:30:18 +000027#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__CloudABI__)
JF Bastien57daf9b2014-12-02 17:30:19 +000028# include <unistd.h>
Ed Schoutenf3034f72017-02-11 08:30:18 +000029#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__CloudABI__)
Howard Hinnantc51e1022010-05-11 19:42:16 +000030
Joerg Sonnenberger22939542013-05-17 21:16:18 +000031#if defined(__NetBSD__)
32#pragma weak pthread_create // Do not create libpthread dependency
33#endif
Saleem Abdulrasoolee302e42017-01-03 21:53:51 +000034
35#if defined(_LIBCPP_WIN32API)
Howard Hinnant287fc502013-07-02 17:53:48 +000036#include <windows.h>
Saleem Abdulrasoolee302e42017-01-03 21:53:51 +000037#endif // defined(_LIBCPP_WIN32API)
Joerg Sonnenberger22939542013-05-17 21:16:18 +000038
Howard Hinnantc51e1022010-05-11 19:42:16 +000039_LIBCPP_BEGIN_NAMESPACE_STD
40
41thread::~thread()
42{
Asiri Rathnayakedb97e252017-01-16 13:13:01 +000043 if (!__libcpp_thread_isnull(&__t_))
Howard Hinnantc51e1022010-05-11 19:42:16 +000044 terminate();
45}
46
47void
48thread::join()
49{
Asiri Rathnayake9f71bc52016-06-03 08:45:26 +000050 int ec = EINVAL;
Asiri Rathnayakedb97e252017-01-16 13:13:01 +000051 if (!__libcpp_thread_isnull(&__t_))
Asiri Rathnayake9f71bc52016-06-03 08:45:26 +000052 {
53 ec = __libcpp_thread_join(&__t_);
54 if (ec == 0)
Asiri Rathnayakedb97e252017-01-16 13:13:01 +000055 __t_ = _LIBCPP_NULL_THREAD;
Asiri Rathnayake9f71bc52016-06-03 08:45:26 +000056 }
Marshall Clow8fea1612016-08-25 15:09:01 +000057
Howard Hinnantc51e1022010-05-11 19:42:16 +000058 if (ec)
Marshall Clow8fea1612016-08-25 15:09:01 +000059 __throw_system_error(ec, "thread::join failed");
Howard Hinnantc51e1022010-05-11 19:42:16 +000060}
61
62void
63thread::detach()
64{
65 int ec = EINVAL;
Asiri Rathnayakedb97e252017-01-16 13:13:01 +000066 if (!__libcpp_thread_isnull(&__t_))
Howard Hinnantc51e1022010-05-11 19:42:16 +000067 {
Asiri Rathnayakefa2e2032016-05-06 14:06:29 +000068 ec = __libcpp_thread_detach(&__t_);
Howard Hinnantc51e1022010-05-11 19:42:16 +000069 if (ec == 0)
Asiri Rathnayakedb97e252017-01-16 13:13:01 +000070 __t_ = _LIBCPP_NULL_THREAD;
Howard Hinnantc51e1022010-05-11 19:42:16 +000071 }
Marshall Clow8fea1612016-08-25 15:09:01 +000072
Howard Hinnantc51e1022010-05-11 19:42:16 +000073 if (ec)
Marshall Clow8fea1612016-08-25 15:09:01 +000074 __throw_system_error(ec, "thread::detach failed");
Howard Hinnantc51e1022010-05-11 19:42:16 +000075}
76
77unsigned
Howard Hinnant4bd34702012-07-21 16:50:47 +000078thread::hardware_concurrency() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +000079{
Howard Hinnant155c2af2010-05-24 17:49:41 +000080#if defined(CTL_HW) && defined(HW_NCPU)
Howard Hinnant28b24882011-12-01 20:21:04 +000081 unsigned n;
Howard Hinnantc51e1022010-05-11 19:42:16 +000082 int mib[2] = {CTL_HW, HW_NCPU};
83 std::size_t s = sizeof(n);
84 sysctl(mib, 2, &n, &s, 0, 0);
85 return n;
Howard Hinnant4a55d842013-06-30 00:14:43 +000086#elif defined(_SC_NPROCESSORS_ONLN)
Howard Hinnant55c3c5f2012-08-02 18:17:49 +000087 long result = sysconf(_SC_NPROCESSORS_ONLN);
Howard Hinnant3f648332012-12-27 23:24:31 +000088 // sysconf returns -1 if the name is invalid, the option does not exist or
89 // does not have a definite limit.
Marshall Clowdcfde7a2013-02-07 18:48:09 +000090 // if sysconf returns some other negative number, we have no idea
91 // what is going on. Default to something safe.
92 if (result < 0)
Howard Hinnant3f648332012-12-27 23:24:31 +000093 return 0;
Marshall Clow84d47b92013-02-07 17:37:58 +000094 return static_cast<unsigned>(result);
Saleem Abdulrasoolee302e42017-01-03 21:53:51 +000095#elif defined(_LIBCPP_WIN32API)
Howard Hinnant287fc502013-07-02 17:53:48 +000096 SYSTEM_INFO info;
97 GetSystemInfo(&info);
98 return info.dwNumberOfProcessors;
Howard Hinnantffb308e2010-08-22 00:03:27 +000099#else // defined(CTL_HW) && defined(HW_NCPU)
Howard Hinnant155c2af2010-05-24 17:49:41 +0000100 // TODO: grovel through /proc or check cpuid on x86 and similar
101 // instructions on other architectures.
Saleem Abdulrasoold94ab1c2017-02-06 05:26:49 +0000102# if defined(_LIBCPP_MSVC)
Howard Hinnant408927e2013-10-04 21:14:44 +0000103 _LIBCPP_WARNING("hardware_concurrency not yet implemented")
104# else
105# warning hardware_concurrency not yet implemented
106# endif
Howard Hinnant155c2af2010-05-24 17:49:41 +0000107 return 0; // Means not computable [thread.thread.static]
Howard Hinnantffb308e2010-08-22 00:03:27 +0000108#endif // defined(CTL_HW) && defined(HW_NCPU)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000109}
110
111namespace this_thread
112{
113
114void
115sleep_for(const chrono::nanoseconds& ns)
116{
Asiri Rathnayake5b8bf4f2017-02-09 09:31:41 +0000117 if (ns > chrono::nanoseconds::zero())
Howard Hinnantc51e1022010-05-11 19:42:16 +0000118 {
Asiri Rathnayake5b8bf4f2017-02-09 09:31:41 +0000119 __libcpp_thread_sleep_for(ns);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000120 }
121}
122
123} // this_thread
124
Howard Hinnant15d55052010-10-14 19:18:04 +0000125__thread_specific_ptr<__thread_struct>&
126__thread_local_data()
127{
128 static __thread_specific_ptr<__thread_struct> __p;
129 return __p;
130}
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000131
132// __thread_struct_imp
133
Howard Hinnantcf823322010-12-17 14:46:43 +0000134template <class T>
135class _LIBCPP_HIDDEN __hidden_allocator
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000136{
Howard Hinnantcf823322010-12-17 14:46:43 +0000137public:
138 typedef T value_type;
139
140 T* allocate(size_t __n)
141 {return static_cast<T*>(::operator new(__n * sizeof(T)));}
Joerg Sonnenbergerc7655a22014-01-04 17:43:00 +0000142 void deallocate(T* __p, size_t) {::operator delete(static_cast<void*>(__p));}
Howard Hinnantcf823322010-12-17 14:46:43 +0000143
144 size_t max_size() const {return size_t(~0) / sizeof(T);}
145};
146
147class _LIBCPP_HIDDEN __thread_struct_imp
148{
149 typedef vector<__assoc_sub_state*,
150 __hidden_allocator<__assoc_sub_state*> > _AsyncStates;
151 typedef vector<pair<condition_variable*, mutex*>,
152 __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify;
Howard Hinnante6a10852010-09-03 21:46:37 +0000153
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000154 _AsyncStates async_states_;
Howard Hinnante6a10852010-09-03 21:46:37 +0000155 _Notify notify_;
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000156
157 __thread_struct_imp(const __thread_struct_imp&);
158 __thread_struct_imp& operator=(const __thread_struct_imp&);
159public:
160 __thread_struct_imp() {}
161 ~__thread_struct_imp();
162
Howard Hinnante6a10852010-09-03 21:46:37 +0000163 void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000164 void __make_ready_at_thread_exit(__assoc_sub_state* __s);
165};
166
167__thread_struct_imp::~__thread_struct_imp()
168{
Howard Hinnante6a10852010-09-03 21:46:37 +0000169 for (_Notify::iterator i = notify_.begin(), e = notify_.end();
170 i != e; ++i)
171 {
172 i->second->unlock();
173 i->first->notify_all();
174 }
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000175 for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end();
176 i != e; ++i)
177 {
178 (*i)->__make_ready();
179 (*i)->__release_shared();
180 }
181}
182
183void
Howard Hinnante6a10852010-09-03 21:46:37 +0000184__thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
185{
186 notify_.push_back(pair<condition_variable*, mutex*>(cv, m));
187}
188
189void
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000190__thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s)
191{
192 async_states_.push_back(__s);
193 __s->__add_shared();
194}
195
196// __thread_struct
197
198__thread_struct::__thread_struct()
199 : __p_(new __thread_struct_imp)
200{
201}
202
203__thread_struct::~__thread_struct()
204{
205 delete __p_;
206}
207
208void
Howard Hinnante6a10852010-09-03 21:46:37 +0000209__thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
210{
211 __p_->notify_all_at_thread_exit(cv, m);
212}
213
214void
Howard Hinnant3820f6b2010-08-27 20:10:19 +0000215__thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
216{
217 __p_->__make_ready_at_thread_exit(__s);
218}
219
Howard Hinnantc51e1022010-05-11 19:42:16 +0000220_LIBCPP_END_NAMESPACE_STD
Jonathan Roelofs39cb6bf2014-09-05 19:45:05 +0000221
222#endif // !_LIBCPP_HAS_NO_THREADS