use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{mpsc, Mutex};
pub type Log<'a> = &'a (dyn Fn(&str) + Sync);
pub fn quiet(_: &str) {}
pub fn relay<T: Send>(work: impl FnOnce(Log) -> T + Send, mut deliver: impl FnMut(&str)) -> T {
let (tx, rx) = mpsc::channel::<String>();
std::thread::scope(|s| {
let handle = s.spawn(move || {
let tx = Mutex::new(tx);
let log = move |msg: &str| {
if let Ok(tx) = tx.lock() {
let _ = tx.send(msg.to_string());
}
};
work(&log)
});
for msg in rx {
deliver(&msg);
}
match handle.join() {
Ok(v) => v,
Err(panic) => std::panic::resume_unwind(panic),
}
})
}
pub fn relay_ticking<T: Send>(work: impl FnOnce(Log) -> T + Send, every: std::time::Duration, mut event: impl FnMut(Option<&str>)) -> T {
let (tx, rx) = mpsc::channel::<String>();
std::thread::scope(|s| {
let handle = s.spawn(move || {
let tx = Mutex::new(tx);
let log = move |msg: &str| {
if let Ok(tx) = tx.lock() {
let _ = tx.send(msg.to_string());
}
};
work(&log)
});
loop {
match rx.recv_timeout(every) {
Ok(msg) => event(Some(&msg)),
Err(mpsc::RecvTimeoutError::Timeout) => event(None),
Err(mpsc::RecvTimeoutError::Disconnected) => break,
}
}
match handle.join() {
Ok(v) => v,
Err(panic) => std::panic::resume_unwind(panic),
}
})
}
pub fn ordered_map<T: Send>(n: usize, workers: usize, f: impl Fn(usize) -> T + Sync, done: impl Fn(usize, &T) + Sync) -> Vec<T> {
if workers <= 1 || n <= 1 {
let mut out = Vec::with_capacity(n);
for k in 0..n {
let v = f(k);
done(k, &v);
out.push(v);
}
return out;
}
let slots: Vec<Mutex<Option<T>>> = (0..n).map(|_| Mutex::new(None)).collect();
let next = AtomicUsize::new(0);
let emitted = Mutex::new(0usize);
let run = || loop {
let k = next.fetch_add(1, Ordering::SeqCst);
if k >= n {
break;
}
let v = f(k);
*slots[k].lock().expect("slot") = Some(v);
let mut first = emitted.lock().expect("emitter");
while *first < n {
let slot = slots[*first].lock().expect("slot");
match slot.as_ref() {
Some(v) => done(*first, v),
None => break,
}
drop(slot);
*first += 1;
}
};
std::thread::scope(|s| {
for _ in 0..workers.min(n) {
s.spawn(run);
}
});
slots.into_iter().map(|m| m.into_inner().expect("slot").expect("every item ran")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ordered_whatever_the_threads() {
for workers in [1, 2, 5] {
let seen = Mutex::new(Vec::new());
let out = ordered_map(20, workers, |k| {
std::thread::sleep(std::time::Duration::from_millis(((k * 7) % 5) as u64));
k * k
}, |k, v| seen.lock().unwrap().push((k, *v)));
assert_eq!(out, (0..20).map(|k| k * k).collect::<Vec<_>>());
assert_eq!(seen.into_inner().unwrap(), (0..20).map(|k| (k, k * k)).collect::<Vec<_>>());
}
}
#[test]
fn a_ticking_relay_delivers_lines_ticks_while_idle_and_passes_an_unwinding_on() {
let (mut got, mut ticks) = (Vec::new(), 0);
let r = relay_ticking(
|log| {
log("first");
std::thread::sleep(std::time::Duration::from_millis(60));
log("second");
7
},
std::time::Duration::from_millis(5),
|m| match m {
Some(m) => got.push(m.to_string()),
None => ticks += 1,
},
);
assert_eq!(r, 7);
assert_eq!(got, ["first", "second"]);
assert!(ticks >= 1, "the caller was woken while the work was quiet");
#[derive(Debug)]
struct Stop;
let caught = std::panic::catch_unwind(|| relay_ticking(|_| -> u8 { std::panic::resume_unwind(Box::new(Stop)) }, std::time::Duration::from_millis(5), |_| {})).unwrap_err();
assert!(caught.is::<Stop>());
}
#[test]
fn relayed_messages_arrive_in_order_on_the_caller() {
let caller = std::thread::current().id();
let mut got = Vec::new();
let r = relay(|log| {
for k in 0..5 {
log(&format!("line {k}"));
}
42
}, |m| {
assert_eq!(std::thread::current().id(), caller);
got.push(m.to_string());
});
assert_eq!(r, 42);
assert_eq!(got, (0..5).map(|k| format!("line {k}")).collect::<Vec<_>>());
}
}