Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/bits/semaphore_base.h
$ cat -n /usr/include/c++/13/bits/semaphore_base.h 1 // -*- C++ -*- header. 2 3 // Copyright (C) 2020-2023 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 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
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
