1 // -*- C++ -*- header.
2
3 // Copyright (C) 2020-2022 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file bits/semaphore_base.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{semaphore}
28 */
29
30 #ifndef _GLIBCXX_SEMAPHORE_BASE_H
31 #define _GLIBCXX_SEMAPHORE_BASE_H 1
32
33 #pragma GCC system_header
34
35 #include <bits/atomic_base.h>
36 #include <bits/chrono.h>
37 #if __cpp_lib_atomic_wait
38 #include <bits/atomic_timed_wait.h>
39 #include <ext/numeric_traits.h>
40 #endif // __cpp_lib_atomic_wait
41
42 #ifdef _GLIBCXX_HAVE_POSIX_SEMAPHORE
43 # include <cerrno> // errno, EINTR, EAGAIN etc.
44 # include <limits.h> // SEM_VALUE_MAX
45 # include <semaphore.h> // sem_t, sem_init, sem_wait, sem_post etc.
46 #endif
47
_GLIBCXX_VISIBILITY(default)48 namespace std _GLIBCXX_VISIBILITY(default)
49 {
50 _GLIBCXX_BEGIN_NAMESPACE_VERSION
51
52 #ifdef _GLIBCXX_HAVE_POSIX_SEMAPHORE
53 struct __platform_semaphore
54 {
55 using __clock_t = chrono::system_clock;
56 #ifdef SEM_VALUE_MAX
57 static constexpr ptrdiff_t _S_max = SEM_VALUE_MAX;
58 #else
59 static constexpr ptrdiff_t _S_max = _POSIX_SEM_VALUE_MAX;
60 #endif
61
62 explicit __platform_semaphore(ptrdiff_t __count) noexcept
63 {
64 sem_init(&_M_semaphore, 0, __count);
65 }
66
67 __platform_semaphore(const __platform_semaphore&) = delete;
68 __platform_semaphore& operator=(const __platform_semaphore&) = delete;
69
70 ~__platform_semaphore()
71 { sem_destroy(&_M_semaphore); }
72
73 _GLIBCXX_ALWAYS_INLINE void
74 _M_acquire() noexcept
75 {
76 for (;;)
77 {
78 auto __err = sem_wait(&_M_semaphore);
79 if (__err && (errno == EINTR))
80 continue;
81 else if (__err)
82 std::__terminate();
83 else
84 break;
85 }
86 }
87
88 _GLIBCXX_ALWAYS_INLINE bool
89 _M_try_acquire() noexcept
90 {
91 for (;;)
92 {
93 auto __err = sem_trywait(&_M_semaphore);
94 if (__err && (errno == EINTR))
95 continue;
96 else if (__err && (errno == EAGAIN))
97 return false;
98 else if (__err)
99 std::__terminate();
100 else
101 break;
102 }
103 return true;
104 }
105
106 _GLIBCXX_ALWAYS_INLINE void
107 _M_release(std::ptrdiff_t __update) noexcept
108 {
109 for(; __update != 0; --__update)
110 {
111 auto __err = sem_post(&_M_semaphore);
112 if (__err)
113 std::__terminate();
114 }
115 }
116
117 bool
118 _M_try_acquire_until_impl(const chrono::time_point<__clock_t>& __atime)
119 noexcept
120 {
121
122 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
123 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
124
125 struct timespec __ts =
126 {
127 static_cast<std::time_t>(__s.time_since_epoch().count()),
128 static_cast<long>(__ns.count())
129 };
130
131 for (;;)
132 {
133 if (auto __err = sem_timedwait(&_M_semaphore, &__ts))
134 {
135 if (errno == EINTR)
136 continue;
137 else if (errno == ETIMEDOUT || errno == EINVAL)
138 return false;
139 else
140 std::__terminate();
141 }
142 else
143 break;
144 }
145 return true;
146 }
147
148 template<typename _Clock, typename _Duration>
149 bool
150 _M_try_acquire_until(const chrono::time_point<_Clock,
151 _Duration>& __atime) noexcept
152 {
153 if constexpr (std::is_same_v<__clock_t, _Clock>)
154 {
155 return _M_try_acquire_until_impl(__atime);
156 }
157 else
158 {
159 const typename _Clock::time_point __c_entry = _Clock::now();
160 const auto __s_entry = __clock_t::now();
161 const auto __delta = __atime - __c_entry;
162 const auto __s_atime = __s_entry + __delta;
163 if (_M_try_acquire_until_impl(__s_atime))
164 return true;
165
166 // We got a timeout when measured against __clock_t but
167 // we need to check against the caller-supplied clock
168 // to tell whether we should return a timeout.
169 return (_Clock::now() < __atime);
170 }
171 }
172
173 template<typename _Rep, typename _Period>
174 _GLIBCXX_ALWAYS_INLINE bool
175 _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
176 noexcept
177 { return _M_try_acquire_until(__clock_t::now() + __rtime); }
178
179 private:
180 sem_t _M_semaphore;
181 };
182 #endif // _GLIBCXX_HAVE_POSIX_SEMAPHORE
183
184 #if __cpp_lib_atomic_wait
185 struct __atomic_semaphore
186 {
187 static constexpr ptrdiff_t _S_max = __gnu_cxx::__int_traits<int>::__max;
188 explicit __atomic_semaphore(__detail::__platform_wait_t __count) noexcept
189 : _M_counter(__count)
190 {
191 __glibcxx_assert(__count >= 0 && __count <= _S_max);
192 }
193
194 __atomic_semaphore(const __atomic_semaphore&) = delete;
195 __atomic_semaphore& operator=(const __atomic_semaphore&) = delete;
196
197 static _GLIBCXX_ALWAYS_INLINE bool
198 _S_do_try_acquire(__detail::__platform_wait_t* __counter) noexcept
199 {
200 auto __old = __atomic_impl::load(__counter, memory_order::acquire);
201 if (__old == 0)
202 return false;
203
204 return __atomic_impl::compare_exchange_strong(__counter,
205 __old, __old - 1,
206 memory_order::acquire,
207 memory_order::relaxed);
208 }
209
210 _GLIBCXX_ALWAYS_INLINE void
211 _M_acquire() noexcept
212 {
213 auto const __pred =
214 [this] { return _S_do_try_acquire(&this->_M_counter); };
215 std::__atomic_wait_address_bare(&_M_counter, __pred);
216 }
217
218 bool
219 _M_try_acquire() noexcept
220 {
221 auto const __pred =
222 [this] { return _S_do_try_acquire(&this->_M_counter); };
223 return std::__detail::__atomic_spin(__pred);
224 }
225
226 template<typename _Clock, typename _Duration>
227 _GLIBCXX_ALWAYS_INLINE bool
228 _M_try_acquire_until(const chrono::time_point<_Clock,
229 _Duration>& __atime) noexcept
230 {
231 auto const __pred =
232 [this] { return _S_do_try_acquire(&this->_M_counter); };
233
234 return __atomic_wait_address_until_bare(&_M_counter, __pred, __atime);
235 }
236
237 template<typename _Rep, typename _Period>
238 _GLIBCXX_ALWAYS_INLINE bool
239 _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
240 noexcept
241 {
242 auto const __pred =
243 [this] { return _S_do_try_acquire(&this->_M_counter); };
244
245 return __atomic_wait_address_for_bare(&_M_counter, __pred, __rtime);
246 }
247
248 _GLIBCXX_ALWAYS_INLINE void
249 _M_release(ptrdiff_t __update) noexcept
250 {
251 if (0 < __atomic_impl::fetch_add(&_M_counter, __update, memory_order_release))
252 return;
253 if (__update > 1)
254 __atomic_notify_address_bare(&_M_counter, true);
255 else
256 __atomic_notify_address_bare(&_M_counter, true);
257 // FIXME - Figure out why this does not wake a waiting thread
258 // __atomic_notify_address_bare(&_M_counter, false);
259 }
260
261 private:
262 alignas(__detail::__platform_wait_alignment)
263 __detail::__platform_wait_t _M_counter;
264 };
265 #endif // __cpp_lib_atomic_wait
266
267 // Note: the _GLIBCXX_USE_POSIX_SEMAPHORE macro can be used to force the
268 // use of Posix semaphores (sem_t). Doing so however, alters the ABI.
269 #if defined __cpp_lib_atomic_wait && !_GLIBCXX_USE_POSIX_SEMAPHORE
270 using __semaphore_impl = __atomic_semaphore;
271 #elif _GLIBCXX_HAVE_POSIX_SEMAPHORE
272 using __semaphore_impl = __platform_semaphore;
273 #endif
274
275 _GLIBCXX_END_NAMESPACE_VERSION
276 } // namespace std
277 #endif // _GLIBCXX_SEMAPHORE_BASE_H
278