1// -*- C++ -*-
2//===---------------------- condition_variable ----------------------------===//
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_CONDITION_VARIABLE
12#define _LIBCPP_CONDITION_VARIABLE
13
14/*
15    condition_variable synopsis
16
17namespace std
18{
19
20enum class cv_status { no_timeout, timeout };
21
22class condition_variable
23{
24public:
25    condition_variable();
26    ~condition_variable();
27
28    condition_variable(const condition_variable&) = delete;
29    condition_variable& operator=(const condition_variable&) = delete;
30
31    void notify_one() noexcept;
32    void notify_all() noexcept;
33
34    void wait(unique_lock<mutex>& lock);
35    template <class Predicate>
36        void wait(unique_lock<mutex>& lock, Predicate pred);
37
38    template <class Clock, class Duration>
39        cv_status
40        wait_until(unique_lock<mutex>& lock,
41                   const chrono::time_point<Clock, Duration>& abs_time);
42
43    template <class Clock, class Duration, class Predicate>
44        bool
45        wait_until(unique_lock<mutex>& lock,
46                   const chrono::time_point<Clock, Duration>& abs_time,
47                   Predicate pred);
48
49    template <class Rep, class Period>
50        cv_status
51        wait_for(unique_lock<mutex>& lock,
52                 const chrono::duration<Rep, Period>& rel_time);
53
54    template <class Rep, class Period, class Predicate>
55        bool
56        wait_for(unique_lock<mutex>& lock,
57                 const chrono::duration<Rep, Period>& rel_time,
58                 Predicate pred);
59
60    typedef pthread_cond_t* native_handle_type;
61    native_handle_type native_handle();
62};
63
64void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
65
66class condition_variable_any
67{
68public:
69    condition_variable_any();
70    ~condition_variable_any();
71
72    condition_variable_any(const condition_variable_any&) = delete;
73    condition_variable_any& operator=(const condition_variable_any&) = delete;
74
75    void notify_one() noexcept;
76    void notify_all() noexcept;
77
78    template <class Lock>
79        void wait(Lock& lock);
80    template <class Lock, class Predicate>
81        void wait(Lock& lock, Predicate pred);
82
83    template <class Lock, class Clock, class Duration>
84        cv_status
85        wait_until(Lock& lock,
86                   const chrono::time_point<Clock, Duration>& abs_time);
87
88    template <class Lock, class Clock, class Duration, class Predicate>
89        bool
90        wait_until(Lock& lock,
91                   const chrono::time_point<Clock, Duration>& abs_time,
92                   Predicate pred);
93
94    template <class Lock, class Rep, class Period>
95        cv_status
96        wait_for(Lock& lock,
97                 const chrono::duration<Rep, Period>& rel_time);
98
99    template <class Lock, class Rep, class Period, class Predicate>
100        bool
101        wait_for(Lock& lock,
102                 const chrono::duration<Rep, Period>& rel_time,
103                 Predicate pred);
104};
105
106}  // std
107
108*/
109
110#include <__config>
111#include <__mutex_base>
112#include <memory>
113
114#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
115#pragma GCC system_header
116#endif
117
118#if !_LIBCPP_SINGLE_THREADED
119
120_LIBCPP_BEGIN_NAMESPACE_STD
121
122class _LIBCPP_TYPE_VIS condition_variable_any
123{
124    condition_variable __cv_;
125    shared_ptr<mutex>  __mut_;
126public:
127    condition_variable_any();
128
129    void notify_one() _NOEXCEPT;
130    void notify_all() _NOEXCEPT;
131
132    template <class _Lock>
133        void wait(_Lock& __lock);
134    template <class _Lock, class _Predicate>
135        void wait(_Lock& __lock, _Predicate __pred);
136
137    template <class _Lock, class _Clock, class _Duration>
138        cv_status
139        wait_until(_Lock& __lock,
140                   const chrono::time_point<_Clock, _Duration>& __t);
141
142    template <class _Lock, class _Clock, class _Duration, class _Predicate>
143        bool
144        wait_until(_Lock& __lock,
145                   const chrono::time_point<_Clock, _Duration>& __t,
146                   _Predicate __pred);
147
148    template <class _Lock, class _Rep, class _Period>
149        cv_status
150        wait_for(_Lock& __lock,
151                 const chrono::duration<_Rep, _Period>& __d);
152
153    template <class _Lock, class _Rep, class _Period, class _Predicate>
154        bool
155        wait_for(_Lock& __lock,
156                 const chrono::duration<_Rep, _Period>& __d,
157                 _Predicate __pred);
158};
159
160inline _LIBCPP_INLINE_VISIBILITY
161condition_variable_any::condition_variable_any()
162    : __mut_(make_shared<mutex>()) {}
163
164inline _LIBCPP_INLINE_VISIBILITY
165void
166condition_variable_any::notify_one() _NOEXCEPT
167{
168    {lock_guard<mutex> __lx(*__mut_);}
169    __cv_.notify_one();
170}
171
172inline _LIBCPP_INLINE_VISIBILITY
173void
174condition_variable_any::notify_all() _NOEXCEPT
175{
176    {lock_guard<mutex> __lx(*__mut_);}
177    __cv_.notify_all();
178}
179
180struct __lock_external
181{
182    template <class _Lock>
183    void operator()(_Lock* __m) {__m->lock();}
184};
185
186template <class _Lock>
187void
188condition_variable_any::wait(_Lock& __lock)
189{
190    shared_ptr<mutex> __mut = __mut_;
191    unique_lock<mutex> __lk(*__mut);
192    __lock.unlock();
193    unique_ptr<_Lock, __lock_external> __lxx(&__lock);
194    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
195    __cv_.wait(__lk);
196}  // __mut_.unlock(), __lock.lock()
197
198template <class _Lock, class _Predicate>
199inline _LIBCPP_INLINE_VISIBILITY
200void
201condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
202{
203    while (!__pred())
204        wait(__lock);
205}
206
207template <class _Lock, class _Clock, class _Duration>
208cv_status
209condition_variable_any::wait_until(_Lock& __lock,
210                                   const chrono::time_point<_Clock, _Duration>& __t)
211{
212    shared_ptr<mutex> __mut = __mut_;
213    unique_lock<mutex> __lk(*__mut);
214    __lock.unlock();
215    unique_ptr<_Lock, __lock_external> __lxx(&__lock);
216    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
217    return __cv_.wait_until(__lk, __t);
218}  // __mut_.unlock(), __lock.lock()
219
220template <class _Lock, class _Clock, class _Duration, class _Predicate>
221inline _LIBCPP_INLINE_VISIBILITY
222bool
223condition_variable_any::wait_until(_Lock& __lock,
224                                   const chrono::time_point<_Clock, _Duration>& __t,
225                                   _Predicate __pred)
226{
227    while (!__pred())
228        if (wait_until(__lock, __t) == cv_status::timeout)
229            return __pred();
230    return true;
231}
232
233template <class _Lock, class _Rep, class _Period>
234inline _LIBCPP_INLINE_VISIBILITY
235cv_status
236condition_variable_any::wait_for(_Lock& __lock,
237                                 const chrono::duration<_Rep, _Period>& __d)
238{
239    return wait_until(__lock, chrono::steady_clock::now() + __d);
240}
241
242template <class _Lock, class _Rep, class _Period, class _Predicate>
243inline _LIBCPP_INLINE_VISIBILITY
244bool
245condition_variable_any::wait_for(_Lock& __lock,
246                                 const chrono::duration<_Rep, _Period>& __d,
247                                 _Predicate __pred)
248{
249    return wait_until(__lock, chrono::steady_clock::now() + __d,
250                      _VSTD::move(__pred));
251}
252
253_LIBCPP_FUNC_VIS
254void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
255
256_LIBCPP_END_NAMESPACE_STD
257
258#endif // !_LIBCPP_SINGLE_THREADED
259
260#endif  // _LIBCPP_CONDITION_VARIABLE
261