From 8cace3f05003c6cb4d38c36890055f03151c2ad4 Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Fri, 16 Oct 2026 02:39:56 +0800 Subject: Remove old code Signed-off-by: Richard Qin --- .../libcxx/include/c++/v1/condition_variable | 368 --------------------- 1 file changed, 368 deletions(-) delete mode 100644 third_party/libcxx/include/c++/v1/condition_variable (limited to 'third_party/libcxx/include/c++/v1/condition_variable') diff --git a/third_party/libcxx/include/c++/v1/condition_variable b/third_party/libcxx/include/c++/v1/condition_variable deleted file mode 100644 index d42a480..0000000 --- a/third_party/libcxx/include/c++/v1/condition_variable +++ /dev/null @@ -1,368 +0,0 @@ -// -*- 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& lock); - template - void wait(unique_lock& lock, Predicate pred); - - template - cv_status - wait_until(unique_lock& lock, - const chrono::time_point& abs_time); - - template - bool - wait_until(unique_lock& lock, - const chrono::time_point& abs_time, - Predicate pred); - - template - cv_status - wait_for(unique_lock& lock, - const chrono::duration& rel_time); - - template - bool - wait_for(unique_lock& lock, - const chrono::duration& 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 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 - void wait(Lock& lock); - template - void wait(Lock& lock, Predicate pred); - - template - cv_status - wait_until(Lock& lock, - const chrono::time_point& abs_time); - - template - bool - wait_until(Lock& lock, - const chrono::time_point& abs_time, - Predicate pred); - - template - cv_status - wait_for(Lock& lock, - const chrono::duration& rel_time); - - template - bool - wait_for(Lock& lock, - const chrono::duration& rel_time, - Predicate pred); - - // [thread.condvarany.intwait], interruptible waits - template - bool wait(Lock& lock, stop_token stoken, Predicate pred); // since C++20 - - template - bool wait_until(Lock& lock, stop_token stoken, - const chrono::time_point& abs_time, Predicate pred); // since C++20 - - template - bool wait_for(Lock& lock, stop_token stoken, - const chrono::duration& rel_time, Predicate pred); // since C++20 -}; - -} // std - -*/ - -#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) -# include <__cxx03/condition_variable> -#else -# 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 - -# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -# endif - -_LIBCPP_PUSH_MACROS -# include <__undef_macros> - -# if _LIBCPP_HAS_THREADS - -_LIBCPP_BEGIN_NAMESPACE_STD - -template -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; -}; - -class _LIBCPP_EXPORTED_FROM_ABI condition_variable_any { - condition_variable __cv_; - shared_ptr __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 - _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock) { - shared_ptr __mut = __mut_; - unique_lock __lk(*__mut); - __unlock_guard<_Lock> __unlock(__lock); - lock_guard > __lx(__lk, adopt_lock_t()); - __cv_.wait(__lk); - } // __mut_.unlock(), __lock.lock() - - template - _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock, _Predicate __pred); - - template - _LIBCPP_HIDE_FROM_ABI cv_status wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t) { - shared_ptr __mut = __mut_; - unique_lock __lk(*__mut); - __unlock_guard<_Lock> __unlock(__lock); - lock_guard > __lx(__lk, adopt_lock_t()); - return __cv_.wait_until(__lk, __t); - } // __mut_.unlock(), __lock.lock() - - template - bool _LIBCPP_HIDE_FROM_ABI - wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred); - - template - cv_status _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d); - - template - bool _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred); - -# if _LIBCPP_STD_VER >= 20 - - template - _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred); - - template - _LIBCPP_HIDE_FROM_ABI bool wait_until( - _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred); - - template - _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 -}; - -inline condition_variable_any::condition_variable_any() : __mut_(make_shared()) {} - -inline void condition_variable_any::notify_one() _NOEXCEPT { - { lock_guard __lx(*__mut_); } - __cv_.notify_one(); -} - -inline void condition_variable_any::notify_all() _NOEXCEPT { - { lock_guard __lx(*__mut_); } - __cv_.notify_all(); -} - -template -inline void condition_variable_any::wait(_Lock& __lock, _Predicate __pred) { - while (!__pred()) - wait(__lock); -} - -template -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 -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 -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 - -template -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 __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 __internal_lock(*__mut); - if (__stoken.stop_requested()) - break; - - __unlock_guard<_Lock> __unlock(__user_lock); - unique_lock __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 -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 __mut = __mut_; - stop_callback __cb(__stoken, [this] { notify_all(); }); - - while (true) { - if (__pred()) - return true; - - unique_lock __internal_lock(*__mut); - if (__stoken.stop_requested()) - break; - - __unlock_guard<_Lock> __unlock(__user_lock); - unique_lock __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 -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 - -_LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock); - -_LIBCPP_END_NAMESPACE_STD - -# endif // _LIBCPP_HAS_THREADS - -_LIBCPP_POP_MACROS - -# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# endif -#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) - -#endif // _LIBCPP_CONDITION_VARIABLE -- cgit v1.2.3