use std::collections::{BTreeMap, BTreeSet};
use crate::api::WaitCause;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(super) enum WaitFor {
Slot,
Host,
}
#[derive(Debug, Clone, Copy)]
struct OpenWait {
kind: WaitFor,
since: u64,
}
#[derive(Debug, Clone, Copy)]
struct OpenCause {
cause: WaitCause,
since: u64,
}
pub(super) const CAUSE_CHECKPOINT: u64 = 5 * 60 * 1000;
#[derive(Debug, Clone, Copy, Default)]
enum Cause {
#[default]
None,
Open(OpenCause),
Taken,
}
#[derive(Debug, Clone, Copy, Default)]
struct JobWaits {
sized: Option<OpenWait>,
cause: Cause,
}
impl JobWaits {
fn is_empty(&self) -> bool {
self.sized.is_none() && matches!(self.cause, Cause::None)
}
fn open_cause(&self) -> Option<OpenCause> {
match self.cause {
Cause::Open(open) => Some(open),
Cause::None | Cause::Taken => None,
}
}
fn is_taken(&self) -> bool {
matches!(self.cause, Cause::Taken)
}
fn take_sized(&mut self) -> Option<OpenWait> {
self.sized.take()
}
fn set_sized(&mut self, wait: OpenWait) {
self.sized = Some(wait);
}
fn take_cause(&mut self) -> Option<OpenCause> {
let open = self.open_cause()?;
self.cause = Cause::None;
Some(open)
}
fn set_cause(&mut self, cause: OpenCause) {
self.cause = Cause::Open(cause);
}
fn set_taken(&mut self) {
self.cause = Cause::Taken;
}
fn forget_taken(&mut self) {
if self.is_taken() {
self.cause = Cause::None;
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub(super) struct Waited {
pub kind: WaitFor,
pub jobs: Vec<u64>,
pub ms: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct CauseWaited {
pub job: u64,
pub cause: WaitCause,
pub ms: u64,
}
#[derive(Debug, Default)]
pub(super) struct OpenWaits {
open: BTreeMap<u64, JobWaits>,
checkpointed: u64,
}
impl OpenWaits {
pub(super) fn open_wait(
&mut self,
kind: WaitFor,
waiting: BTreeSet<u64>,
now: u64,
) -> Vec<Waited> {
let waiting: BTreeSet<u64> = waiting
.into_iter()
.filter(|job| !self.open.get(job).is_some_and(JobWaits::is_taken))
.collect();
let mut waited = self.close(|job, open| open != kind && waiting.contains(&job), now);
waited.extend(self.close(|_, open| open == kind, now));
let since = OpenWait { kind, since: now };
for job in waiting {
self.open.entry(job).or_default().set_sized(since);
}
waited
}
pub(super) fn end_wait(&mut self, job: u64, now: u64) -> Option<Waited> {
let wait = self.open.get_mut(&job)?.take_sized()?;
self.forget_if_empty(job);
Some(Waited {
kind: wait.kind,
jobs: vec![job],
ms: now.saturating_sub(wait.since),
})
}
pub(super) fn jobs(&self, kind: WaitFor) -> BTreeSet<u64> {
self.open
.iter()
.filter(|(_, waits)| waits.sized.is_some_and(|wait| wait.kind == kind))
.map(|(job, _)| *job)
.collect()
}
pub(super) fn hold(
&mut self,
held: &BTreeMap<u64, WaitCause>,
going_on: &BTreeSet<u64>,
now: u64,
) -> Vec<CauseWaited> {
let checkpoint = now.saturating_sub(self.checkpointed) >= CAUSE_CHECKPOINT;
let mut waited = Vec::new();
for (job, waits) in &mut self.open {
let Some(open) = waits.open_cause() else {
continue;
};
let next = held
.get(job)
.copied()
.or_else(|| going_on.contains(job).then_some(open.cause));
if next == Some(open.cause) && !checkpoint {
continue;
}
if let Some(open) = waits.take_cause() {
waited.push(CauseWaited {
job: *job,
cause: open.cause,
ms: now.saturating_sub(open.since),
});
}
if let Some(cause) = next {
waits.set_cause(OpenCause { cause, since: now });
}
}
for (job, cause) in held {
let waits = self.open.entry(*job).or_default();
if matches!(waits.cause, Cause::None) {
waits.set_cause(OpenCause {
cause: *cause,
since: now,
});
}
}
for waits in self.open.values_mut() {
waits.forget_taken();
}
self.open.retain(|_, waits| !waits.is_empty());
if checkpoint {
self.checkpointed = now;
}
waited
}
pub(super) fn booting(&mut self, job: u64, now: u64) -> Option<CauseWaited> {
let waits = self.open.entry(job).or_default();
if waits.is_taken() {
return None;
}
let ended = waits.take_cause();
waits.set_cause(OpenCause {
cause: WaitCause::Booting,
since: now,
});
ended.map(|open| CauseWaited {
job,
cause: open.cause,
ms: now.saturating_sub(open.since),
})
}
pub(super) fn end_cause(&mut self, job: u64, at: u64) -> Option<CauseWaited> {
let open = self.open.get_mut(&job)?.take_cause()?;
self.forget_if_empty(job);
Some(CauseWaited {
job,
cause: open.cause,
ms: at.saturating_sub(open.since),
})
}
pub(super) fn taken(&mut self, job: u64, at: u64) -> Option<CauseWaited> {
let waits = self.open.entry(job).or_default();
let open = waits.take_cause();
waits.set_taken();
open.map(|open| CauseWaited {
job,
cause: open.cause,
ms: at.saturating_sub(open.since),
})
}
pub(super) fn end_causes(&mut self, now: u64) -> Vec<CauseWaited> {
let mut waited = Vec::new();
for (job, waits) in &mut self.open {
waits.forget_taken();
if let Some(open) = waits.take_cause() {
waited.push(CauseWaited {
job: *job,
cause: open.cause,
ms: now.saturating_sub(open.since),
});
}
}
self.open.retain(|_, waits| !waits.is_empty());
waited
}
#[cfg(test)]
pub(super) fn checkpoint_due(&mut self) {
self.checkpointed = 0;
}
#[cfg(test)]
pub(super) fn cause(&self, job: u64) -> Option<WaitCause> {
self.open
.get(&job)
.and_then(JobWaits::open_cause)
.map(|open| open.cause)
}
fn forget_if_empty(&mut self, job: u64) {
if self.open.get(&job).is_some_and(JobWaits::is_empty) {
self.open.remove(&job);
}
}
fn close(&mut self, ends: impl Fn(u64, WaitFor) -> bool, now: u64) -> Vec<Waited> {
let mut ended: BTreeMap<(WaitFor, u64), Vec<u64>> = BTreeMap::new();
for (job, waits) in &mut self.open {
if waits.sized.is_some_and(|wait| ends(*job, wait.kind))
&& let Some(wait) = waits.take_sized()
{
ended.entry((wait.kind, wait.since)).or_default().push(*job);
}
}
self.open.retain(|_, waits| !waits.is_empty());
ended
.into_iter()
.map(|((kind, since), jobs)| Waited {
kind,
jobs,
ms: now.saturating_sub(since),
})
.collect()
}
}