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 "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
  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 #else
  40     (void)ec;
  41 #endif  // _LIBCPP_NO_EXCEPTIONS
  42     __t_ = 0;
  43 }
  44
  45 void
  46 thread::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
  61 unsigned
  62 thread::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
  86 namespace this_thread
  87 {
  88
  89 void
  90 sleep_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
 124 template <class T>
 125 class _LIBCPP_HIDDEN __hidden_allocator
 126 {
 127 public:
 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
 137 class _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&);
 149 public:
 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
 173 void
 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
 179 void
 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
 198 void
 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
 204 void
 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