LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M5.6: a view slot renders one job at a time, so a drag's renders don't pile up
Matthew James Sivakd7037d117f77
diff --git a/crates/preview/src/pool.rs b/crates/preview/src/pool.rsindex 4dbd35661..285cfd802 100644--- a/crates/preview/src/pool.rs+++ b/crates/preview/src/pool.rs@@ -30,6 +30,11 @@ struct Entry<S, R> {struct Shared<S, R> {queue: Mutex<Vec<Entry<S, R>>>,+ /// Slots with a job running: their next job waits until it ends, so a slot never has two at+ /// once (a slider drag submits faster than renders finish; overlapping renders of one view+ /// were mostly thrown away, and took the GPU from the one that is shown). Locked inside+ /// `queue`.+ busy: Mutex<Vec<S>>,cv: Condvar,shutdown: AtomicBool,/// The worker threads that have not ended yet, and the signal that one did.@@ -73,6 +78,7 @@ impl<S: Copy + Eq + Hash + Send + 'static, R: Send + 'static> JobPool<S, R> {JobPool {shared: Arc::new(Shared {queue: Mutex::new(Vec::new()),+ busy: Mutex::new(Vec::new()),cv: Condvar::new(),shutdown: AtomicBool::new(false),#[cfg(not(target_arch = "wasm32"))]@@ -119,6 +125,8 @@ impl<S: Copy + Eq + Hash + Send + 'static, R: Send + 'static> JobPool<S, R> {let _ended = Ended(&shared);while let Some(e) = take(&shared, true) {let t0 = std::time::Instant::now();+ // the slot is free again when the job ends, also if it panics+ let _free = Free(&shared, e.slot);let result = (e.job)();let done = Done { slot: e.slot, key: e.key, result, ms: t0.elapsed().as_secs_f64() * 1000.0 };if tx.send(done).is_err() {@@ -219,6 +227,7 @@ impl<S: Copy + Eq + Hash + Send + 'static, R: Send + 'static> JobPool<S, R> {let mut ran = 0;while ran < n {let Some(e) = take(&self.shared, false) else { break };+ let _free = Free(&self.shared, e.slot);let result = (e.job)();let _ = self.tx.send(Done { slot: e.slot, key: e.key, result, ms: 0.0 });ran += 1;@@ -229,14 +238,21 @@ impl<S: Copy + Eq + Hash + Send + 'static, R: Send + 'static> JobPool<S, R> {/// Pop the best job (highest priority, newest first). Blocks when `wait` until one is queued or/// the pool shuts down.-fn take<S, R>(shared: &Shared<S, R>, wait: bool) -> Option<Entry<S, R>> {+fn take<S: PartialEq + Copy, R>(shared: &Shared<S, R>, wait: bool) -> Option<Entry<S, R>> {let mut q = shared.queue.lock().unwrap_or_else(|e| e.into_inner());loop {if shared.shutdown.load(Ordering::Relaxed) {return None;}- if let Some(i) = q.iter().enumerate().max_by_key(|(_, e)| (e.priority, e.seq)).map(|(i, _)| i) {- return Some(q.swap_remove(i));+ // (a slot with a job running waits for it: see `Shared::busy`)+ let best = {+ let busy = shared.busy.lock().unwrap_or_else(|e| e.into_inner());+ q.iter().enumerate().filter(|(_, e)| !busy.contains(&e.slot)).max_by_key(|(_, e)| (e.priority, e.seq)).map(|(i, _)| i)+ };+ if let Some(i) = best {+ let e = q.swap_remove(i);+ shared.busy.lock().unwrap_or_else(|e| e.into_inner()).push(e.slot);+ return Some(e);}if !wait {return None;@@ -245,6 +261,28 @@ fn take<S, R>(shared: &Shared<S, R>, wait: bool) -> Option<Entry<S, R>> {}}+/// The job for `slot` ended: a job queued for it may start.+fn finished<S: PartialEq, R>(shared: &Shared<S, R>, slot: &S) {+ {+ // under the queue lock: a worker is either before its look at `busy` or waiting+ let _q = shared.queue.lock().unwrap_or_else(|e| e.into_inner());+ let mut busy = shared.busy.lock().unwrap_or_else(|e| e.into_inner());+ if let Some(i) = busy.iter().position(|s| s == slot) {+ busy.swap_remove(i);+ }+ }+ shared.cv.notify_all();+}++/// Frees a job's slot when the job ends (see [`finished`]).+struct Free<'a, S: PartialEq, R>(&'a Shared<S, R>, S);++impl<S: PartialEq, R> Drop for Free<'_, S, R> {+ fn drop(&mut self) {+ finished(self.0, &self.1);+ }+}+/// Takes a worker off the live list when its thread ends (also when a job panicked).#[cfg(not(target_arch = "wasm32"))]struct Ended<'a, S, R>(&'a Shared<S, R>);diff --git a/crates/preview/src/tests.rs b/crates/preview/src/tests.rsindex d733ad829..718fa0d20 100644--- a/crates/preview/src/tests.rs+++ b/crates/preview/src/tests.rs@@ -351,3 +351,79 @@ fn disk_cache_never_touches_foreign_files() {assert!(!disk::is_cache_file("01", "0123456789abcdef0123456789abcdef.jpg.bak"));let _ = std::fs::remove_dir_all(&dir);}++/// Wait up to `secs` for `f` to hold.+fn eventually(secs: u64, mut f: impl FnMut() -> bool) -> bool {+ let t0 = std::time::Instant::now();+ while t0.elapsed() < std::time::Duration::from_secs(secs) {+ if f() {+ return true;+ }+ std::thread::sleep(std::time::Duration::from_millis(5));+ }+ false+}++/// A slider drag submits for a view faster than its renders finish. A newer job for a slot used+/// to start beside the running one on another worker: one view's renders piled up on the GPU and+/// most were thrown away. Now a slot runs one job at a time: the newer one waits (replacing an+/// older one still queued), other slots keep going, and it starts when the slot's job ends.+#[test]+fn a_slot_runs_one_job_at_a_time() {+ use std::sync::atomic::{AtomicUsize, Ordering};+ let mut p: JobPool<u8, u32> = JobPool::new(4);+ let (release, released) = std::sync::mpsc::channel::<()>();+ let (started, has_started) = std::sync::mpsc::channel();+ let running = Arc::new(AtomicUsize::new(0));+ let most = Arc::new(AtomicUsize::new(0));+ let job = |n: u32, wait: Option<std::sync::mpsc::Receiver<()>>| -> crate::pool::Job<u32> {+ let (running, most, started) = (running.clone(), most.clone(), started.clone());+ Box::new(move || {+ let now = running.fetch_add(1, Ordering::SeqCst) + 1;+ most.fetch_max(now, Ordering::SeqCst);+ let _ = started.send(n);+ if let Some(w) = wait {+ let _ = w.recv_timeout(std::time::Duration::from_secs(30));+ }+ running.fetch_sub(1, Ordering::SeqCst);+ n+ })+ };+ p.submit(1, 1, 9, job(1, Some(released)));+ assert_eq!(has_started.recv().unwrap(), 1);+ // two newer requests for the busy slot: the second replaces the first, neither starts+ p.submit(1, 2, 9, job(2, None));+ p.submit(1, 3, 9, job(3, None));+ // another slot is not held up+ p.submit(2, 9, 1, Box::new(|| 9));+ let mut done = Vec::new();+ assert!(eventually(10, || {+ done.extend(std::iter::from_fn(|| p.try_recv()).map(|d| d.result));+ done.contains(&9)+ }));+ std::thread::sleep(std::time::Duration::from_millis(50));+ assert!(has_started.try_recv().is_err(), "a second job of slot 1 started beside the first");+ assert!(p.is_queued(1));+ drop(release);+ assert!(eventually(10, || {+ done.extend(std::iter::from_fn(|| p.try_recv()).map(|d| d.result));+ done.contains(&3)+ }));+ assert!(!done.contains(&2), "the replaced job never runs");+ assert_eq!(most.load(Ordering::SeqCst), 1, "slot 1 ran two jobs at once");+}++/// A job that panics still frees its slot: the slot's next job runs (on another worker).+#[test]+fn a_panicking_job_frees_its_slot() {+ let mut p: JobPool<u8, u32> = JobPool::new(2);+ p.submit(1, 1, 9, Box::new(|| panic!("simulated render panic")));+ assert!(eventually(10, || !p.is_queued(1) && p.live_workers() == 1));+ p.submit(1, 2, 9, Box::new(|| 2));+ let mut got = None;+ assert!(eventually(10, || {+ got = got.or_else(|| p.try_recv().map(|d| d.result));+ got.is_some()+ }));+ assert_eq!(got, Some(2));+}