use std::collections::BTreeMap;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Condvar, Mutex};
use super::decode::TileBufs;
use super::{caught, FrameJob, Reconstructed};
#[derive(Default)]
struct State {
ready: BTreeMap<u64, FrameJob>,
running: usize,
outstanding: usize,
next_id: u64,
error: Option<(u64, String)>,
}
pub(crate) struct Sched {
limit: usize,
state: Mutex<State>,
idle: Condvar,
pools: Mutex<Vec<Vec<TileBufs>>>,
cancelled: AtomicBool,
}
impl Sched {
pub(crate) fn new(limit: usize, pool: Vec<TileBufs>) -> Arc<Self> {
Arc::new(Sched {
limit,
state: Mutex::default(),
idle: Condvar::new(),
pools: Mutex::new(vec![pool]),
cancelled: AtomicBool::new(false),
})
}
pub(crate) fn submit(self: &Arc<Self>, job: FrameJob) {
let id = {
let mut s = self.state.lock().unwrap();
s.outstanding += 1;
s.next_id += 1;
s.next_id
};
let deps = job.dependencies();
let left = Arc::new(AtomicUsize::new(deps.len() + 1));
let job = Arc::new(Mutex::new(Some(job)));
let arrive = {
let (me, left, job) = (self.clone(), left, job);
Arc::new(move || {
if left.fetch_sub(1, Ordering::AcqRel) == 1 {
let j = job.lock().unwrap().take().unwrap();
me.state.lock().unwrap().ready.insert(id, j);
me.pump();
}
})
};
for d in deps {
let a = arrive.clone();
d.when_done(Box::new(move || a()));
}
arrive();
}
fn pump(self: &Arc<Self>) {
loop {
let (id, job) = {
let mut s = self.state.lock().unwrap();
if s.running >= self.limit {
return;
}
let Some(next) = s.ready.pop_first() else {
return;
};
s.running += 1;
next
};
let me = self.clone();
crate::spawn(move || me.run(id, job));
}
}
fn run(self: &Arc<Self>, id: u64, job: FrameJob) {
let r = if self.cancelled.load(Ordering::Relaxed) {
Err("decoding stopped".into())
} else {
let mut pool = self.pools.lock().unwrap().pop().unwrap_or_default();
let r = caught(|| job.reconstruct(&mut pool).map(Reconstructed::finish));
self.pools.lock().unwrap().push(pool);
r
};
if let Err(e) = &r {
let mut s = self.state.lock().unwrap();
if s.error.as_ref().is_none_or(|(first, _)| id < *first) {
s.error = Some((id, e.clone()));
}
}
job.done.set(r);
{
let mut s = self.state.lock().unwrap();
s.running -= 1;
s.outstanding -= 1;
}
self.idle.notify_all();
self.pump();
}
pub(crate) fn cancel(&self) {
self.cancelled.store(true, Ordering::Relaxed);
}
pub(crate) fn finish(&self) -> (Vec<TileBufs>, Option<String>) {
let mut s = self.state.lock().unwrap();
while s.outstanding != 0 {
s = self.idle.wait(s).unwrap();
}
let error = s.error.take().map(|(_, e)| e);
(self.pools.lock().unwrap().pop().unwrap_or_default(), error)
}
}