112 lines
3.6 KiB
C++
112 lines
3.6 KiB
C++
// Copyright 2023 The Abseil Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "absl/synchronization/internal/futex_waiter.h"
|
|
|
|
#ifdef ABSL_INTERNAL_HAVE_FUTEX_WAITER
|
|
|
|
#include <atomic>
|
|
#include <cstdint>
|
|
#include <cerrno>
|
|
|
|
#include "absl/base/config.h"
|
|
#include "absl/base/internal/raw_logging.h"
|
|
#include "absl/base/internal/thread_identity.h"
|
|
#include "absl/base/optimization.h"
|
|
#include "absl/synchronization/internal/kernel_timeout.h"
|
|
#include "absl/synchronization/internal/futex.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
namespace synchronization_internal {
|
|
|
|
#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
|
|
constexpr char FutexWaiter::kName[];
|
|
#endif
|
|
|
|
int FutexWaiter::WaitUntil(std::atomic<int32_t>* v, int32_t val,
|
|
KernelTimeout t) {
|
|
#ifdef CLOCK_MONOTONIC
|
|
constexpr bool kHasClockMonotonic = true;
|
|
#else
|
|
constexpr bool kHasClockMonotonic = false;
|
|
#endif
|
|
|
|
// We can't call Futex::WaitUntil() here because the prodkernel implementation
|
|
// does not know about KernelTimeout::SupportsSteadyClock().
|
|
if (!t.has_timeout()) {
|
|
return Futex::Wait(v, val);
|
|
} else if (kHasClockMonotonic && KernelTimeout::SupportsSteadyClock() &&
|
|
t.is_relative_timeout()) {
|
|
auto rel_timespec = t.MakeRelativeTimespec();
|
|
return Futex::WaitRelativeTimeout(v, val, &rel_timespec);
|
|
} else {
|
|
auto abs_timespec = t.MakeAbsTimespec();
|
|
return Futex::WaitAbsoluteTimeout(v, val, &abs_timespec);
|
|
}
|
|
}
|
|
|
|
bool FutexWaiter::Wait(KernelTimeout t) {
|
|
// Loop until we can atomically decrement futex from a positive
|
|
// value, waiting on a futex while we believe it is zero.
|
|
// Note that, since the thread ticker is just reset, we don't need to check
|
|
// whether the thread is idle on the very first pass of the loop.
|
|
bool first_pass = true;
|
|
while (true) {
|
|
int32_t x = futex_.load(std::memory_order_relaxed);
|
|
while (x != 0) {
|
|
if (!futex_.compare_exchange_weak(x, x - 1,
|
|
std::memory_order_acquire,
|
|
std::memory_order_relaxed)) {
|
|
continue; // Raced with someone, retry.
|
|
}
|
|
return true; // Consumed a wakeup, we are done.
|
|
}
|
|
|
|
if (!first_pass) MaybeBecomeIdle();
|
|
const int err = WaitUntil(&futex_, 0, t);
|
|
if (err != 0) {
|
|
if (err == -EINTR || err == -EWOULDBLOCK) {
|
|
// Do nothing, the loop will retry.
|
|
} else if (err == -ETIMEDOUT) {
|
|
return false;
|
|
} else {
|
|
ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
|
|
}
|
|
}
|
|
first_pass = false;
|
|
}
|
|
}
|
|
|
|
void FutexWaiter::Post() {
|
|
if (futex_.fetch_add(1, std::memory_order_release) == 0) {
|
|
// We incremented from 0, need to wake a potential waiter.
|
|
Poke();
|
|
}
|
|
}
|
|
|
|
void FutexWaiter::Poke() {
|
|
// Wake one thread waiting on the futex.
|
|
const int err = Futex::Wake(&futex_, 1);
|
|
if (ABSL_PREDICT_FALSE(err < 0)) {
|
|
ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
|
|
}
|
|
}
|
|
|
|
} // namespace synchronization_internal
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|
|
|
|
#endif // ABSL_INTERNAL_HAVE_FUTEX_WAITER
|