diff --git a/crates/media/src/pool.rs b/crates/media/src/pool.rs index 52966991d..9be4a3fd7 100644 --- a/crates/media/src/pool.rs +++ b/crates/media/src/pool.rs @@ -215,9 +215,15 @@ struct CacheState { /// decoded again (#3269), and comes out as if decoded on its own. Not in the frame cache: a /// large plate shown reduced is not kept whole there (#1812). recent: VecDeque, - /// Counts `forget` calls: a decode that started before one doesn't keep its picture (the file - /// may have changed meanwhile). + /// Counts `forget` calls (an epoch requests and decodes start in; see [`CacheState::stale`]). generation: u64, + /// The generation each path was last forgotten at (at most [`MAX_FORGOTTEN`] paths): a + /// request or decode of that path that started before it is stale (the file may have changed + /// meanwhile), one of another path is not. + forgotten: HashMap, u64>, + /// Requests and decodes that started before this generation are stale whatever their path + /// (set when `forgotten` is cleared to keep it bounded). + stale_before: u64, /// Last frame index requested per movie (sequential-playback detection). last: HashMap, i64>, } @@ -233,7 +239,28 @@ struct Recent { stamp: u64, } +/// At most this many forgotten paths are remembered ([`CacheState::forgotten`]); beyond that +/// everything that started before is treated as stale instead. +const MAX_FORGOTTEN: usize = 4096; + impl CacheState { + /// Whether what was made of `path` by a request or decode that started at `generation` is + /// stale: the path was forgotten since (#3269 review: forgetting one file left every other + /// file's decodes uncached and unshared). + fn stale(&self, path: &str, generation: u64) -> bool { + generation < self.stale_before || self.forgotten.get(path).is_some_and(|&at| at > generation) + } + + /// Note that `path` was forgotten. + fn forgot(&mut self, path: &str) { + self.generation = self.generation.saturating_add(1); + if self.forgotten.len() >= MAX_FORGOTTEN { + self.forgotten.clear(); + self.stale_before = self.generation; + } + self.forgotten.insert(path.into(), self.generation); + } + /// The whole still `key` decoded recently, with the files it was decoded from, if it is /// still kept. fn recent(&mut self, key: &Key) -> Option<(Arc, Arc)> { @@ -519,7 +546,7 @@ impl Drop for Owner<'_> { let budget = self.inner.budget(); let mut c = lock(&self.inner.cache); if let (Ok(img), files) = &outcome - && c.generation == self.generation + && !c.stale(&self.key.path, self.generation) { if self.as_asked { c.lru.insert(self.key.clone(), img.clone(), files.clone(), budget); @@ -643,7 +670,7 @@ impl MediaPool { c.lru.remove(&k); } c.recent.retain(|r| &*r.key.path != path); - c.generation = c.generation.wrapping_add(1); + c.forgot(path); c.last.remove(path); drop(c); crate::exr_planes::forget(path); @@ -1139,7 +1166,7 @@ impl Inner { } } // (one started before the file was forgotten is left to its own requests) - let Some(flight) = c.inflight.get(&source.key).filter(|f| f.generation == generation).cloned() else { break }; + let Some(flight) = c.inflight.get(&source.key).filter(|f| !c.stale(&source.key.path, f.generation)).cloned() else { break }; // Another request (or the read-ahead) is decoding this picture: wait for it. drop(c); self.misses.fetch_add(1, Ordering::Relaxed); @@ -1209,11 +1236,11 @@ impl Inner { Ok(Self::sized_still(Arc::new(img?), loc, footage)) } - /// Keep `img`, made of `files`, in the frame cache as `key` (unless a file was forgotten - /// since `generation`, see [`CacheState::generation`]), and return it. + /// Keep `img`, made of `files`, in the frame cache as `key` (unless its file was forgotten + /// since `generation`, see [`CacheState::stale`]), and return it. fn keep(&self, key: &Key, img: Arc, files: Arc, generation: u64) -> Arc { let mut c = lock(&self.cache); - if c.generation == generation { + if !c.stale(&key.path, generation) { c.lru.insert(key.clone(), img.clone(), files, self.budget()); } drop(c); @@ -2245,4 +2272,59 @@ mod tests { let again = pool.frame_at(&f, Tick::ZERO).unwrap(); assert!(again.data.iter().any(|p| p[0] > 0.0), "the old decode's pixels were not kept"); } + + /// #3270 review: forgetting one file (a file watcher's change, `add_bytes`) leaves another + /// file's decode in flight joinable and cached: a global count made every other decode + /// stale, so requests decoded those files again and nothing was kept. + #[test] + fn forgetting_one_file_keeps_another_files_decode() { + let pool = MediaPool::new(); + let f = plate(&pool, "/a.exr"); + let other = plate(&pool, "/b.exr"); + let (pool_a, f_a) = (pool.clone(), f.clone()); + let started = Arc::new(std::sync::atomic::AtomicBool::new(false)); + let started_a = started.clone(); + // The decode waits (2 s at most) for a request to join it, then decodes the file. + *lock(&pool.inner.gate) = { + let inner = Arc::downgrade(&pool.inner); + Some(Arc::new(move || { + started_a.store(true, Ordering::SeqCst); + let until = std::time::Instant::now() + std::time::Duration::from_secs(2); + while inner.upgrade().is_some_and(|i| i.waiting.load(Ordering::SeqCst) < 1) && std::time::Instant::now() < until { + std::thread::sleep(std::time::Duration::from_millis(1)); + } + None + })) + }; + std::thread::scope(|s| { + let first = s.spawn(move || pool_a.frame_at(&f_a, Tick::ZERO)); + while !started.load(Ordering::SeqCst) { + std::thread::sleep(std::time::Duration::from_millis(1)); + } + pool.forget(&other.path); + let joined = pool.frame_at(&f, Tick::ZERO).unwrap(); + let first = first.join().unwrap().unwrap(); + assert!(Arc::ptr_eq(&joined, &first), "the request joined the decode in flight"); + }); + assert_eq!(pool.stats().decodes, 1, "one decode"); + pool.frame_at(&f, Tick::ZERO).unwrap(); + assert_eq!(pool.stats().decodes, 1, "and its picture was kept"); + *lock(&pool.inner.gate) = None; + } + + /// Forgotten paths are remembered per path and boundedly: past [`MAX_FORGOTTEN`], everything + /// that started before counts as stale. + #[test] + fn forgotten_paths_stay_bounded() { + let mut c = CacheState::default(); + let at = c.generation; + c.forgot("/a.exr"); + assert!(c.stale("/a.exr", at) && !c.stale("/b.exr", at) && !c.stale("/a.exr", c.generation)); + for i in 0..MAX_FORGOTTEN + 10 { + c.forgot(&format!("/{i}.exr")); + } + assert!(c.forgotten.len() <= MAX_FORGOTTEN); + assert!(c.stale("/b.exr", at), "older than the remembered paths: stale"); + assert!(!c.stale("/b.exr", c.generation)); + } }