mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 06:56:08 +00:00
95ebf2be0e
This is a follow-up PR to <https://github.com/llvm/llvm-project/pull/79265>. It aims to be a gentle refactoring of the `__cxx_atomic_wait` function that takes a predicate. The key idea here is that this function's signature is changed to look like this (`std::function` used just for clarity): ```c++ __cxx_atomic_wait_fn(Atp*, std::function<bool(Tp &)> poll, memory_order __order); ``` ...where `Tp` is the corresponding `value_type` to the atomic variable type `Atp`. The function's semantics are similar to `atomic`s `.wait()`, but instead of having a hardcoded predicate (is the loaded value unequal to `old`?) the predicate is specified explicitly. The `poll` function may change its argument, and it is very important that if it returns `false`, it leaves its current understanding of the atomic's value in the argument. Internally, `__cxx_atomic_wait_fn` dispatches to two waiting mechanisms, depending on the type of the atomic variable: 1. If the atomic variable can be waited on directly (for example, Linux's futex mechanism only supports waiting on 32 bit long variables), the value of the atomic variable (which `poll` made its decision on) is then given to the underlying system wait function (e.g. futex). 2. If the atomic variable can not be waited on directly, there is a global pool of atomics that are used for this task. The ["eventcount" pattern](<https://gist.github.com/mratsim/04a29bdd98d6295acda4d0677c4d0041>) is employed to make this possible. The eventcount pattern needs a "monitor" variable which is read before the condition is checked another time. libcxx has the `__libcpp_atomic_monitor` function for this. However, this function only has to be called in case "2", i.e. when the eventcount is actually used. In case "1", the futex is used directly, so the monitor must be the value of the atomic variable that the `poll` function made its decision on to continue blocking. Previously, `__libcpp_atomic_monitor` was _also_ used in case "1". This was the source of the ABA style bug that PR#79265 fixed. However, the solution in PR#79265 has some disadvantages: - It exposes internals such as `cxx_contention_t` or the fact that `__libcpp_thread_poll_with_backoff` needs two functions to higher level constructs such as `semaphore`. - It doesn't prevent consumers calling `__cxx_atomic_wait` in an error prone way, i.e. by providing to it a predicate that doesn't take an argument. This makes ABA style issues more likely to appear. Now, `__cxx_atomic_wait_fn` takes just _one_ function, which is then transformed into the `poll` and `backoff` callables needed by `__libcpp_thread_poll_with_backoff`. Aside from the `__cxx_atomic_wait` changes, the only other change is the weakening of the initial atomic load of `semaphore`'s `try_acquire` into `memory_order_relaxed` and the CAS inside the loop is changed from `strong` to `weak`. Both weakenings should be fine, since the CAS is called in a loop, and the "acquire" semantics of `try_acquire` come from the CAS, not from the initial load.
131 lines
3.7 KiB
C++
131 lines
3.7 KiB
C++
// -*- 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_LATCH
|
|
#define _LIBCPP_LATCH
|
|
|
|
/*
|
|
latch synopsis
|
|
|
|
namespace std
|
|
{
|
|
|
|
class latch
|
|
{
|
|
public:
|
|
static constexpr ptrdiff_t max() noexcept;
|
|
|
|
constexpr explicit latch(ptrdiff_t __expected);
|
|
~latch();
|
|
|
|
latch(const latch&) = delete;
|
|
latch& operator=(const latch&) = delete;
|
|
|
|
void count_down(ptrdiff_t __update = 1);
|
|
bool try_wait() const noexcept;
|
|
void wait() const;
|
|
void arrive_and_wait(ptrdiff_t __update = 1);
|
|
|
|
private:
|
|
ptrdiff_t __counter; // exposition only
|
|
};
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
#include <__config>
|
|
|
|
#ifdef _LIBCPP_HAS_NO_THREADS
|
|
# error "<latch> is not supported since libc++ has been configured without support for threads."
|
|
#endif
|
|
|
|
#include <__assert> // all public C++ headers provide the assertion handler
|
|
#include <__atomic/atomic_base.h>
|
|
#include <__atomic/atomic_sync.h>
|
|
#include <__atomic/memory_order.h>
|
|
#include <__availability>
|
|
#include <cstddef>
|
|
#include <limits>
|
|
#include <version>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
#include <__undef_macros>
|
|
|
|
#if _LIBCPP_STD_VER >= 14
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
class latch {
|
|
__atomic_base<ptrdiff_t> __a_;
|
|
|
|
public:
|
|
static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI constexpr explicit latch(ptrdiff_t __expected) : __a_(__expected) {
|
|
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
|
__expected >= 0,
|
|
"latch::latch(ptrdiff_t): latch cannot be "
|
|
"initialized with a negative value");
|
|
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
|
__expected <= max(),
|
|
"latch::latch(ptrdiff_t): latch cannot be "
|
|
"initialized with a value greater than max()");
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI ~latch() = default;
|
|
latch(const latch&) = delete;
|
|
latch& operator=(const latch&) = delete;
|
|
|
|
inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void count_down(ptrdiff_t __update = 1) {
|
|
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::count_down called with a negative value");
|
|
auto const __old = __a_.fetch_sub(__update, memory_order_release);
|
|
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
|
|
__update <= __old,
|
|
"latch::count_down called with a value greater "
|
|
"than the internal counter");
|
|
if (__old == __update)
|
|
__a_.notify_all();
|
|
}
|
|
inline _LIBCPP_HIDE_FROM_ABI bool try_wait() const noexcept {
|
|
auto __value = __a_.load(memory_order_acquire);
|
|
return try_wait_impl(__value);
|
|
}
|
|
inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait() const {
|
|
__cxx_atomic_wait_unless(
|
|
&__a_.__a_, [this](ptrdiff_t& __value) -> bool { return try_wait_impl(__value); }, memory_order_acquire);
|
|
}
|
|
inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_wait(ptrdiff_t __update = 1) {
|
|
_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::arrive_and_wait called with a negative value");
|
|
// other preconditions on __update are checked in count_down()
|
|
|
|
count_down(__update);
|
|
wait();
|
|
}
|
|
|
|
private:
|
|
inline _LIBCPP_HIDE_FROM_ABI bool try_wait_impl(ptrdiff_t& __value) const noexcept { return __value == 0; }
|
|
};
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_STD_VER >= 14
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
|
# include <atomic>
|
|
#endif
|
|
|
|
#endif //_LIBCPP_LATCH
|