17 using Clock = std::chrono::steady_clock;
18 using Duration = std::chrono::nanoseconds;
20 void pending(
bool value)
noexcept {
21 m_pending.store(value, std::memory_order_release);
24 void nextReady(Clock::time_point when)
noexcept {
26 std::chrono::duration_cast<Duration>(when.time_since_epoch())
28 std::memory_order_release);
31 bool hasDeadline()
const noexcept {
32 return m_nextReadyNs.load(std::memory_order_acquire) != 0;
37 bool pressured(Duration reserve = Duration{0})
const noexcept {
38 if (m_pending.load(std::memory_order_acquire))
40 auto const deadline = m_nextReadyNs.load(std::memory_order_acquire);
43 auto const now = std::chrono::duration_cast<Duration>(
44 Clock::now().time_since_epoch())
46 return now >= deadline || reserve.count() >= deadline - now;
50 std::atomic<bool> m_pending{
false};
51 std::atomic<std::int64_t> m_nextReadyNs{0};
54enum class OptionalStage : std::size_t { Deep, Rescue, Aided, Count };
58class OptionalWorkBudget {
60 using Clock = OptionalWorkSignal::Clock;
61 using Duration = OptionalWorkSignal::Duration;
62 static constexpr std::size_t stages =
63 static_cast<std::size_t
>(OptionalStage::Count);
66 std::array<Duration, stages> &estimates,
67 bool unknownMandatory =
false)
68 : m_signal(signal), m_reserve(reserve), m_estimates(estimates),
69 m_unknownMandatory(unknownMandatory) {}
71 bool allow(OptionalStage stage)
const {
72 if (m_signal ==
nullptr)
74 if (m_unknownMandatory && m_signal->pressured())
76 if (m_unknownMandatory && m_signal->hasDeadline())
78 return !m_signal->pressured(m_reserve +
79 m_estimates[
static_cast<std::size_t
>(stage)]);
83 return m_signal && m_signal->pressured(m_reserve);
86 void observe(OptionalStage stage, Clock::time_point started) {
87 auto const elapsed = std::chrono::duration_cast<Duration>(
88 Clock::now() - started);
89 auto &estimate = m_estimates[
static_cast<std::size_t
>(stage)];
92 estimate = std::max(estimate * 9 / 10, elapsed + elapsed / 4);
98 std::array<Duration, stages> &m_estimates;
99 bool m_unknownMandatory;