[gcc(refs/users/redi/heads/pr92895)] libstdc++: Fix conformance issues in <stop_token> (PR92895)
Jonathan Wakely
redi@gcc.gnu.org
Thu Jan 23 00:36:00 GMT 2020
https://gcc.gnu.org/g:bb66f690b212b1c12c1153b4ed996210971f4d8f
commit bb66f690b212b1c12c1153b4ed996210971f4d8f
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Wed Jan 22 14:09:56 2020 +0000
libstdc++: Fix conformance issues in <stop_token> (PR92895)
Replaces shared_ptr with _Stop_state_ref.
Replaces std::mutex with spinlock using one bit of a std::atomic<> that
also tracks whether a stop request has been made and how many
stop_source objects share ownership of the state.
TODO: see TODO comments in the header about callback synchronization
TODO: more tests, including verifying the following:
- try to test TOCTTOU race is fixed in stop_callback constructor.
Diff:
---
libstdc++-v3/include/std/stop_token | 408 ++++++++++++++++-----
.../stop_token/stop_callback/deadlock-mt.cc | 50 +++
.../stop_token/stop_callback/deadlock.cc | 48 +++
.../stop_token/stop_callback/destructible_neg.cc | 57 +++
.../stop_token/stop_callback/invocable_neg.cc | 35 ++
.../30_threads/stop_token/stop_callback/invoke.cc | 62 ++++
.../30_threads/stop_token/stop_source/assign.cc | 51 +++
.../stop_token/stop_token/stop_possible.cc | 49 +++
8 files changed, 660 insertions(+), 100 deletions(-)
diff --git a/libstdc++-v3/include/std/stop_token b/libstdc++-v3/include/std/stop_token
index e23d139..61c1867 100644
--- a/libstdc++-v3/include/std/stop_token
+++ b/libstdc++-v3/include/std/stop_token
@@ -32,15 +32,13 @@
#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>
#endif
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@@ -49,6 +47,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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
{
@@ -70,14 +70,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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
@@ -100,74 +100,154 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct _Stop_cb
{
- void(*_M_callback)(_Stop_cb*);
+ using __cb_type = void(_Stop_cb*) noexcept;
+ __cb_type* _M_callback;
_Stop_cb* _M_prev = nullptr;
_Stop_cb* _M_next = nullptr;
- template<typename _Cb>
- _Stop_cb(_Cb&& __cb)
- : _M_callback(std::forward<_Cb>(__cb))
- { }
-
- bool
- _M_linked() const noexcept
- {
- return (_M_prev != nullptr)
- || (_M_next != nullptr);
- }
+ [[__gnu__::__nonnull__]]
+ explicit
+ _Stop_cb(__cb_type* __cb)
+ : _M_callback(__cb)
+ { }
- static void
- _S_execute(_Stop_cb* __cb) noexcept
- {
- __cb->_M_callback(__cb);
- __cb->_M_prev = __cb->_M_next = nullptr;
- }
+ 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;
-#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 (even if stop request has already been made).
+ 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};
-#endif
- while (_M_head)
- {
- auto __p = _M_head;
- _M_head = _M_head->_M_next;
- _Stop_cb::_S_execute(__p);
- }
- return true;
- }
- return false;
+ // 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));
+
+ 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();
+
+ // run callback
+ // TODO: synchronize with owning stop_callback's destructor
+ __cb->_M_run();
+
+ // TODO: check if __cb is still accessible, might be destroyed
+ __cb->_M_prev = __cb->_M_next = nullptr;
+
+ // 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.
+ return true;
+ }
+ while (!_M_try_lock(__old));
__cb->_M_next = _M_head;
if (_M_head)
@@ -175,43 +255,152 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_head->_M_prev = __cb;
}
_M_head = __cb;
+ _M_unlock();
return true;
}
+ [[__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;
- }
- }
- else if (!__cb->_M_linked())
- {
- return;
+ _M_head->_M_prev = nullptr;
+ _M_unlock();
+ 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 be currently executing.
+ // TODO: synchronize with completion of callback
+ }
+
+ // 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)
+ {
+ if constexpr (__has_builtin(__builtin_ia32_pause))
+ __builtin_ia32_pause();
+#ifdef _GLIBCXX_USE_SCHED_YIELD
+ else
+ __gthread_yield();
+#endif
+ __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}
{ }
};
@@ -220,34 +409,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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]]
@@ -261,7 +457,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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
@@ -299,14 +495,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
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;
@@ -315,13 +513,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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);
}
}
@@ -331,13 +527,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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);
}
}
@@ -346,7 +540,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
if (_M_state)
{
- _M_state->_M_remove_callback(this);
+ _M_state->_M_remove_callback(&_M_cb);
}
}
@@ -356,14 +550,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
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>
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock-mt.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock-mt.cc
new file mode 100644
index 0000000..12c54db
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock-mt.cc
@@ -0,0 +1,50 @@
+// 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();
+}
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock.cc
new file mode 100644
index 0000000..f9de6e0
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/deadlock.cc
@@ -0,0 +1,48 @@
+// 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();
+}
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/destructible_neg.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/destructible_neg.cc
new file mode 100644
index 0000000..5016af0
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/destructible_neg.cc
@@ -0,0 +1,57 @@
+// 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 }
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
new file mode 100644
index 0000000..459a481
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
@@ -0,0 +1,35 @@
+// 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 }
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invoke.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invoke.cc
new file mode 100644
index 0000000..9b8137c
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invoke.cc
@@ -0,0 +1,62 @@
+// 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();
+}
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_source/assign.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_source/assign.cc
new file mode 100644
index 0000000..c822e8e
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_source/assign.cc
@@ -0,0 +1,51 @@
+// 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();
+}
diff --git a/libstdc++-v3/testsuite/30_threads/stop_token/stop_token/stop_possible.cc b/libstdc++-v3/testsuite/30_threads/stop_token/stop_token/stop_possible.cc
new file mode 100644
index 0000000..ee8de68
--- /dev/null
+++ b/libstdc++-v3/testsuite/30_threads/stop_token/stop_token/stop_possible.cc
@@ -0,0 +1,49 @@
+// 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();
+}
More information about the Libstdc++-cvs
mailing list