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 "thread" 11 #include "exception" 12 #include "vector" 13 #include "future" 14 #include "limits" 15 #include <sys/types.h> 16 #if !_WIN32 17 #if !__sun__ && !__linux__ 18 #include <sys/sysctl.h> 19 #else 20 #include <unistd.h> 21 #endif // !__sun__ && !__linux__ 22 #endif // !_WIN32 23 24 _LIBCPP_BEGIN_NAMESPACE_STD 25 26 thread::~thread() 27 { 28 if (__t_ != 0) 29 terminate(); 30 } 31 32 void 33 thread::join() 34 { 35 int ec = pthread_join(__t_, 0); 36 #ifndef _LIBCPP_NO_EXCEPTIONS 37 if (ec) 38 throw system_error(error_code(ec, system_category()), "thread::join failed"); 39 #endif // _LIBCPP_NO_EXCEPTIONS 40 __t_ = 0; 41 } 42 43 void 44 thread::detach() 45 { 46 int ec = EINVAL; 47 if (__t_ != 0) 48 { 49 ec = pthread_detach(__t_); 50 if (ec == 0) 51 __t_ = 0; 52 } 53 #ifndef _LIBCPP_NO_EXCEPTIONS 54 if (ec) 55 throw system_error(error_code(ec, system_category()), "thread::detach failed"); 56 #endif // _LIBCPP_NO_EXCEPTIONS 57 } 58 59 unsigned 60 thread::hardware_concurrency() _NOEXCEPT 61 { 62 #if defined(CTL_HW) && defined(HW_NCPU) 63 unsigned n; 64 int mib[2] = {CTL_HW, HW_NCPU}; 65 std::size_t s = sizeof(n); 66 sysctl(mib, 2, &n, &s, 0, 0); 67 return n; 68 #elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && defined(_SC_NPROCESSORS_ONLN) 69 long result = sysconf(_SC_NPROCESSORS_ONLN); 70 // sysconf returns -1 if the name is invalid, the option does not exist or 71 // does not have a definite limit. 72 if (result == -1) 73 return 0; 74 return result; 75 #else // defined(CTL_HW) && defined(HW_NCPU) 76 // TODO: grovel through /proc or check cpuid on x86 and similar 77 // instructions on other architectures. 78 return 0; // Means not computable [thread.thread.static] 79 #endif // defined(CTL_HW) && defined(HW_NCPU) 80 } 81 82 namespace this_thread 83 { 84 85 void 86 sleep_for(const chrono::nanoseconds& ns) 87 { 88 using namespace chrono; 89 if (ns > nanoseconds::zero()) 90 { 91 seconds s = duration_cast<seconds>(ns); 92 timespec ts; 93 typedef decltype(ts.tv_sec) ts_sec; 94 _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max(); 95 if (s.count() < ts_sec_max) 96 { 97 ts.tv_sec = static_cast<ts_sec>(s.count()); 98 ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((ns-s).count()); 99 } 100 else 101 { 102 ts.tv_sec = ts_sec_max; 103 ts.tv_nsec = giga::num - 1; 104 } 105 nanosleep(&ts, 0); 106 } 107 } 108 109 } // this_thread 110 111 __thread_specific_ptr<__thread_struct>& 112 __thread_local_data() 113 { 114 static __thread_specific_ptr<__thread_struct> __p; 115 return __p; 116 } 117 118 // __thread_struct_imp 119 120 template <class T> 121 class _LIBCPP_HIDDEN __hidden_allocator 122 { 123 public: 124 typedef T value_type; 125 126 T* allocate(size_t __n) 127 {return static_cast<T*>(::operator new(__n * sizeof(T)));} 128 void deallocate(T* __p, size_t) {::operator delete((void*)__p);} 129 130 size_t max_size() const {return size_t(~0) / sizeof(T);} 131 }; 132 133 class _LIBCPP_HIDDEN __thread_struct_imp 134 { 135 typedef vector<__assoc_sub_state*, 136 __hidden_allocator<__assoc_sub_state*> > _AsyncStates; 137 typedef vector<pair<condition_variable*, mutex*>, 138 __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify; 139 140 _AsyncStates async_states_; 141 _Notify notify_; 142 143 __thread_struct_imp(const __thread_struct_imp&); 144 __thread_struct_imp& operator=(const __thread_struct_imp&); 145 public: 146 __thread_struct_imp() {} 147 ~__thread_struct_imp(); 148 149 void notify_all_at_thread_exit(condition_variable* cv, mutex* m); 150 void __make_ready_at_thread_exit(__assoc_sub_state* __s); 151 }; 152 153 __thread_struct_imp::~__thread_struct_imp() 154 { 155 for (_Notify::iterator i = notify_.begin(), e = notify_.end(); 156 i != e; ++i) 157 { 158 i->second->unlock(); 159 i->first->notify_all(); 160 } 161 for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end(); 162 i != e; ++i) 163 { 164 (*i)->__make_ready(); 165 (*i)->__release_shared(); 166 } 167 } 168 169 void 170 __thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m) 171 { 172 notify_.push_back(pair<condition_variable*, mutex*>(cv, m)); 173 } 174 175 void 176 __thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s) 177 { 178 async_states_.push_back(__s); 179 __s->__add_shared(); 180 } 181 182 // __thread_struct 183 184 __thread_struct::__thread_struct() 185 : __p_(new __thread_struct_imp) 186 { 187 } 188 189 __thread_struct::~__thread_struct() 190 { 191 delete __p_; 192 } 193 194 void 195 __thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m) 196 { 197 __p_->notify_all_at_thread_exit(cv, m); 198 } 199 200 void 201 __thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s) 202 { 203 __p_->__make_ready_at_thread_exit(__s); 204 } 205 206 _LIBCPP_END_NAMESPACE_STD 207
