use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
#[derive(Debug)]
pub struct Frame {
pub label: String,
pub done: AtomicU64,
pub total: AtomicU64,
}
static CANCEL: AtomicBool = AtomicBool::new(false);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Cancelled;
pub fn cancel() {
CANCEL.store(true, Ordering::SeqCst);
}
pub fn cancelled() -> bool {
CANCEL.load(Ordering::Relaxed)
}
pub fn clear_cancel() {
CANCEL.store(false, Ordering::SeqCst);
}
pub fn check() {
if cancelled() {
std::panic::resume_unwind(Box::new(Cancelled));
}
}
fn stack() -> &'static Mutex<Vec<Arc<Frame>>> {
static STACK: OnceLock<Mutex<Vec<Arc<Frame>>>> = OnceLock::new();
STACK.get_or_init(|| Mutex::new(Vec::new()))
}
#[derive(Debug)]
pub struct Task {
frame: Arc<Frame>,
}
pub fn start(label: impl Into<String>, total: u64) -> Task {
let frame = Arc::new(Frame { label: label.into(), done: AtomicU64::new(0), total: AtomicU64::new(total) });
if let Ok(mut s) = stack().lock() {
s.push(Arc::clone(&frame));
}
Task { frame }
}
impl Task {
pub fn inc(&self, n: u64) {
check();
self.inc_unchecked(n);
}
pub fn set(&self, done: u64) {
check();
self.set_unchecked(done);
}
pub fn inc_unchecked(&self, n: u64) {
self.frame.done.fetch_add(n, Ordering::Relaxed);
}
pub fn set_unchecked(&self, done: u64) {
self.frame.done.store(done, Ordering::Relaxed);
}
pub fn set_total(&self, total: u64) {
self.frame.total.store(total, Ordering::Relaxed);
}
}
impl Drop for Task {
fn drop(&mut self) {
if let Ok(mut s) = stack().lock() {
s.retain(|f| !Arc::ptr_eq(f, &self.frame));
}
}
}
pub fn state() -> Vec<(String, u64, u64)> {
match stack().lock() {
Ok(s) => s
.iter()
.map(|f| (f.label.clone(), f.done.load(Ordering::Relaxed), f.total.load(Ordering::Relaxed)))
.collect(),
Err(_) => Vec::new(),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn mine(prefix: &str) -> Vec<(String, u64, u64)> {
state().into_iter().filter(|(l, _, _)| l.starts_with(prefix)).collect()
}
#[test]
fn tasks_nest_and_leave_when_dropped() {
let outer = start("test-nest outer", 10);
outer.inc(3);
{
let inner = start("test-nest inner", 4);
inner.inc(1);
inner.inc(1);
let s = mine("test-nest");
assert_eq!(s.len(), 2);
assert_eq!(s[0], ("test-nest outer".to_string(), 3, 10));
assert_eq!(s[1], ("test-nest inner".to_string(), 2, 4));
}
let s = mine("test-nest");
assert_eq!(s.len(), 1, "the inner task left when it was dropped");
outer.set(10);
outer.set_total(12);
assert_eq!(mine("test-nest")[0], ("test-nest outer".to_string(), 10, 12));
drop(outer);
assert!(mine("test-nest").is_empty());
}
#[test]
fn an_uncancelled_check_does_nothing_and_the_payload_is_recognisable() {
assert!(!cancelled());
check();
let caught = std::panic::catch_unwind(|| std::panic::resume_unwind(Box::new(Cancelled))).unwrap_err();
assert!(caught.is::<Cancelled>());
let t = start("test-unchecked", 5);
t.inc_unchecked(2);
t.set_unchecked(4);
assert_eq!(mine("test-unchecked")[0].1, 4);
}
#[test]
fn counting_works_from_several_threads() {
let t = start("test-threads", 400);
std::thread::scope(|s| {
for _ in 0..4 {
s.spawn(|| (0..100).for_each(|_| t.inc(1)));
}
});
assert_eq!(mine("test-threads")[0].1, 400);
}
}