mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-23 07:10:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

libstdc++: Make barrier::arrival_token a move-only class type

Browse Source 
The standard only specifies that barrier::arrival_token is a move
constructible and move assignable type. We originally used a scoped enum
type, but that means we do not diagnose non-portable code that makes
copies of arrival tokens (or compares them for equality, or uses them as
keys in map!) This wraps the enum in a move-only class type, so that
users are forced to pass it correctly.

The move constructor and move assignment operator of the new class do
not zero out the moved-from token, as that would add additional
instructions. That means that passing a moved-from token will work with
our implementation, despite being a bug in the user code. We could
consider doing that zeroing out in debug mode.

libstdc++-v3/ChangeLog:

	* include/std/barrier (barrier::arrival_token): New move-only
	class that encapsulates the underlying token value.
This commit is contained in:
Jonathan Wakely 2021-03-11 16:57:20 +00:00
parent 9dacc828bf
commit 5643f6f396
1 changed files with 18 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
libstdc++-v3/include/std/barrier
View File

@ -209,15 +209,27 @@ It looks different from literature pseudocode for two main reasons:
__algorithm_t _M_b;
public:
using arrival_token = typename __tree_barrier<_CompletionF>::arrival_token;
class arrival_token final
{
public:
arrival_token(arrival_token&&) = default;
arrival_token& operator=(arrival_token&&) = default;
~arrival_token() = default;
private:
friend class barrier;
using __token = typename __algorithm_t::arrival_token;
explicit arrival_token(__token __tok) noexcept : _M_tok(__tok) { }
__token _M_tok;
};
static constexpr ptrdiff_t
max() noexcept
{ return __algorithm_t::max(); }
explicit barrier(ptrdiff_t __count,
_CompletionF __completion = _CompletionF())
: _M_b(__count, std::move(__completion))
explicit
barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
: _M_b(__count, std::move(__completion))
{ }
barrier(barrier const&) = delete;
@ -225,11 +237,11 @@ It looks different from literature pseudocode for two main reasons:
[[nodiscard]] arrival_token
arrive(ptrdiff_t __update = 1)
{ return _M_b.arrive(__update); }
{ return arrival_token{_M_b.arrive(__update)}; }
void
wait(arrival_token&& __phase) const
{ _M_b.wait(std::move(__phase)); }
{ _M_b.wait(std::move(__phase._M_tok)); }
void
arrive_and_wait()