2020-01-29 Jonathan Wakely <jwakely@redhat.com>
+ PR libstdc++/92895
+ * include/std/stop_token (stop_token::stop_possible()): Call new
+ _M_stop_possible() function.
+ (stop_token::stop_requested()): Do not use stop_possible().
+ (stop_token::binary_semaphore): New class, as temporary stand-in for
+ std::binary_semaphore.
+ (stop_token::_Stop_cb::_M_callback): Add noexcept to type.
+ (stop_token::_Stop_cb::_M_destroyed, stop_token::_Stop_cb::_M_done):
+ New data members for symchronization with stop_callback destruction.
+ (stop_token::_Stop_cb::_Stop_cb): Make non-template.
+ (stop_token::_Stop_cb::_M_linked, stop_token::_Stop_cb::_S_execute):
+ Remove.
+ (stop_token::_Stop_cb::_M_run): New member function.
+ (stop_token::_Stop_state::_M_stopped, stop_token::_Stop_state::_M_mtx):
+ Remove.
+ (stop_token::_Stop_state::_M_owners): New data member to track
+ reference count for ownership.
+ (stop_token::_Stop_state::_M_value): New data member combining a
+ spinlock, the stop requested flag, and the reference count for
+ associated stop_source objects.
+ (stop_token::_Stop_state::_M_requester): New data member for
+ synchronization with stop_callback destruction.
+ (stop_token::_Stop_state::_M_stop_possible()): New member function.
+ (stop_token::_Stop_state::_M_stop_requested()): Inspect relevant bit
+ of _M_value.
+ (stop_token::_Stop_state::_M_add_owner)
+ (stop_token::_Stop_state::_M_release_ownership)
+ (stop_token::_Stop_state::_M_add_ssrc)
+ (stop_token::_Stop_state::_M_sub_ssrc): New member functions for
+ updating reference counts.
+ (stop_token::_Stop_state::_M_lock, stop_token::_Stop_state::_M_unlock)
+ (stop_token::_Stop_state::_M_lock, stop_token::_Stop_state::_M_unlock)
+ (stop_token::_Stop_state::_M_try_lock)
+ (stop_token::_Stop_state::_M_try_lock_and_stop)
+ (stop_token::_Stop_state::_M_do_try_lock): New member functions for
+ managing spinlock.
+ (stop_token::_Stop_state::_M_request_stop): Use atomic operations to
+ read and update state. Release lock while running callbacks. Use new
+ data members to synchronize with callback destruction.
+ (stop_token::_Stop_state::_M_remove_callback): Likewise.
+ (stop_token::_Stop_state::_M_register_callback): Use atomic operations
+ to read and update state.
+ (stop_token::_Stop_state_ref): Handle type to manage _Stop_state,
+ replacing shared_ptr.
+ (stop_source::stop_source(const stop_source&)): Update reference count.
+ (stop_source::operator=(const stop_source&)): Likewise.
+ (stop_source::~stop_source()): Likewise.
+ (stop_source::stop_source(stop_source&&)): Define as defaulted.
+ (stop_source::operator=(stop_source&&)): Establish postcondition on
+ parameter.
+ (stop_callback): Enforce preconditions on template parameter. Replace
+ base class with data member of new _Cb_impl type.
+ (stop_callback::stop_callback(const stop_token&, Cb&&))
+ (stop_callback::stop_callback(stop_token&&, Cb&&)): Fix TOCTTOU race.
+ (stop_callback::_Cb_impl): New type wrapping _Callback member and
+ defining the _S_execute member function.
+ * testsuite/30_threads/stop_token/stop_callback/deadlock-mt.cc: New
+ test.
+ * testsuite/30_threads/stop_token/stop_callback/deadlock.cc: New test.
+ * testsuite/30_threads/stop_token/stop_callback/destroy.cc: New test.
+ * testsuite/30_threads/stop_token/stop_callback/destructible_neg.cc:
+ New test.
+ * testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc: New
+ test.
+ * testsuite/30_threads/stop_token/stop_callback/invoke.cc: New test.
+ * testsuite/30_threads/stop_token/stop_source/assign.cc: New test.
+ * testsuite/30_threads/stop_token/stop_token/stop_possible.cc: New
+ test.
+
* libsupc++/compare (__detail::__3way_builtin_ptr_cmp): Use
three_way_comparable_with.
(__detail::__3way_cmp_with): Remove workaround for fixed bug.
#if __cplusplus > 201703L
#include <atomic>
-#include <bits/std_mutex.h>
-#include <ext/concurrence.h>
-#include <bits/unique_ptr.h>
-#include <bits/shared_ptr.h>
#ifdef _GLIBCXX_HAS_GTHREADS
# define __cpp_lib_jthread 201907L
+# include <bits/gthr.h>
+# if __has_include(<semaphore>)
+# include <semaphore>
+# endif
#endif
namespace std _GLIBCXX_VISIBILITY(default)
struct nostopstate_t { explicit nostopstate_t() = default; };
inline constexpr nostopstate_t nostopstate{};
+ class stop_source;
+
/// Allow testing whether a stop request has been made on a `stop_source`.
class stop_token
{
public:
stop_token() noexcept = default;
- stop_token(const stop_token& __other) noexcept = default;
- stop_token(stop_token&& __other) noexcept = default;
+ stop_token(const stop_token&) noexcept = default;
+ stop_token(stop_token&&) noexcept = default;
~stop_token() = default;
stop_token&
- operator=(const stop_token& __rhs) noexcept = default;
+ operator=(const stop_token&) noexcept = default;
stop_token&
- operator=(stop_token&& __rhs) noexcept = default;
+ operator=(stop_token&&) noexcept = default;
[[nodiscard]]
bool
stop_possible() const noexcept
{
- return static_cast<bool>(_M_state);
+ return static_cast<bool>(_M_state) && _M_state->_M_stop_possible();
}
[[nodiscard]]
bool
stop_requested() const noexcept
{
- return stop_possible() && _M_state->_M_stop_requested();
+ return static_cast<bool>(_M_state) && _M_state->_M_stop_requested();
}
void
template<typename _Callback>
friend class stop_callback;
- struct _Stop_cb
+ static void
+ _S_yield() noexcept
{
- void(*_M_callback)(_Stop_cb*);
- _Stop_cb* _M_prev = nullptr;
- _Stop_cb* _M_next = nullptr;
+#if defined __i386__ || defined __x86_64__
+ __builtin_ia32_pause();
+#elif defined _GLIBCXX_USE_SCHED_YIELD
+ __gthread_yield();
+#endif
+ }
- template<typename _Cb>
- _Stop_cb(_Cb&& __cb)
- : _M_callback(std::forward<_Cb>(__cb))
- { }
+#ifndef __cpp_lib_semaphore
+ // TODO: replace this with a real implementation of std::binary_semaphore
+ struct binary_semaphore
+ {
+ explicit binary_semaphore(int __d) : _M_counter(__d > 0) { }
- bool
- _M_linked() const noexcept
- {
- return (_M_prev != nullptr)
- || (_M_next != nullptr);
- }
+ void release() { _M_counter.fetch_add(1, memory_order::release); }
- static void
- _S_execute(_Stop_cb* __cb) noexcept
+ void acquire()
{
- __cb->_M_callback(__cb);
- __cb->_M_prev = __cb->_M_next = nullptr;
+ int __old = 1;
+ while (!_M_counter.compare_exchange_weak(__old, 0,
+ memory_order::acquire,
+ memory_order::relaxed))
+ {
+ __old = 1;
+ _S_yield();
+ }
}
+
+ atomic<int> _M_counter;
+ };
+#endif
+
+ struct _Stop_cb
+ {
+ using __cb_type = void(_Stop_cb*) noexcept;
+ __cb_type* _M_callback;
+ _Stop_cb* _M_prev = nullptr;
+ _Stop_cb* _M_next = nullptr;
+ bool* _M_destroyed = nullptr;
+ binary_semaphore _M_done{0};
+
+ [[__gnu__::__nonnull__]]
+ explicit
+ _Stop_cb(__cb_type* __cb)
+ : _M_callback(__cb)
+ { }
+
+ void _M_run() noexcept { _M_callback(this); }
};
struct _Stop_state_t
{
- std::atomic<bool> _M_stopped{false};
+ using value_type = uint32_t;
+ static constexpr value_type _S_stop_requested_bit = 1;
+ static constexpr value_type _S_locked_bit = 2;
+ static constexpr value_type _S_ssrc_counter_inc = 4;
+
+ std::atomic<value_type> _M_owners{1};
+ std::atomic<value_type> _M_value{_S_ssrc_counter_inc};
_Stop_cb* _M_head = nullptr;
-#ifdef _GLIBCXX_HAS_GTHREADS
- std::mutex _M_mtx;
+#if _GLIBCXX_HAS_GTHREADS
+ __gthread_t _M_requester;
#endif
_Stop_state_t() = default;
+ bool
+ _M_stop_possible() noexcept
+ {
+ // true if a stop request has already been made or there are still
+ // stop_source objects that would allow one to be made.
+ return _M_value.load(memory_order::acquire) & ~_S_locked_bit;
+ }
+
bool
_M_stop_requested() noexcept
{
- return _M_stopped;
+ return _M_value.load(memory_order::acquire) & _S_stop_requested_bit;
+ }
+
+ void
+ _M_add_owner() noexcept
+ {
+ _M_owners.fetch_add(1, memory_order::relaxed);
+ }
+
+ void
+ _M_release_ownership() noexcept
+ {
+ if (_M_owners.fetch_sub(1, memory_order::release) == 1)
+ delete this;
+ }
+
+ void
+ _M_add_ssrc() noexcept
+ {
+ _M_value.fetch_add(_S_ssrc_counter_inc, memory_order::relaxed);
+ }
+
+ void
+ _M_sub_ssrc() noexcept
+ {
+ _M_value.fetch_sub(_S_ssrc_counter_inc, memory_order::release);
+ }
+
+ // Obtain lock.
+ void
+ _M_lock() noexcept
+ {
+ // Can use relaxed loads to get the current value.
+ // The successful call to _M_try_lock is an acquire operation.
+ auto __old = _M_value.load(memory_order::relaxed);
+ while (!_M_try_lock(__old, memory_order::relaxed))
+ { }
+ }
+
+ // Precondition: calling thread holds the lock.
+ void
+ _M_unlock() noexcept
+ {
+ _M_value.fetch_sub(_S_locked_bit, memory_order::release);
}
bool
- _M_request_stop()
+ _M_request_stop() noexcept
{
- bool __stopped = false;
- if (_M_stopped.compare_exchange_strong(__stopped, true))
- {
-#ifdef _GLIBCXX_HAS_GTHREADS
- std::lock_guard<std::mutex> __lck{_M_mtx};
+ // obtain lock and set stop_requested bit
+ auto __old = _M_value.load(memory_order::acquire);
+ do
+ {
+ if (__old & _S_stop_requested_bit) // stop request already made
+ return false;
+ }
+ while (!_M_try_lock_and_stop(__old));
+
+#if _GLIBCXX_HAS_GTHREADS
+ _M_requester = __gthread_self();
#endif
- while (_M_head)
- {
- auto __p = _M_head;
- _M_head = _M_head->_M_next;
- _Stop_cb::_S_execute(__p);
- }
- return true;
- }
- return false;
+
+ while (_M_head)
+ {
+ bool __last_cb;
+ _Stop_cb* __cb = _M_head;
+ _M_head = _M_head->_M_next;
+ if (_M_head)
+ {
+ _M_head->_M_prev = nullptr;
+ __last_cb = false;
+ }
+ else
+ __last_cb = true;
+
+ // Allow other callbacks to be unregistered while __cb runs.
+ _M_unlock();
+
+ bool __destroyed = false;
+ __cb->_M_destroyed = &__destroyed;
+
+ // run callback
+ __cb->_M_run();
+
+ if (!__destroyed)
+ {
+ __cb->_M_destroyed = nullptr;
+#if _GLIBCXX_HAS_GTHREADS
+ // synchronize with destructor of stop_callback that owns *__cb
+ __cb->_M_done.release();
+#endif
+ }
+
+ // Avoid relocking if we already know there are no more callbacks.
+ if (__last_cb)
+ return true;
+
+ _M_lock();
+ }
+
+ _M_unlock();
+ return true;
}
+ [[__gnu__::__nonnull__]]
bool
- _M_register_callback(_Stop_cb* __cb)
+ _M_register_callback(_Stop_cb* __cb) noexcept
{
-#ifdef _GLIBCXX_HAS_GTHREADS
- std::lock_guard<std::mutex> __lck{_M_mtx};
-#endif
- if (_M_stopped)
- return false;
+ auto __old = _M_value.load(memory_order::acquire);
+ do
+ {
+ if (__old & _S_stop_requested_bit) // stop request already made
+ {
+ __cb->_M_run(); // run synchronously
+ return false;
+ }
+
+ if (__old < _S_ssrc_counter_inc) // no stop_source owns *this
+ // No need to register callback if no stop request can be made.
+ // Returning false also means the stop_callback does not share
+ // ownership of this state, but that's not observable.
+ return false;
+ }
+ while (!_M_try_lock(__old));
__cb->_M_next = _M_head;
if (_M_head)
_M_head->_M_prev = __cb;
}
_M_head = __cb;
+ _M_unlock();
return true;
}
+ // Called by ~stop_callback just before destroying *__cb.
+ [[__gnu__::__nonnull__]]
void
_M_remove_callback(_Stop_cb* __cb)
{
-#ifdef _GLIBCXX_HAS_GTHREADS
- std::lock_guard<std::mutex> __lck{_M_mtx};
-#endif
+ _M_lock();
+
if (__cb == _M_head)
{
_M_head = _M_head->_M_next;
if (_M_head)
- {
- _M_head->_M_prev = nullptr;
- }
+ _M_head->_M_prev = nullptr;
+ _M_unlock();
+ return;
}
- else if (!__cb->_M_linked())
- {
- return;
- }
- else
+ else if (__cb->_M_prev)
{
__cb->_M_prev->_M_next = __cb->_M_next;
if (__cb->_M_next)
- {
- __cb->_M_next->_M_prev = __cb->_M_prev;
- }
+ __cb->_M_next->_M_prev = __cb->_M_prev;
+ _M_unlock();
+ return;
}
+
+ _M_unlock();
+
+ // Callback is not in the list, so must have been removed by a call to
+ // _M_request_stop.
+
+#if _GLIBCXX_HAS_GTHREADS
+ // Despite appearances there is no data race on _M_requester. The only
+ // write to it happens before the callback is removed from the list,
+ // and removing it from the list happens before this read.
+ if (!__gthread_equal(_M_requester, __gthread_self()))
+ {
+ // Synchronize with completion of callback.
+ __cb->_M_done.acquire();
+ // Safe for ~stop_callback to destroy *__cb now.
+ return;
+ }
+#endif
+ if (__cb->_M_destroyed)
+ *__cb->_M_destroyed = true;
+ }
+
+ // Try to obtain the lock.
+ // Returns true if the lock is acquired (with memory order acquire).
+ // Otherwise, sets __curval = _M_value.load(__failure) and returns false.
+ // Might fail spuriously, so must be called in a loop.
+ bool
+ _M_try_lock(value_type& __curval,
+ memory_order __failure = memory_order::acquire) noexcept
+ {
+ return _M_do_try_lock(__curval, 0, memory_order::acquire, __failure);
+ }
+
+ // Try to obtain the lock to make a stop request.
+ // Returns true if the lock is acquired and the _S_stop_requested_bit is
+ // set (with memory order acq_rel so that other threads see the request).
+ // Otherwise, sets __curval = _M_value.load(memory_order::acquire) and
+ // returns false.
+ // Might fail spuriously, so must be called in a loop.
+ bool
+ _M_try_lock_and_stop(value_type& __curval) noexcept
+ {
+ return _M_do_try_lock(__curval, _S_stop_requested_bit,
+ memory_order::acq_rel, memory_order::acquire);
+ }
+
+ bool
+ _M_do_try_lock(value_type& __curval, value_type __newbits,
+ memory_order __success, memory_order __failure) noexcept
+ {
+ if (__curval & _S_locked_bit)
+ {
+ _S_yield();
+ __curval = _M_value.load(__failure);
+ return false;
+ }
+ __newbits |= _S_locked_bit;
+ return _M_value.compare_exchange_weak(__curval, __curval | __newbits,
+ __success, __failure);
+ }
+ };
+
+ struct _Stop_state_ref
+ {
+ _Stop_state_ref() = default;
+
+ explicit
+ _Stop_state_ref(const stop_source&)
+ : _M_ptr(new _Stop_state_t())
+ { }
+
+ _Stop_state_ref(const _Stop_state_ref& __other) noexcept
+ : _M_ptr(__other._M_ptr)
+ {
+ if (_M_ptr)
+ _M_ptr->_M_add_owner();
+ }
+
+ _Stop_state_ref(_Stop_state_ref&& __other) noexcept
+ : _M_ptr(__other._M_ptr)
+ {
+ __other._M_ptr = nullptr;
}
+
+ _Stop_state_ref&
+ operator=(const _Stop_state_ref& __other) noexcept
+ {
+ if (auto __ptr = __other._M_ptr; __ptr != _M_ptr)
+ {
+ if (__ptr)
+ __ptr->_M_add_owner();
+ if (_M_ptr)
+ _M_ptr->_M_release_ownership();
+ _M_ptr = __ptr;
+ }
+ return *this;
+ }
+
+ _Stop_state_ref&
+ operator=(_Stop_state_ref&& __other) noexcept
+ {
+ _Stop_state_ref(std::move(__other)).swap(*this);
+ return *this;
+ }
+
+ ~_Stop_state_ref()
+ {
+ if (_M_ptr)
+ _M_ptr->_M_release_ownership();
+ }
+
+ void
+ swap(_Stop_state_ref& __other) noexcept
+ { std::swap(_M_ptr, __other._M_ptr); }
+
+ explicit operator bool() const noexcept { return _M_ptr != nullptr; }
+
+ _Stop_state_t* operator->() const noexcept { return _M_ptr; }
+
+ friend bool
+ operator==(const _Stop_state_ref&, const _Stop_state_ref&) = default;
+
+ private:
+ _Stop_state_t* _M_ptr = nullptr;
};
- using _Stop_state = std::shared_ptr<_Stop_state_t>;
- _Stop_state _M_state;
+ _Stop_state_ref _M_state;
explicit
- stop_token(const _Stop_state& __state) noexcept
+ stop_token(const _Stop_state_ref& __state) noexcept
: _M_state{__state}
{ }
};
class stop_source
{
public:
- stop_source()
- : _M_state(std::make_shared<stop_token::_Stop_state_t>())
+ stop_source() : _M_state(*this)
{ }
explicit stop_source(std::nostopstate_t) noexcept
{ }
stop_source(const stop_source& __other) noexcept
- : _M_state(__other._M_state)
- { }
+ : _M_state(__other._M_state)
+ {
+ if (_M_state)
+ _M_state->_M_add_ssrc();
+ }
- stop_source(stop_source&& __other) noexcept
- : _M_state(std::move(__other._M_state))
- { }
+ stop_source(stop_source&&) noexcept = default;
stop_source&
- operator=(const stop_source& __rhs) noexcept
+ operator=(const stop_source& __other) noexcept
{
- if (_M_state != __rhs._M_state)
- _M_state = __rhs._M_state;
+ if (_M_state != __other._M_state)
+ {
+ stop_source __sink(std::move(*this));
+ _M_state = __other._M_state;
+ if (_M_state)
+ _M_state->_M_add_ssrc();
+ }
return *this;
}
stop_source&
- operator=(stop_source&& __rhs) noexcept
+ operator=(stop_source&&) noexcept = default;
+
+ ~stop_source()
{
- std::swap(_M_state, __rhs._M_state);
- return *this;
+ if (_M_state)
+ _M_state->_M_sub_ssrc();
}
[[nodiscard]]
bool
stop_requested() const noexcept
{
- return stop_possible() && _M_state->_M_stop_requested();
+ return static_cast<bool>(_M_state) && _M_state->_M_stop_requested();
}
bool
}
private:
- stop_token::_Stop_state _M_state;
+ stop_token::_Stop_state_ref _M_state;
};
/// A wrapper for callbacks to be run when a stop request is made.
template<typename _Callback>
class [[nodiscard]] stop_callback
- : private stop_token::_Stop_cb
{
+ static_assert(is_nothrow_destructible_v<_Callback>);
+ static_assert(is_invocable_v<_Callback>);
+
public:
using callback_type = _Callback;
explicit
stop_callback(const stop_token& __token, _Cb&& __cb)
noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
- : _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
+ : _M_cb(std::forward<_Cb>(__cb))
{
if (auto __state = __token._M_state)
{
- if (__state->_M_stop_requested())
- _S_execute(this); // ensures std::terminate on throw
- else if (__state->_M_register_callback(this))
+ if (__state->_M_register_callback(&_M_cb))
_M_state.swap(__state);
}
}
explicit
stop_callback(stop_token&& __token, _Cb&& __cb)
noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
- : _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
+ : _M_cb(std::forward<_Cb>(__cb))
{
if (auto& __state = __token._M_state)
{
- if (__state->_M_stop_requested())
- _S_execute(this); // ensures std::terminate on throw
- else if (__state->_M_register_callback(this))
+ if (__state->_M_register_callback(&_M_cb))
_M_state.swap(__state);
}
}
{
if (_M_state)
{
- _M_state->_M_remove_callback(this);
+ _M_state->_M_remove_callback(&_M_cb);
}
}
stop_callback& operator=(stop_callback&&) = delete;
private:
- _Callback _M_cb;
- stop_token::_Stop_state _M_state = nullptr;
-
- static void
- _S_execute(_Stop_cb* __that) noexcept
+ struct _Cb_impl : stop_token::_Stop_cb
{
- static_cast<stop_callback*>(__that)->_M_cb();
- }
+ template<typename _Cb>
+ explicit
+ _Cb_impl(_Cb&& __cb)
+ : _Stop_cb(&_S_execute),
+ _M_cb(std::forward<_Cb>(__cb))
+ { }
+
+ _Callback _M_cb;
+
+ [[__gnu__::__nonnull__]]
+ static void
+ _S_execute(_Stop_cb* __that) noexcept
+ {
+ _Callback& __cb = static_cast<_Cb_impl*>(__that)->_M_cb;
+ std::forward<_Callback>(__cb)();
+ }
+ };
+
+ _Cb_impl _M_cb;
+ stop_token::_Stop_state_ref _M_state;
};
template<typename _Callback>
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a -pthread" }
+// { dg-require-effective-target c++2a }
+// { dg-require-effective-target pthread }
+// { dg-require-gthreads "" }
+
+#include <stop_token>
+#include <memory>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ std::stop_source ssrc;
+ std::stop_token stok = ssrc.get_token();
+ using F = void(*)();
+ std::unique_ptr<std::stop_callback<F>> pcb;
+ auto dereg = [&pcb] { pcb.reset(); };
+ std::stop_callback cb1(stok, dereg);
+ pcb = std::make_unique<std::stop_callback<F>>(stok, []{});
+ std::stop_callback cb2(stok, dereg);
+
+ // PR libstdc++/92895
+ // Making a stop request runs the callbacks. Whichever of cb1 and cb2
+ // runs first will destroy *pcb, which will try to unregister it.
+ // This recursive access to the shared stop state within a callback must
+ // work without deadlock.
+ ssrc.request_stop();
+}
+
+int main()
+{
+ test01();
+}
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <stop_token>
+#include <memory>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ std::stop_source ssrc;
+ std::stop_token stok = ssrc.get_token();
+ using F = void(*)();
+ std::unique_ptr<std::stop_callback<F>> pcb;
+ auto dereg = [&pcb] { pcb.reset(); };
+ std::stop_callback cb1(stok, dereg);
+ pcb = std::make_unique<std::stop_callback<F>>(stok, []{});
+ std::stop_callback cb2(stok, dereg);
+
+ // PR libstdc++/92895
+ // Making a stop request runs the callbacks. Whichever of cb1 and cb2
+ // runs first will destroy *pcb, which will try to unregister it.
+ // This recursive access to the shared stop state within a callback must
+ // work without deadlock.
+ ssrc.request_stop();
+}
+
+int main()
+{
+ test01();
+}
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a -pthread" }
+// { dg-require-effective-target c++2a }
+// { dg-require-effective-target pthread }
+// { dg-require-gthreads "" }
+
+#include <stop_token>
+#include <atomic>
+#include <thread>
+#include <testsuite_hooks.h>
+
+struct F
+{
+ static std::atomic<int> stage;
+
+ F(int) { }
+
+ ~F()
+ {
+ // PR libstdc++/92895
+ // Callback function must not be destroyed while still executing.
+ VERIFY( stage == 4 );
+ }
+
+ void operator()() const noexcept
+ {
+ stage = 2; // trigger destructor of stop_callback that owns *this
+ while (stage == 2)
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ std::this_thread::sleep_for(std::chrono::milliseconds(500));
+ stage = 4; // destructor checks for this
+ }
+};
+
+std::atomic<int> F::stage{0};
+
+void
+test01()
+{
+ std::stop_source ssrc;
+ std::stop_token stok = ssrc.get_token();
+ std::thread t1([&ssrc] {
+ while (F::stage == 0)
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ ssrc.request_stop();
+ while (F::stage != 5)
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ });
+
+ std::thread t2([&ssrc] {
+ std::stop_callback<F> cb(ssrc.get_token(), 0);
+ F::stage = 1; // trigger stop request in other thread, which runs callback
+ while (F::stage == 1)
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ F::stage = 3;
+ // stop_callback destructor should block until callback completes
+ });
+
+ t2.join();
+ F::stage = 5; // allow first thread to exit
+ t1.join();
+}
+
+int main()
+{
+ test01();
+}
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <stop_token>
+
+struct F
+{
+ F();
+
+ void operator()() const { }
+
+private:
+ ~F();
+};
+
+auto
+test01(std::stop_token& tok, F& f)
+{
+ auto ok = sizeof(std::stop_callback<F&>);
+ auto bad = sizeof(std::stop_callback<F>); // { dg-error "here" }
+ return ok + bad;
+}
+
+struct G
+{
+ G();
+ ~G() noexcept(false);
+
+ void operator()() const { }
+};
+
+auto
+test02(std::stop_token& tok, G& g)
+{
+ auto ok = sizeof(std::stop_callback<G&>);
+ auto bad = sizeof(std::stop_callback<G>); // { dg-error "here" }
+ return ok + bad;
+}
+
+// { dg-error "static assertion failed" "" { target *-*-* } 0 }
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <stop_token>
+
+struct F
+{
+};
+
+auto
+test01(std::stop_token& tok, F& f)
+{
+ auto bad1 = sizeof(std::stop_callback<F&>); // { dg-error "here" }
+ auto bad2 = sizeof(std::stop_callback<F>); // { dg-error "here" }
+ return bad1 + bad2;
+}
+
+// { dg-error "static assertion failed" "" { target *-*-* } 0 }
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <stop_token>
+#include <testsuite_hooks.h>
+
+int lval[5];
+int rval[5];
+
+void
+test01()
+{
+ std::stop_source ssrc;
+ std::stop_token stok = ssrc.get_token();
+ struct F
+ {
+ void operator()() const & { ++lval[i]; }
+ void operator()() && { ++rval[i]; }
+
+ int i;
+ };
+ std::stop_callback<F> cb0(stok, F{0});
+ std::stop_callback<F> cb1(stok, F{1});
+ std::stop_callback<F> cb2(stok, F{2});
+ F f3{3};
+ std::stop_callback<F&> cb3(stok, f3);
+ std::stop_callback<const F> cb4(stok, F{4});
+
+ // PR libstdc++/92895
+ // Callback should be invoked with correct value category.
+ ssrc.request_stop();
+
+ VERIFY( lval[0] == 0 && lval[1] == 0 && lval[2] == 0 );
+ VERIFY( lval[3] == 1 );
+ VERIFY( lval[4] == 1 );
+ VERIFY( rval[0] == 1 );
+ VERIFY( rval[1] == 1 );
+ VERIFY( rval[2] == 1 );
+ VERIFY( rval[3] == 0 && rval[4] == 0 );
+}
+
+int main()
+{
+ test01();
+}
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <stop_token>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ std::stop_source src1, src2;
+ const std::stop_source orig1(src1);
+ VERIFY( src1 != src2 );
+ src1 = src2;
+ VERIFY( src1 == src2 );
+ VERIFY( src1 != orig1 );
+}
+
+void
+test02()
+{
+ std::stop_source src1, src2;
+ const std::stop_source orig1(src1), orig2(src2), src0(std::nostopstate);
+ src1 = std::move(src2);
+ VERIFY( src1 == orig2 );
+ VERIFY( src2 == src0 );
+ VERIFY( src1 != orig1 );
+ VERIFY( src0 != orig1 );
+}
+
+int main()
+{
+ test01();
+ test02();
+}
--- /dev/null
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <stop_token>
+#include <memory>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ std::stop_source ssrc;
+ std::stop_token tok = ssrc.get_token();
+ VERIFY(tok.stop_possible());
+
+ ssrc.request_stop();
+ VERIFY(tok.stop_possible());
+}
+
+void
+test02()
+{
+ std::stop_token tok = std::stop_source().get_token();
+ // PR libstdc++/92895
+ // stop_possible() is false when there is no associated stop_source
+ VERIFY(!tok.stop_possible());
+}
+
+int main()
+{
+ test01();
+ test02();
+}
projects / gcc.git / commitdiff