// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_CONDITION_VARIABLE
#define _LIBCPP_CONDITION_VARIABLE
/*
condition_variable synopsis
namespace std
{
enum class cv_status { no_timeout, timeout };
class condition_variable
{
public:
condition_variable();
~condition_variable();
condition_variable(const condition_variable&) = delete;
condition_variable& operator=(const condition_variable&) = delete;
void notify_one() noexcept;
void notify_all() noexcept;
void wait(unique_lock<mutex>& lock);
template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred);
template <class Clock, class Duration>
cv_status
wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time);
template <class Clock, class Duration, class Predicate>
bool
wait_until(unique_lock<mutex>& lock,
const chrono::time_point<Clock, Duration>& abs_time,
Predicate pred);
template <class Rep, class Period>
cv_status
wait_for(unique_lock<mutex>& lock,
const chrono::duration<Rep, Period>& rel_time);
template <class Rep, class Period, class Predicate>
bool
wait_for(unique_lock<mutex>& lock,
const chrono::duration<Rep, Period>& rel_time,
Predicate pred);
typedef pthread_cond_t* native_handle_type;
native_handle_type native_handle();
};
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
class condition_variable_any
{
public:
condition_variable_any();
~condition_variable_any();
condition_variable_any(const condition_variable_any&) = delete;
condition_variable_any& operator=(const condition_variable_any&) = delete;
void notify_one() noexcept;
void notify_all() noexcept;
template <class Lock>
void wait(Lock& lock);
template <class Lock, class Predicate>
void wait(Lock& lock, Predicate pred);
template <class Lock, class Clock, class Duration>
cv_status
wait_until(Lock& lock,
const chrono::time_point<Clock, Duration>& abs_time);
template <class Lock, class Clock, class Duration, class Predicate>
bool
wait_until(Lock& lock,
const chrono::time_point<Clock, Duration>& abs_time,
Predicate pred);
template <class Lock, class Rep, class Period>
cv_status
wait_for(Lock& lock,
const chrono::duration<Rep, Period>& rel_time);
template <class Lock, class Rep, class Period, class Predicate>
bool
wait_for(Lock& lock,
const chrono::duration<Rep, Period>& rel_time,
Predicate pred);
// [thread.condvarany.intwait], interruptible waits
template <class Lock, class Predicate>
bool wait(Lock& lock, stop_token stoken, Predicate pred); // since C++20
template <class Lock, class Clock, class Duration, class Predicate>
bool wait_until(Lock& lock, stop_token stoken,
const chrono::time_point<Clock, Duration>& abs_time, Predicate pred); // since C++20
template <class Lock, class Rep, class Period, class Predicate>
bool wait_for(Lock& lock, stop_token stoken,
const chrono::duration<Rep, Period>& rel_time, Predicate pred); // since C++20
};
} // std
*/
#include <__chrono/duration.h>
#include <__chrono/steady_clock.h>
#include <__chrono/time_point.h>
#include <__condition_variable/condition_variable.h>
#include <__config>
#include <__memory/shared_ptr.h>
#include <__mutex/lock_guard.h>
#include <__mutex/mutex.h>
#include <__mutex/tag_types.h>
#include <__mutex/unique_lock.h>
#include <__stop_token/stop_callback.h>
#include <__stop_token/stop_token.h>
#include <__utility/move.h>
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
#ifndef _LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_EXPORTED_FROM_ABI condition_variable_any {
condition_variable __cv_;
shared_ptr<mutex> __mut_;
public:
_LIBCPP_HIDE_FROM_ABI condition_variable_any();
_LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT;
template <class _Lock>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS void wait(_Lock& __lock);
template <class _Lock, class _Predicate>
_LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock, _Predicate __pred);
template <class _Lock, class _Clock, class _Duration>
_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t);
template <class _Lock, class _Clock, class _Duration, class _Predicate>
bool _LIBCPP_HIDE_FROM_ABI
wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred);
template <class _Lock, class _Rep, class _Period>
cv_status _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d);
template <class _Lock, class _Rep, class _Period, class _Predicate>
bool _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
template <class _Lock, class _Predicate>
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
template <class _Lock, class _Clock, class _Duration, class _Predicate>
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_until(
_Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
template <class _Lock, class _Rep, class _Period, class _Predicate>
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
# endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
};
inline condition_variable_any::condition_variable_any() : __mut_(make_shared<mutex>()) {}
inline void condition_variable_any::notify_one() _NOEXCEPT {
{ lock_guard<mutex> __lx(*__mut_); }
__cv_.notify_one();
}
inline void condition_variable_any::notify_all() _NOEXCEPT {
{ lock_guard<mutex> __lx(*__mut_); }
__cv_.notify_all();
}
template <class _Lock>
struct __unlock_guard {
_Lock& __lock_;
_LIBCPP_HIDE_FROM_ABI __unlock_guard(_Lock& __lock) : __lock_(__lock) { __lock_.unlock(); }
_LIBCPP_HIDE_FROM_ABI ~__unlock_guard() _NOEXCEPT // turns exception to std::terminate
{
__lock_.lock();
}
__unlock_guard(const __unlock_guard&) = delete;
__unlock_guard& operator=(const __unlock_guard&) = delete;
};
template <class _Lock>
void condition_variable_any::wait(_Lock& __lock) {
shared_ptr<mutex> __mut = __mut_;
unique_lock<mutex> __lk(*__mut);
__unlock_guard<_Lock> __unlock(__lock);
lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
__cv_.wait(__lk);
} // __mut_.unlock(), __lock.lock()
template <class _Lock, class _Predicate>
inline void condition_variable_any::wait(_Lock& __lock, _Predicate __pred) {
while (!__pred())
wait(__lock);
}
template <class _Lock, class _Clock, class _Duration>
cv_status condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t) {
shared_ptr<mutex> __mut = __mut_;
unique_lock<mutex> __lk(*__mut);
__unlock_guard<_Lock> __unlock(__lock);
lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
return __cv_.wait_until(__lk, __t);
} // __mut_.unlock(), __lock.lock()
template <class _Lock, class _Clock, class _Duration, class _Predicate>
inline bool
condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) {
while (!__pred())
if (wait_until(__lock, __t) == cv_status::timeout)
return __pred();
return true;
}
template <class _Lock, class _Rep, class _Period>
inline cv_status condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d) {
return wait_until(__lock, chrono::steady_clock::now() + __d);
}
template <class _Lock, class _Rep, class _Period, class _Predicate>
inline bool
condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) {
return wait_until(__lock, chrono::steady_clock::now() + __d, std::move(__pred));
}
# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
template <class _Lock, class _Predicate>
bool condition_variable_any::wait(_Lock& __user_lock, stop_token __stoken, _Predicate __pred) {
if (__stoken.stop_requested())
return __pred();
// Per https://eel.is/c++draft/thread.condition.condvarany#general-note-2,
// we do need to take a copy of the shared pointer __mut_
// This ensures that a thread can call the destructor immediately after calling
// notify_all, without waiting all the wait calls.
// A thread can also safely call the destructor immediately after calling
// request_stop, as the call to request_stop would evaluate the callback,
// which accesses the internal condition variable, immediately on the same thread.
// In this situation, it is OK even without copying a shared ownership the internal
// condition variable. However, this needs the evaluation of stop_callback to
// happen-before the destruction.
// The spec only says "Only the notification to unblock the wait needs to happen
// before destruction". To make this work, we need to copy the shared ownership of
// the internal condition variable inside this function, which is not possible
// with the current ABI.
shared_ptr<mutex> __mut = __mut_;
stop_callback __cb(__stoken, [this] { notify_all(); });
while (true) {
if (__pred())
return true;
// We need to take the internal lock before checking stop_requested,
// so that the notification cannot come in between the stop_requested
// check and entering the wait.
// Note that the stop_callback takes the same internal lock before notifying
unique_lock<mutex> __internal_lock(*__mut);
if (__stoken.stop_requested())
break;
__unlock_guard<_Lock> __unlock(__user_lock);
unique_lock<mutex> __internal_lock2(
std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
__cv_.wait(__internal_lock2);
} // __internal_lock2.unlock(), __user_lock.lock()
return __pred();
}
template <class _Lock, class _Clock, class _Duration, class _Predicate>
bool condition_variable_any::wait_until(
_Lock& __user_lock,
stop_token __stoken,
const chrono::time_point<_Clock, _Duration>& __abs_time,
_Predicate __pred) {
if (__stoken.stop_requested())
return __pred();
shared_ptr<mutex> __mut = __mut_;
stop_callback __cb(__stoken, [this] { notify_all(); });
while (true) {
if (__pred())
return true;
unique_lock<mutex> __internal_lock(*__mut);
if (__stoken.stop_requested())
break;
__unlock_guard<_Lock> __unlock(__user_lock);
unique_lock<mutex> __internal_lock2(
std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
if (__cv_.wait_until(__internal_lock2, __abs_time) == cv_status::timeout)
break;
} // __internal_lock2.unlock(), __user_lock.lock()
return __pred();
}
template <class _Lock, class _Rep, class _Period, class _Predicate>
bool condition_variable_any::wait_for(
_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) {
return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred));
}
# endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
_LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
_LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic>
# include <concepts>
# include <cstdint>
# include <cstdlib>
# include <cstring>
# include <initializer_list>
# include <iosfwd>
# include <new>
# include <stdexcept>
# include <system_error>
# include <type_traits>
# include <typeinfo>
#endif
#endif // _LIBCPP_CONDITION_VARIABLE
Codebase Browser
llvm