thread revision 249998 
1// -*- C++ -*-
2//===--------------------------- thread -----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_THREAD
12#define _LIBCPP_THREAD
13
14/*
15
16    thread synopsis
17
18#define __STDCPP_THREADS__ __cplusplus
19
20namespace std
21{
22
23class thread
24{
25public:
26    class id;
27    typedef pthread_t native_handle_type;
28
29    thread() noexcept;
30    template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
31    ~thread();
32
33    thread(const thread&) = delete;
34    thread(thread&& t) noexcept;
35
36    thread& operator=(const thread&) = delete;
37    thread& operator=(thread&& t) noexcept;
38
39    void swap(thread& t) noexcept;
40
41    bool joinable() const noexcept;
42    void join();
43    void detach();
44    id get_id() const noexcept;
45    native_handle_type native_handle();
46
47    static unsigned hardware_concurrency() noexcept;
48};
49
50void swap(thread& x, thread& y) noexcept;
51
52class thread::id
53{
54public:
55    id() noexcept;
56};
57
58bool operator==(thread::id x, thread::id y) noexcept;
59bool operator!=(thread::id x, thread::id y) noexcept;
60bool operator< (thread::id x, thread::id y) noexcept;
61bool operator<=(thread::id x, thread::id y) noexcept;
62bool operator> (thread::id x, thread::id y) noexcept;
63bool operator>=(thread::id x, thread::id y) noexcept;
64
65template<class charT, class traits>
66basic_ostream<charT, traits>&
67operator<<(basic_ostream<charT, traits>& out, thread::id id);
68
69namespace this_thread
70{
71
72thread::id get_id() noexcept;
73
74void yield() noexcept;
75
76template <class Clock, class Duration>
77void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
78
79template <class Rep, class Period>
80void sleep_for(const chrono::duration<Rep, Period>& rel_time);
81
82}  // this_thread
83
84}  // std
85
86*/
87
88#include <__config>
89#include <iosfwd>
90#include <__functional_base>
91#include <type_traits>
92#include <cstddef>
93#include <functional>
94#include <memory>
95#include <system_error>
96#include <chrono>
97#include <__mutex_base>
98#ifndef _LIBCPP_HAS_NO_VARIADICS
99#include <tuple>
100#endif
101#include <pthread.h>
102
103#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
104#pragma GCC system_header
105#endif
106
107#define __STDCPP_THREADS__ __cplusplus
108
109_LIBCPP_BEGIN_NAMESPACE_STD
110
111template <class _Tp>
112class __thread_specific_ptr
113{
114    pthread_key_t __key_;
115
116    __thread_specific_ptr(const __thread_specific_ptr&);
117    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
118
119    static void __at_thread_exit(void*);
120public:
121    typedef _Tp* pointer;
122
123    __thread_specific_ptr();
124    ~__thread_specific_ptr();
125
126    _LIBCPP_INLINE_VISIBILITY
127    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
128    _LIBCPP_INLINE_VISIBILITY
129    pointer operator*() const {return *get();}
130    _LIBCPP_INLINE_VISIBILITY
131    pointer operator->() const {return get();}
132    pointer release();
133    void reset(pointer __p = nullptr);
134};
135
136template <class _Tp>
137void
138__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
139{
140    delete static_cast<pointer>(__p);
141}
142
143template <class _Tp>
144__thread_specific_ptr<_Tp>::__thread_specific_ptr()
145{
146    int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
147#ifndef _LIBCPP_NO_EXCEPTIONS
148    if (__ec)
149        throw system_error(error_code(__ec, system_category()),
150                           "__thread_specific_ptr construction failed");
151#endif
152}
153
154template <class _Tp>
155__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
156{
157    pthread_key_delete(__key_);
158}
159
160template <class _Tp>
161typename __thread_specific_ptr<_Tp>::pointer
162__thread_specific_ptr<_Tp>::release()
163{
164    pointer __p = get();
165    pthread_setspecific(__key_, 0);
166    return __p;
167}
168
169template <class _Tp>
170void
171__thread_specific_ptr<_Tp>::reset(pointer __p)
172{
173    pointer __p_old = get();
174    pthread_setspecific(__key_, __p);
175    delete __p_old;
176}
177
178class _LIBCPP_TYPE_VIS thread;
179class _LIBCPP_TYPE_VIS __thread_id;
180
181namespace this_thread
182{
183
184_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
185
186}  // this_thread
187
188class _LIBCPP_TYPE_VIS __thread_id;
189template<> struct _LIBCPP_TYPE_VIS hash<__thread_id>;
190
191class _LIBCPP_TYPE_VIS __thread_id
192{
193    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
194    // NULL is the no-thread value on Darwin.  Someone needs to check
195    // on other platforms.  We assume 0 works everywhere for now.
196    pthread_t __id_;
197
198public:
199    _LIBCPP_INLINE_VISIBILITY
200    __thread_id() _NOEXCEPT : __id_(0) {}
201
202    friend _LIBCPP_INLINE_VISIBILITY
203        bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
204        {return __x.__id_ == __y.__id_;}
205    friend _LIBCPP_INLINE_VISIBILITY
206        bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
207        {return !(__x == __y);}
208    friend _LIBCPP_INLINE_VISIBILITY
209        bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
210        {return __x.__id_ < __y.__id_;}
211    friend _LIBCPP_INLINE_VISIBILITY
212        bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
213        {return !(__y < __x);}
214    friend _LIBCPP_INLINE_VISIBILITY
215        bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
216        {return   __y < __x ;}
217    friend _LIBCPP_INLINE_VISIBILITY
218        bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
219        {return !(__x < __y);}
220
221    template<class _CharT, class _Traits>
222    friend
223    _LIBCPP_INLINE_VISIBILITY
224    basic_ostream<_CharT, _Traits>&
225    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
226        {return __os << __id.__id_;}
227
228private:
229    _LIBCPP_INLINE_VISIBILITY
230    __thread_id(pthread_t __id) : __id_(__id) {}
231
232    friend __thread_id this_thread::get_id() _NOEXCEPT;
233    friend class _LIBCPP_TYPE_VIS thread;
234    friend struct _LIBCPP_TYPE_VIS hash<__thread_id>;
235};
236
237template<>
238struct _LIBCPP_TYPE_VIS hash<__thread_id>
239    : public unary_function<__thread_id, size_t>
240{
241    _LIBCPP_INLINE_VISIBILITY
242    size_t operator()(__thread_id __v) const
243    {
244        return hash<pthread_t>()(__v.__id_);
245    }
246};
247
248namespace this_thread
249{
250
251inline _LIBCPP_INLINE_VISIBILITY
252__thread_id
253get_id() _NOEXCEPT
254{
255    return pthread_self();
256}
257
258}  // this_thread
259
260class _LIBCPP_TYPE_VIS thread
261{
262    pthread_t __t_;
263
264    thread(const thread&);
265    thread& operator=(const thread&);
266public:
267    typedef __thread_id id;
268    typedef pthread_t native_handle_type;
269
270    _LIBCPP_INLINE_VISIBILITY
271    thread() _NOEXCEPT : __t_(0) {}
272#ifndef _LIBCPP_HAS_NO_VARIADICS
273    template <class _Fp, class ..._Args,
274              class = typename enable_if
275              <
276                   !is_same<typename decay<_Fp>::type, thread>::value
277              >::type
278             >
279        explicit thread(_Fp&& __f, _Args&&... __args);
280#else  // _LIBCPP_HAS_NO_VARIADICS
281    template <class _Fp> explicit thread(_Fp __f);
282#endif
283    ~thread();
284
285#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
286    _LIBCPP_INLINE_VISIBILITY
287    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
288    thread& operator=(thread&& __t) _NOEXCEPT;
289#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
290
291    _LIBCPP_INLINE_VISIBILITY
292    void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
293
294    _LIBCPP_INLINE_VISIBILITY
295    bool joinable() const _NOEXCEPT {return __t_ != 0;}
296    void join();
297    void detach();
298    _LIBCPP_INLINE_VISIBILITY
299    id get_id() const _NOEXCEPT {return __t_;}
300    _LIBCPP_INLINE_VISIBILITY
301    native_handle_type native_handle() _NOEXCEPT {return __t_;}
302
303    static unsigned hardware_concurrency() _NOEXCEPT;
304};
305
306class __assoc_sub_state;
307
308class _LIBCPP_HIDDEN __thread_struct_imp;
309
310class __thread_struct
311{
312    __thread_struct_imp* __p_;
313
314    __thread_struct(const __thread_struct&);
315    __thread_struct& operator=(const __thread_struct&);
316public:
317    __thread_struct();
318    ~__thread_struct();
319
320    void notify_all_at_thread_exit(condition_variable*, mutex*);
321    void __make_ready_at_thread_exit(__assoc_sub_state*);
322};
323
324__thread_specific_ptr<__thread_struct>& __thread_local_data();
325
326#ifndef _LIBCPP_HAS_NO_VARIADICS
327
328template <class _Fp, class ..._Args, size_t ..._Indices>
329inline _LIBCPP_INLINE_VISIBILITY
330void
331__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
332{
333    __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
334}
335
336template <class _Fp>
337void*
338__thread_proxy(void* __vp)
339{
340    __thread_local_data().reset(new __thread_struct);
341    std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
342    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
343    __thread_execute(*__p, _Index());
344    return nullptr;
345}
346
347template <class _Fp, class ..._Args,
348          class
349         >
350thread::thread(_Fp&& __f, _Args&&... __args)
351{
352    typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
353    _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
354                                __decay_copy(_VSTD::forward<_Args>(__args))...));
355    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
356    if (__ec == 0)
357        __p.release();
358    else
359        __throw_system_error(__ec, "thread constructor failed");
360}
361
362#else  // _LIBCPP_HAS_NO_VARIADICS
363
364template <class _Fp>
365void*
366__thread_proxy(void* __vp)
367{
368    __thread_local_data().reset(new __thread_struct);
369    std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
370    (*__p)();
371    return nullptr;
372}
373
374template <class _Fp>
375thread::thread(_Fp __f)
376{
377    std::unique_ptr<_Fp> __p(new _Fp(__f));
378    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
379    if (__ec == 0)
380        __p.release();
381    else
382        __throw_system_error(__ec, "thread constructor failed");
383}
384
385#endif  // _LIBCPP_HAS_NO_VARIADICS
386
387#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
388
389inline _LIBCPP_INLINE_VISIBILITY
390thread&
391thread::operator=(thread&& __t) _NOEXCEPT
392{
393    if (__t_ != 0)
394        terminate();
395    __t_ = __t.__t_;
396    __t.__t_ = 0;
397    return *this;
398}
399
400#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
401
402inline _LIBCPP_INLINE_VISIBILITY
403void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
404
405namespace this_thread
406{
407
408void sleep_for(const chrono::nanoseconds& ns);
409
410template <class _Rep, class _Period>
411void
412sleep_for(const chrono::duration<_Rep, _Period>& __d)
413{
414    using namespace chrono;
415    if (__d > duration<_Rep, _Period>::zero())
416    {
417        _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
418        nanoseconds __ns;
419        if (__d < _Max)
420        {
421            __ns = duration_cast<nanoseconds>(__d);
422            if (__ns < __d)
423                ++__ns;
424        }
425        else
426            __ns = nanoseconds::max();
427        sleep_for(__ns);
428    }
429}
430
431template <class _Clock, class _Duration>
432void
433sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
434{
435    using namespace chrono;
436    mutex __mut;
437    condition_variable __cv;
438    unique_lock<mutex> __lk(__mut);
439    while (_Clock::now() < __t)
440        __cv.wait_until(__lk, __t);
441}
442
443template <class _Duration>
444inline _LIBCPP_INLINE_VISIBILITY
445void
446sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
447{
448    using namespace chrono;
449    sleep_for(__t - steady_clock::now());
450}
451
452inline _LIBCPP_INLINE_VISIBILITY
453void yield() _NOEXCEPT {sched_yield();}
454
455}  // this_thread
456
457_LIBCPP_END_NAMESPACE_STD
458
459#endif  // _LIBCPP_THREAD
460