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