src/third_party/libc++/trunk/src/thread.cpp

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