use std::collections::BTreeMap;
use std::time::Duration;
use super::{HIGH_WATER, Key};
use crate::api::Basis;
pub const POOL_AFTER: Duration = Duration::from_secs(60);
pub const MOST_CREDIT: u64 = 6 << 30;
pub const HIGH_WATER_RESERVE: u64 = 2 << 30;
#[derive(Debug, Clone, Copy)]
pub struct Runner<'run> {
pub key: Option<&'run Key>,
pub takes: u64,
pub used: Option<u64>,
pub ran: Option<Duration>,
pub basis: Option<Basis>,
}
impl Runner<'_> {
fn pooled(&self) -> Option<u64> {
let predicted = matches!(
self.basis,
Some(Basis::Job { .. } | Basis::Profile { .. } | Basis::ProfileMax { .. })
);
let settled = self.ran.is_some_and(|ran| ran >= POOL_AFTER);
self.used
.filter(|_| predicted && settled && self.key.is_some())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Slice {
pub memory: u64,
pub memory_max: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Host {
pub available: u64,
pub keeps: u64,
pub stalled: bool,
}
#[derive(Debug, Clone, Copy)]
pub struct Snapshot<'run> {
pub runners: &'run [Runner<'run>],
pub committed: u64,
pub slice: Option<Slice>,
pub host: Option<Host>,
pub most: u64,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Count {
pub plain: u64,
pub credit: u64,
pub runners: usize,
}
impl Count {
pub fn pooled(self) -> u64 {
self.plain - self.credit
}
}
pub fn count(snapshot: &Snapshot<'_>) -> Count {
let takes: u64 = snapshot.runners.iter().map(|runner| runner.takes).sum();
let plain = takes.saturating_add(snapshot.committed);
let mut room: BTreeMap<&Key, u64> = BTreeMap::new();
let mut runners = 0;
for runner in snapshot.runners {
if let (Some(key), Some(used)) = (runner.key, runner.pooled()) {
*room.entry(key).or_default() += runner.takes.saturating_sub(used);
runners += 1;
}
}
let added: u64 = room.values().sum();
let squares: u128 = room
.values()
.map(|room| u128::from(*room) * u128::from(*room))
.sum();
let credit = added
.saturating_sub(root(squares))
.min(snapshot.most)
.min(snapshot.slice.map_or(0, slice_room))
.min(snapshot.host.map_or(0, host_room));
Count {
plain,
credit,
runners: if credit > 0 { runners } else { 0 },
}
}
fn slice_room(slice: Slice) -> u64 {
let mark = u128::from(slice.memory_max) * u128::from(HIGH_WATER) / 100;
u64::try_from(mark)
.unwrap_or(u64::MAX)
.saturating_sub(slice.memory)
.saturating_sub(HIGH_WATER_RESERVE)
}
fn host_room(host: Host) -> u64 {
if host.stalled {
return 0;
}
host.available.saturating_sub(host.keeps)
}
fn root(squares: u128) -> u64 {
let root = squares.isqrt();
let exact = root * root == squares;
u64::try_from(root + u128::from(!exact)).unwrap_or(u64::MAX)
}
#[cfg(test)]
mod tests;