use crate::msg::ActorMsg;
use std::sync::atomic::{AtomicU64, Ordering as AtomicOrdering};
use std::sync::{Arc, Mutex};
use tokio::sync::watch;
pub const DEFAULT_MAILBOX_CAPACITY: usize = 256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MailboxPolicy {
Reliable { capacity: usize },
LossTolerant { capacity: usize },
}
impl MailboxPolicy {
pub const DEFAULT: Self = MailboxPolicy::Reliable { capacity: 0 };
pub fn capacity(&self) -> usize {
match self {
MailboxPolicy::Reliable { capacity } | MailboxPolicy::LossTolerant { capacity } => {
*capacity
}
}
}
pub fn has_data_port(&self) -> bool {
matches!(self, MailboxPolicy::LossTolerant { .. })
}
pub fn resolve(self, default_capacity: usize) -> Self {
let declared = self.capacity();
let cap = if declared == 0 {
default_capacity
} else {
declared
}
.max(1);
match self {
MailboxPolicy::Reliable { .. } => MailboxPolicy::Reliable { capacity: cap },
MailboxPolicy::LossTolerant { .. } => MailboxPolicy::LossTolerant { capacity: cap },
}
}
}
impl Default for MailboxPolicy {
fn default() -> Self {
Self::DEFAULT
}
}
struct SlotInner<M: ActorMsg> {
cell: Mutex<Option<M>>,
seq: AtomicU64,
}
pub struct SlotWriter<M: ActorMsg> {
seq: watch::Sender<u64>,
inner: Arc<SlotInner<M>>,
}
impl<M: ActorMsg> Clone for SlotWriter<M> {
fn clone(&self) -> Self {
Self {
seq: self.seq.clone(),
inner: self.inner.clone(),
}
}
}
impl<M: ActorMsg> SlotWriter<M> {
pub fn send(&self, msg: M) -> bool {
let (n, old) = {
let mut g = self.inner.cell.lock().unwrap_or_else(|e| e.into_inner());
let n = self.inner.seq.fetch_add(1, AtomicOrdering::Relaxed) + 1;
(n, g.replace(msg))
};
drop(old);
self.seq.send(n).is_ok()
}
pub fn is_closed(&self) -> bool {
self.seq.receiver_count() == 0
}
}
pub struct SlotReader<M: ActorMsg> {
rx: watch::Receiver<u64>,
inner: Arc<SlotInner<M>>,
}
impl<M: ActorMsg> Clone for SlotReader<M> {
fn clone(&self) -> Self {
Self {
rx: self.rx.clone(),
inner: self.inner.clone(),
}
}
}
impl<M: ActorMsg> SlotReader<M> {
pub async fn changed(&mut self) -> Result<(), watch::error::RecvError> {
self.rx.changed().await
}
pub fn take_latest(&mut self) -> Option<M> {
self.rx.borrow_and_update();
let mut g = self.inner.cell.lock().unwrap_or_else(|e| e.into_inner());
g.take()
}
}
pub fn latest_slot<M: ActorMsg>() -> (SlotWriter<M>, SlotReader<M>) {
let (seq, rx) = watch::channel(0u64);
let inner = Arc::new(SlotInner {
cell: Mutex::new(None),
seq: AtomicU64::new(0),
});
(
SlotWriter {
seq,
inner: inner.clone(),
},
SlotReader { rx, inner },
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn policy_resolve_fills_default() {
let p = MailboxPolicy::Reliable { capacity: 0 }.resolve(128);
assert_eq!(p, MailboxPolicy::Reliable { capacity: 128 });
let p = MailboxPolicy::LossTolerant { capacity: 4 }.resolve(128);
assert_eq!(p, MailboxPolicy::LossTolerant { capacity: 4 });
assert!(p.has_data_port());
}
#[tokio::test]
async fn slot_keeps_only_latest() {
let (w, mut r) = latest_slot::<u64>();
assert!(r.take_latest().is_none());
for i in 0..100 {
assert!(w.send(i));
}
assert_eq!(r.take_latest(), Some(99));
assert_eq!(r.take_latest(), None);
}
#[tokio::test]
async fn slot_change_notification() {
let (w, mut r) = latest_slot::<String>();
let handle = tokio::spawn(async move {
r.changed().await.unwrap();
r.take_latest()
});
w.send("attitude".into());
assert_eq!(handle.await.unwrap(), Some("attitude".to_string()));
}
#[tokio::test]
async fn slot_multi_writer_no_missed_wakeup() {
let (w1, mut r) = latest_slot::<u64>();
let w2 = w1.clone();
let reader = tokio::spawn(async move {
r.changed().await.unwrap();
r.take_latest()
});
let h1 = tokio::spawn(async move {
for i in 0..1000u64 {
w1.send(i * 2);
}
});
let h2 = tokio::spawn(async move {
for i in 0..1000u64 {
w2.send(i * 2 + 1);
}
});
let _ = tokio::join!(h1, h2);
let got = reader.await.unwrap().expect("唤醒后应取到帧");
assert!(got >= 999, "最终帧应来自最后一批写入,实际 {got}");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn slot_multi_writer_high_frequency_interleave() {
let (w, mut r) = latest_slot::<u64>();
let reader = tokio::spawn(async move {
let mut wakes = 0u64;
loop {
if r.changed().await.is_err() {
break;
}
let _ = r.take_latest();
wakes += 1;
}
wakes
});
const WRITERS: u64 = 3;
const PER_WRITER: u64 = 5000;
let mut handles = Vec::new();
for base in 0..WRITERS {
let w = w.clone();
handles.push(tokio::spawn(async move {
for i in 0..PER_WRITER {
w.send(base * PER_WRITER + i);
}
}));
}
drop(w); for h in handles {
h.await.unwrap();
}
let wakes = reader.await.unwrap();
assert!(wakes > 0, "压测应产生至少一次唤醒");
}
#[test]
fn slot_non_cloneable_msg() {
struct NoClone(Box<[u8; 32]>);
let (w, mut r) = latest_slot::<NoClone>();
w.send(NoClone(Box::new([7u8; 32])));
let taken = r.take_latest().expect("应取到唯一帧");
assert_eq!(taken.0[0], 7);
}
}