use std::collections::BTreeMap;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct CutToken(pub u64);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LatchCause {
Gap,
ScopeDirty,
CapacityExhausted,
HandoffBarrier,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CutKind {
Incremental { invalidations: BTreeMap<u64, u64> },
FullBaseline { cause: LatchCause },
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ObservationCut {
pub token: CutToken,
pub kind: CutKind,
}
#[derive(Debug)]
pub struct CoalescingAccumulator {
bound: usize,
pending: BTreeMap<u64, u64>,
latch: Option<LatchCause>,
next_token: u64,
}
struct UnwindRetention<'a> {
latch: &'a mut Option<LatchCause>,
armed: bool,
}
impl Drop for UnwindRetention<'_> {
fn drop(&mut self) {
if self.armed {
self.latch.get_or_insert(LatchCause::ScopeDirty);
}
}
}
impl CoalescingAccumulator {
pub fn new(bound: usize) -> Self {
Self {
bound,
pending: BTreeMap::new(),
latch: None,
next_token: 1,
}
}
pub fn observe(&mut self, source: u64, derive: impl FnOnce() -> u64) {
if !self.pending.contains_key(&source) && self.pending.len() >= self.bound {
self.latch.get_or_insert(LatchCause::CapacityExhausted);
return;
}
let stamp = {
let mut retention = UnwindRetention {
latch: &mut self.latch,
armed: true,
};
let stamp = derive();
retention.armed = false;
drop(retention);
stamp
};
self.pending.insert(source, stamp);
}
pub fn report_gap(&mut self) {
self.latch.get_or_insert(LatchCause::Gap);
}
pub fn pending(&self) -> usize {
self.pending.len()
}
pub fn cut(&mut self) -> ObservationCut {
let token = CutToken(self.next_token);
self.next_token += 1;
let pending = std::mem::take(&mut self.pending);
let kind = match self.latch.take() {
Some(cause) => CutKind::FullBaseline { cause },
None => CutKind::Incremental {
invalidations: pending,
},
};
ObservationCut { token, kind }
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum HandoffRefusal {
PredecessorStillDraining { undelivered: usize },
NoHandoffInProgress,
HandoffAlreadyInProgress { bound_successor: ObserverId },
NotTheActiveObserver { producer: ObserverId },
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ObserverId(pub u64);
#[derive(Debug)]
pub struct ObserverSlot {
active: ObserverId,
undelivered: Vec<(ObserverId, ObservationCut)>,
pending_successor: Option<ObserverId>,
}
impl ObserverSlot {
pub fn new(first: ObserverId) -> Self {
Self {
active: first,
undelivered: Vec::new(),
pending_successor: None,
}
}
pub fn active(&self) -> ObserverId {
self.active
}
pub fn queue_undelivered(
&mut self,
producer: ObserverId,
cut: ObservationCut,
) -> Result<(), HandoffRefusal> {
if producer != self.active {
return Err(HandoffRefusal::NotTheActiveObserver { producer });
}
self.undelivered.push((producer, cut));
Ok(())
}
pub fn begin_handoff(&mut self, successor: ObserverId) -> Result<(), HandoffRefusal> {
if let Some(bound_successor) = self.pending_successor {
return Err(HandoffRefusal::HandoffAlreadyInProgress { bound_successor });
}
self.pending_successor = Some(successor);
Ok(())
}
pub fn deliver_pending(&mut self) -> Vec<ObservationCut> {
std::mem::take(&mut self.undelivered)
.into_iter()
.map(|(_, cut)| cut)
.collect()
}
pub fn complete_handoff(&mut self) -> Result<CutKind, HandoffRefusal> {
let Some(successor) = self.pending_successor else {
return Err(HandoffRefusal::NoHandoffInProgress);
};
if !self.undelivered.is_empty() {
return Err(HandoffRefusal::PredecessorStillDraining {
undelivered: self.undelivered.len(),
});
}
self.active = successor;
self.pending_successor = None;
Ok(CutKind::FullBaseline {
cause: LatchCause::HandoffBarrier,
})
}
}