LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Never crash: the work gate counts held bytes exactly past usize::MAX (#2576)
insideTheFluxbe252030745d
diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex f83adb9ac..e00155c62 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -2177,25 +2177,50 @@ mod tests {/// Issue #2576: work weighed with saturating maths can ask for `usize::MAX` bytes. Adding to/// that overflowed (a panic with the gate's mutex held in a debug build, a wrapped count that- /// let everything in for a release one); the count now saturates, and later work waits.+ /// let everything in for a release one). The count is now exact past `usize::MAX`: later work+ /// waits, whichever permit is released first, and even on a gate whose limit is `usize::MAX`.#[test]- fn work_gate_saturates_instead_of_overflowing() {+ fn work_gate_counts_past_usize_max_instead_of_overflowing() {use crate::memory::WorkGate;+ // a holder of one byte, on its own thread; still waiting 50 ms later+ let waiting = |g: &Arc<WorkGate>| {+ let g2 = g.clone();+ let t = std::thread::spawn(move || {+ let _b = g2.acquire(1);+ g2.usage().0+ });+ std::thread::sleep(std::time::Duration::from_millis(50));+ assert!(!t.is_finished(), "the next holder waits");+ t+ };++ // the huge permit released first: the urgent one is still countedlet g = Arc::new(WorkGate::new(100));let huge = g.acquire(usize::MAX);- let urgent = g.acquire_urgent(1);- assert_eq!(g.usage().0, usize::MAX);+ let urgent = g.acquire_urgent(101);+ assert_eq!(g.usage().0, usize::MAX, "reported saturated");+ drop(huge);+ assert_eq!(g.usage().0, 101);+ let t = waiting(&g);drop(urgent);- let g2 = g.clone();- let t = std::thread::spawn(move || {- let _b = g2.acquire(1);- g2.usage().0- });- std::thread::sleep(std::time::Duration::from_millis(50));- assert!(!t.is_finished(), "the second holder waits while the first holds everything");+ assert_eq!(t.join().unwrap(), 1);+ assert_eq!(g.usage().0, 0);++ // the urgent permit released first+ let huge = g.acquire(usize::MAX);+ drop(g.acquire_urgent(1));+ assert_eq!(g.usage().0, usize::MAX);+ let t = waiting(&g);drop(huge);assert_eq!(t.join().unwrap(), 1);assert_eq!(g.usage().0, 0);++ // a gate without a practical limit is still full when it holds usize::MAX+ let g = Arc::new(WorkGate::new(usize::MAX));+ let huge = g.acquire(usize::MAX);+ let t = waiting(&g);+ drop(huge);+ assert_eq!(t.join().unwrap(), 1);}#[test]diff --git a/crates/engine/src/memory.rs b/crates/engine/src/memory.rsindex a29355ab5..61a41f99c 100644--- a/crates/engine/src/memory.rs+++ b/crates/engine/src/memory.rs@@ -99,7 +99,10 @@ pub fn cache_share(budget: usize) -> usize {/// A weighted semaphore over bytes of working memory: [`WorkGate::acquire`] waits while other/// holders already use the limit (one holder may always proceed, whatever its size).pub struct WorkGate {- state: Mutex<(usize, usize)>,+ /// Bytes held and the limit. Held is a `u128`: callers weigh work with saturating maths, so a+ /// permit may hold `usize::MAX`, and the exact total of several such permits still fits, so+ /// releasing one in any order leaves the others counted (issue #2576).+ state: Mutex<(u128, usize)>,cv: Condvar,}@@ -114,7 +117,7 @@ impl WorkGate {WorkGate { state: Mutex::new((0, limit)), cv: Condvar::new() }}- fn lock(&self) -> std::sync::MutexGuard<'_, (usize, usize)> {+ fn lock(&self) -> std::sync::MutexGuard<'_, (u128, usize)> {self.state.lock().unwrap_or_else(|e| e.into_inner())}@@ -123,27 +126,27 @@ impl WorkGate {self.cv.notify_all();}- /// Bytes held now and the limit.+ /// Bytes held now (at most `usize::MAX`) and the limit.pub fn usage(&self) -> (usize, usize) {- *self.lock()+ let g = self.lock();+ (usize::try_from(g.0).unwrap_or(usize::MAX), g.1)}- /// Hold `bytes`, waiting until they fit (or nothing else is held). Callers weigh work with- /// saturating maths, so `bytes` may be `usize::MAX`: the count saturates there, never overflows- /// (issue #2576).+ /// Hold `bytes`, waiting until they fit (or nothing else is held). Even `usize::MAX` bytes on+ /// a gate whose limit is `usize::MAX` make the next holder wait.pub fn acquire(&self, bytes: usize) -> Permit<'_> {let mut g = self.lock();- while g.0 > 0 && g.0.saturating_add(bytes) > g.1 {+ while g.0 > 0 && g.0.saturating_add(bytes as u128) > g.1 as u128 {g = self.cv.wait(g).unwrap_or_else(|e| e.into_inner());}- g.0 = g.0.saturating_add(bytes);+ g.0 = g.0.saturating_add(bytes as u128);Permit { gate: self, bytes }}/// Hold `bytes` without waiting (interactive work): counted, so background work waits for it.pub fn acquire_urgent(&self, bytes: usize) -> Permit<'_> {let mut g = self.lock();- g.0 = g.0.saturating_add(bytes);+ g.0 = g.0.saturating_add(bytes as u128);Permit { gate: self, bytes }}}@@ -151,7 +154,7 @@ impl WorkGate {impl Drop for Permit<'_> {fn drop(&mut self) {let mut g = self.gate.lock();- g.0 = g.0.saturating_sub(self.bytes);+ g.0 = g.0.saturating_sub(self.bytes as u128);drop(g);self.gate.cv.notify_all();}