use std::sync::{Arc, Mutex, PoisonError};
use std::time::Duration;
use store_io_platform::Platform;
use crate::exec::LaneMark;
use crate::store::Store;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Outstanding {
pub age: Duration,
pub flush: bool,
}
#[derive(Debug, Default)]
pub(crate) struct Seen {
lanes: Vec<(u64, u64)>,
submitters: Vec<(u64, u64, u64)>,
}
#[derive(Default)]
pub(crate) struct Submitters {
next: u64,
marks: Vec<(u64, Arc<LaneMark>)>,
}
fn lock_submitters(s: &Mutex<Submitters>) -> std::sync::MutexGuard<'_, Submitters> {
s.lock().unwrap_or_else(PoisonError::into_inner)
}
const NOT_SEEN: u64 = u64::MAX;
pub(crate) fn lock_seen(s: &Mutex<Seen>) -> std::sync::MutexGuard<'_, Seen> {
s.lock().unwrap_or_else(PoisonError::into_inner)
}
impl<P: Platform> Store<P>
where
P::Queue: Send,
{
#[must_use]
pub fn oldest_outstanding(&self) -> Option<Outstanding> {
let inner = &self.inner;
let mut seen = lock_seen(&inner.seen);
let lanes = inner.queues.marks().len();
if seen.lanes.len() != lanes {
seen.lanes = vec![(0, 0); lanes];
}
for (mark, entry) in inner.queues.marks().zip(seen.lanes.iter_mut()) {
if mark % 2 == 0 || entry.0 != mark {
*entry = (mark, NOT_SEEN);
}
}
let busy: Vec<(u64, u64)> = lock_submitters(&inner.submitters)
.marks
.iter()
.map(|(id, m)| (*id, m.get()))
.filter(|(_, mark)| mark % 2 == 1)
.collect();
let now = inner.platform.monotonic_ms();
let first_flush = 2 * inner.queues.shared_len();
let mut oldest: Option<(u64, bool)> = None;
for (i, entry) in seen.lanes.iter_mut().enumerate() {
if entry.0 % 2 == 0 {
continue;
}
if entry.1 == NOT_SEEN {
entry.1 = now;
}
let flush = i >= first_flush;
if oldest.is_none_or(|(first, was_flush)| {
entry.1 < first || (entry.1 == first && flush && !was_flush)
}) {
oldest = Some((entry.1, flush));
}
}
let before = std::mem::take(&mut seen.submitters);
for (id, mark) in busy {
let first = before
.iter()
.find(|e| e.0 == id && e.1 == mark)
.map_or(now, |e| e.2);
seen.submitters.push((id, mark, first));
if oldest.is_none_or(|(at, _)| first < at) {
oldest = Some((first, false));
}
}
oldest.map(|(first, flush)| Outstanding {
age: Duration::from_millis(now.saturating_sub(first)),
flush,
})
}
}
impl<P: Platform> Store<P>
where
P::Queue: Send,
{
pub(crate) fn register_submitter(&self, mark: &Arc<LaneMark>) -> u64 {
let mut s = lock_submitters(&self.inner.submitters);
let id = s.next;
s.next += 1;
s.marks.push((id, Arc::clone(mark)));
id
}
pub(crate) fn unregister_submitter(&self, id: u64) {
lock_submitters(&self.inner.submitters)
.marks
.retain(|(i, _)| *i != id);
}
}
#[cfg(test)]
mod tests;