#[cfg(doc)]
use crate::limits::Limits;
#[derive(Debug)]
pub(crate) struct Work {
done: std::sync::atomic::AtomicU64,
limit: u64,
}
impl Work {
#[cfg(feature = "parallel")]
pub(crate) const BATCH: u64 = 1 << 12;
pub(crate) const fn new(limit: Option<u64>) -> Self {
Self {
done: std::sync::atomic::AtomicU64::new(0),
limit: match limit {
Some(limit) => limit,
None => u64::MAX,
},
}
}
pub(crate) fn add(&self, units: u64) -> u64 {
self.done
.fetch_add(units, std::sync::atomic::Ordering::Relaxed)
.saturating_add(units)
}
pub(crate) fn done(&self) -> u64 {
self.done.load(std::sync::atomic::Ordering::Relaxed)
}
pub(crate) const fn limit(&self) -> u64 {
self.limit
}
pub(crate) fn passed(&self) -> bool {
self.done() > self.limit
}
}
pub(crate) fn lock<T>(shared: &std::sync::Mutex<T>) -> std::sync::MutexGuard<'_, T> {
shared
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
#[cfg(feature = "parallel")]
pub(crate) fn taken<T>(shared: std::sync::Mutex<T>) -> T {
shared
.into_inner()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
pub(crate) struct Counted<'a> {
work: &'a Work,
pending: u64,
}
impl<'a> Counted<'a> {
pub(crate) const fn new(work: &'a Work) -> Self {
Self { work, pending: 0 }
}
pub(crate) fn add(&mut self, units: u64) -> u64 {
self.pending += units;
#[cfg(feature = "parallel")]
if self.pending >= Work::BATCH {
self.work.add(self.pending);
self.pending = 0;
}
self.done()
}
pub(crate) fn done(&self) -> u64 {
self.work.done().saturating_add(self.pending)
}
pub(crate) fn passed(&self) -> bool {
self.done() > self.work.limit
}
}
impl Drop for Counted<'_> {
fn drop(&mut self) {
self.work.add(self.pending);
}
}