contrib/libc++/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 "__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__))
  28 # include <unistd.h>
  29 #endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
  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 // defined(_LIBCPP_WIN32API)
  38
  39 _LIBCPP_BEGIN_NAMESPACE_STD
  40
  41 thread::~thread()
  42 {
  43     if (__t_ != 0)
  44         terminate();
  45 }
  46
  47 void
  48 thread::join()
  49 {
  50     int ec = EINVAL;
  51     if (__t_ != 0)
  52     {
  53         ec = __libcpp_thread_join(&__t_);
  54         if (ec == 0)
  55             __t_ = 0;
  56     }
  57
  58     if (ec)
  59         __throw_system_error(ec, "thread::join failed");
  60 }
  61
  62 void
  63 thread::detach()
  64 {
  65     int ec = EINVAL;
  66     if (__t_ != 0)
  67     {
  68         ec = __libcpp_thread_detach(&__t_);
  69         if (ec == 0)
  70             __t_ = 0;
  71     }
  72
  73     if (ec)
  74         __throw_system_error(ec, "thread::detach failed");
  75 }
  76
  77 unsigned
  78 thread::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(_MSC_VER) && ! defined(__clang__)
 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
 111 namespace this_thread
 112 {
 113
 114 void
 115 sleep_for(const chrono::nanoseconds& ns)
 116 {
 117     using namespace chrono;
 118     if (ns > nanoseconds::zero())
 119     {
 120 #if defined(_LIBCPP_WIN32API)
 121         milliseconds ms = duration_cast<milliseconds>(ns);
 122         if (ms.count() == 0 || ns > duration_cast<nanoseconds>(ms))
 123           ++ms;
 124         Sleep(ms.count());
 125 #else
 126         seconds s = duration_cast<seconds>(ns);
 127         timespec ts;
 128         typedef decltype(ts.tv_sec) ts_sec;
 129         _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
 130         if (s.count() < ts_sec_max)
 131         {
 132             ts.tv_sec = static_cast<ts_sec>(s.count());
 133             ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((ns-s).count());
 134         }
 135         else
 136         {
 137             ts.tv_sec = ts_sec_max;
 138             ts.tv_nsec = giga::num - 1;
 139         }
 140
 141         while (nanosleep(&ts, &ts) == -1 && errno == EINTR)
 142             ;
 143 #endif
 144     }
 145 }
 146
 147 }  // this_thread
 148
 149 __thread_specific_ptr<__thread_struct>&
 150 __thread_local_data()
 151 {
 152     static __thread_specific_ptr<__thread_struct> __p;
 153     return __p;
 154 }
 155
 156 // __thread_struct_imp
 157
 158 template <class T>
 159 class _LIBCPP_HIDDEN __hidden_allocator
 160 {
 161 public:
 162     typedef T  value_type;
 163
 164     T* allocate(size_t __n)
 165         {return static_cast<T*>(::operator new(__n * sizeof(T)));}
 166     void deallocate(T* __p, size_t) {::operator delete(static_cast<void*>(__p));}
 167
 168     size_t max_size() const {return size_t(~0) / sizeof(T);}
 169 };
 170
 171 class _LIBCPP_HIDDEN __thread_struct_imp
 172 {
 173     typedef vector<__assoc_sub_state*,
 174                           __hidden_allocator<__assoc_sub_state*> > _AsyncStates;
 175     typedef vector<pair<condition_variable*, mutex*>,
 176                __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify;
 177
 178     _AsyncStates async_states_;
 179     _Notify notify_;
 180
 181     __thread_struct_imp(const __thread_struct_imp&);
 182     __thread_struct_imp& operator=(const __thread_struct_imp&);
 183 public:
 184     __thread_struct_imp() {}
 185     ~__thread_struct_imp();
 186
 187     void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
 188     void __make_ready_at_thread_exit(__assoc_sub_state* __s);
 189 };
 190
 191 __thread_struct_imp::~__thread_struct_imp()
 192 {
 193     for (_Notify::iterator i = notify_.begin(), e = notify_.end();
 194             i != e; ++i)
 195     {
 196         i->second->unlock();
 197         i->first->notify_all();
 198     }
 199     for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end();
 200             i != e; ++i)
 201     {
 202         (*i)->__make_ready();
 203         (*i)->__release_shared();
 204     }
 205 }
 206
 207 void
 208 __thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
 209 {
 210     notify_.push_back(pair<condition_variable*, mutex*>(cv, m));
 211 }
 212
 213 void
 214 __thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s)
 215 {
 216     async_states_.push_back(__s);
 217     __s->__add_shared();
 218 }
 219
 220 // __thread_struct
 221
 222 __thread_struct::__thread_struct()
 223     : __p_(new __thread_struct_imp)
 224 {
 225 }
 226
 227 __thread_struct::~__thread_struct()
 228 {
 229     delete __p_;
 230 }
 231
 232 void
 233 __thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
 234 {
 235     __p_->notify_all_at_thread_exit(cv, m);
 236 }
 237
 238 void
 239 __thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
 240 {
 241     __p_->__make_ready_at_thread_exit(__s);
 242 }
 243
 244 _LIBCPP_END_NAMESPACE_STD
 245
 246 #endif // !_LIBCPP_HAS_NO_THREADS