1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_SEMAPHORE 11#define _LIBCPP_SEMAPHORE 12 13/* 14 semaphore synopsis 15 16namespace std { 17 18template<ptrdiff_t least_max_value = implementation-defined> 19class counting_semaphore 20{ 21public: 22static constexpr ptrdiff_t max() noexcept; 23 24constexpr explicit counting_semaphore(ptrdiff_t desired); 25~counting_semaphore(); 26 27counting_semaphore(const counting_semaphore&) = delete; 28counting_semaphore& operator=(const counting_semaphore&) = delete; 29 30void release(ptrdiff_t update = 1); 31void acquire(); 32bool try_acquire() noexcept; 33template<class Rep, class Period> 34 bool try_acquire_for(const chrono::duration<Rep, Period>& rel_time); 35template<class Clock, class Duration> 36 bool try_acquire_until(const chrono::time_point<Clock, Duration>& abs_time); 37 38private: 39ptrdiff_t counter; // exposition only 40}; 41 42using binary_semaphore = counting_semaphore<1>; 43 44} 45 46*/ 47 48#include <__config> 49 50#ifdef _LIBCPP_HAS_NO_THREADS 51# error "<semaphore> is not supported since libc++ has been configured without support for threads." 52#endif 53 54#include <__assert> // all public C++ headers provide the assertion handler 55#include <__atomic/atomic_base.h> 56#include <__atomic/atomic_sync.h> 57#include <__atomic/memory_order.h> 58#include <__availability> 59#include <__chrono/time_point.h> 60#include <__thread/poll_with_backoff.h> 61#include <__thread/timed_backoff_policy.h> 62#include <__threading_support> 63#include <cstddef> 64#include <limits> 65#include <version> 66 67#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 68# pragma GCC system_header 69#endif 70 71_LIBCPP_PUSH_MACROS 72#include <__undef_macros> 73 74#if _LIBCPP_STD_VER >= 14 75 76_LIBCPP_BEGIN_NAMESPACE_STD 77 78/* 79 80__atomic_semaphore_base is the general-case implementation. 81It is a typical Dijkstra semaphore algorithm over atomics, wait and notify 82functions. It avoids contention against users' own use of those facilities. 83 84*/ 85 86# define _LIBCPP_SEMAPHORE_MAX (numeric_limits<ptrdiff_t>::max()) 87 88class __atomic_semaphore_base { 89 __atomic_base<ptrdiff_t> __a_; 90 91public: 92 _LIBCPP_HIDE_FROM_ABI constexpr explicit __atomic_semaphore_base(ptrdiff_t __count) : __a_(__count) {} 93 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) { 94 auto __old = __a_.fetch_add(__update, memory_order_release); 95 _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN( 96 __update <= _LIBCPP_SEMAPHORE_MAX - __old, "update is greater than the expected value"); 97 98 if (__old > 0) { 99 // Nothing to do 100 } else if (__update > 1) 101 __a_.notify_all(); 102 else 103 __a_.notify_one(); 104 } 105 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() { 106 auto const __test_fn = [this]() -> bool { 107 auto __old = __a_.load(memory_order_relaxed); 108 return (__old != 0) && __a_.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed); 109 }; 110 __cxx_atomic_wait(&__a_.__a_, __test_fn); 111 } 112 template <class _Rep, class _Period> 113 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool 114 try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) { 115 if (__rel_time == chrono::duration<_Rep, _Period>::zero()) 116 return try_acquire(); 117 auto const __test_fn = [this]() { return try_acquire(); }; 118 return std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time); 119 } 120 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() { 121 auto __old = __a_.load(memory_order_acquire); 122 while (true) { 123 if (__old == 0) 124 return false; 125 if (__a_.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed)) 126 return true; 127 } 128 } 129}; 130 131template <ptrdiff_t __least_max_value = _LIBCPP_SEMAPHORE_MAX> 132class counting_semaphore { 133 __atomic_semaphore_base __semaphore_; 134 135public: 136 static_assert(__least_max_value >= 0, "The least maximum value must be a positive number"); 137 138 static constexpr ptrdiff_t max() noexcept { return __least_max_value; } 139 140 _LIBCPP_HIDE_FROM_ABI constexpr explicit counting_semaphore(ptrdiff_t __count) : __semaphore_(__count) { 141 _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN( 142 __count >= 0, 143 "counting_semaphore::counting_semaphore(ptrdiff_t): counting_semaphore cannot be " 144 "initialized with a negative value"); 145 _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN( 146 __count <= max(), 147 "counting_semaphore::counting_semaphore(ptrdiff_t): counting_semaphore cannot be " 148 "initialized with a value greater than max()"); 149 } 150 ~counting_semaphore() = default; 151 152 counting_semaphore(const counting_semaphore&) = delete; 153 counting_semaphore& operator=(const counting_semaphore&) = delete; 154 155 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) { 156 _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "counting_semaphore:release called with a negative value"); 157 __semaphore_.release(__update); 158 } 159 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() { __semaphore_.acquire(); } 160 template <class _Rep, class _Period> 161 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool 162 try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) { 163 return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time)); 164 } 165 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() { return __semaphore_.try_acquire(); } 166 template <class _Clock, class _Duration> 167 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool 168 try_acquire_until(chrono::time_point<_Clock, _Duration> const& __abs_time) { 169 auto const __current = _Clock::now(); 170 if (__current >= __abs_time) 171 return try_acquire(); 172 else 173 return try_acquire_for(__abs_time - __current); 174 } 175}; 176 177using binary_semaphore = counting_semaphore<1>; 178 179_LIBCPP_END_NAMESPACE_STD 180 181#endif // _LIBCPP_STD_VER >= 14 182 183_LIBCPP_POP_MACROS 184 185#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 186# include <atomic> 187#endif 188 189#endif //_LIBCPP_SEMAPHORE 190