1//===------------------------- thread.cpp----------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "__config"
11#ifndef _LIBCPP_HAS_NO_THREADS
12
13#include "thread"
14#include "exception"
15#include "vector"
16#include "future"
17#include "limits"
18#include <sys/types.h>
19
20#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
21# include <sys/param.h>
22# if defined(BSD)
23#   include <sys/sysctl.h>
24# endif // defined(BSD)
25#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
26
27#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__CloudABI__) || defined(__Fuchsia__)
28# include <unistd.h>
29#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__CloudABI__) || defined(__Fuchsia__)
30
31#if defined(__NetBSD__)
32#pragma weak pthread_create // Do not create libpthread dependency
33#endif
34
35#if defined(_LIBCPP_WIN32API)
36#include <windows.h>
37#endif
38
39_LIBCPP_BEGIN_NAMESPACE_STD
40
41thread::~thread()
42{
43    if (!__libcpp_thread_isnull(&__t_))
44        terminate();
45}
46
47void
48thread::join()
49{
50    int ec = EINVAL;
51    if (!__libcpp_thread_isnull(&__t_))
52    {
53        ec = __libcpp_thread_join(&__t_);
54        if (ec == 0)
55            __t_ = _LIBCPP_NULL_THREAD;
56    }
57
58    if (ec)
59        __throw_system_error(ec, "thread::join failed");
60}
61
62void
63thread::detach()
64{
65    int ec = EINVAL;
66    if (!__libcpp_thread_isnull(&__t_))
67    {
68        ec = __libcpp_thread_detach(&__t_);
69        if (ec == 0)
70            __t_ = _LIBCPP_NULL_THREAD;
71    }
72
73    if (ec)
74        __throw_system_error(ec, "thread::detach failed");
75}
76
77unsigned
78thread::hardware_concurrency() _NOEXCEPT
79{
80#if defined(CTL_HW) && defined(HW_NCPU)
81    unsigned n;
82    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;
86#elif defined(_SC_NPROCESSORS_ONLN)
87    long result = sysconf(_SC_NPROCESSORS_ONLN);
88    // sysconf returns -1 if the name is invalid, the option does not exist or
89    // does not have a definite limit.
90    // if sysconf returns some other negative number, we have no idea
91    // what is going on. Default to something safe.
92    if (result < 0)
93        return 0;
94    return static_cast<unsigned>(result);
95#elif defined(_LIBCPP_WIN32API)
96    SYSTEM_INFO info;
97    GetSystemInfo(&info);
98    return info.dwNumberOfProcessors;
99#else  // defined(CTL_HW) && defined(HW_NCPU)
100    // TODO: grovel through /proc or check cpuid on x86 and similar
101    // instructions on other architectures.
102#   if defined(_LIBCPP_WARNING)
103        _LIBCPP_WARNING("hardware_concurrency not yet implemented")
104#   else
105#       warning hardware_concurrency not yet implemented
106#   endif
107    return 0;  // Means not computable [thread.thread.static]
108#endif  // defined(CTL_HW) && defined(HW_NCPU)
109}
110
111namespace this_thread
112{
113
114void
115sleep_for(const chrono::nanoseconds& ns)
116{
117    if (ns > chrono::nanoseconds::zero())
118    {
119        __libcpp_thread_sleep_for(ns);
120    }
121}
122
123}  // this_thread
124
125__thread_specific_ptr<__thread_struct>&
126__thread_local_data()
127{
128    static __thread_specific_ptr<__thread_struct> __p;
129    return __p;
130}
131
132// __thread_struct_imp
133
134template <class T>
135class _LIBCPP_HIDDEN __hidden_allocator
136{
137public:
138    typedef T  value_type;
139
140    T* allocate(size_t __n)
141        {return static_cast<T*>(::operator new(__n * sizeof(T)));}
142    void deallocate(T* __p, size_t) {::operator delete(static_cast<void*>(__p));}
143
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;
153
154    _AsyncStates async_states_;
155    _Notify notify_;
156
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
163    void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
164    void __make_ready_at_thread_exit(__assoc_sub_state* __s);
165};
166
167__thread_struct_imp::~__thread_struct_imp()
168{
169    for (_Notify::iterator i = notify_.begin(), e = notify_.end();
170            i != e; ++i)
171    {
172        i->second->unlock();
173        i->first->notify_all();
174    }
175    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
184__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
190__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
209__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
215__thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
216{
217    __p_->__make_ready_at_thread_exit(__s);
218}
219
220_LIBCPP_END_NAMESPACE_STD
221
222#endif // !_LIBCPP_HAS_NO_THREADS
223