Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Viewer: dragging a layer no longer piles up frame renders until memory runs out (#647)

Clauded247b98b9563
diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs
index 33fd676d2..ccffeb9f9 100644
--- a/crates/ui-egui/src/frames.rs
+++ b/crates/ui-egui/src/frames.rs
@@ -768,10 +768,8 @@ impl Frames {
#[cfg(not(target_arch = "wasm32"))]
if self.remote.is_none() {
let w = self.worker();
- // One spawn per job; each spawn renders whichever queued job matters most right now.
- let job = move || {
- w.run_next();
- };
+ // One spawn per job; each spawn renders whichever queued jobs matter most right now.
+ let job = move || w.drain();
match &self.pool {
Some(pool) => pool.spawn(job),
None => rayon::spawn(job),
@@ -924,7 +922,42 @@ struct Worker {
gpu_retired: Arc<AtomicBool>,
}
+#[cfg(not(target_arch = "wasm32"))]
+thread_local! {
+ /// This pool thread is inside [`Worker::drain`] (rendering a frame).
+ static DRAINING: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+/// Clears [`DRAINING`] when the drain ends, even by a panic.
+#[cfg(not(target_arch = "wasm32"))]
+struct Draining;
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Drop for Draining {
+ fn drop(&mut self) {
+ DRAINING.set(false);
+ }
+}
+
impl Worker {
+ /// Render queued jobs, most important first, until the queue is empty.
+ ///
+ /// A pool thread waiting inside a render (on a parallel loop's join) runs other pool work
+ /// meanwhile, including the spawns of newer requests: each would start a whole frame render
+ /// on top of the one waiting, with all of its buffers. Dragging a layer asks for a new frame
+ /// every UI frame, so renders piled up on every thread until memory ran out (#647). A spawn
+ /// that lands inside a render returns at once instead; the render below it takes the queued
+ /// jobs when it is done, so each thread renders one frame at a time.
+ #[cfg(not(target_arch = "wasm32"))]
+ fn drain(&self) {
+ if DRAINING.get() {
+ return;
+ }
+ DRAINING.set(true);
+ let _reset = Draining;
+ while self.run_next() {}
+ }
+
/// Render the queued job that matters most right now. `false` when the queue was empty.
fn run_next(&self) -> bool {
let Worker { queue, content_keys, .. } = self;
@@ -1234,6 +1267,80 @@ mod tests {
assert!(!f.is_cached(&key));
}
+ /// #647: a pool thread waiting inside a render (on a parallel loop) never starts another
+ /// frame render on top of it. Dragging a layer queues a frame every UI frame; renders used to
+ /// nest on every thread, each holding its buffers, until memory ran out.
+ #[test]
+ fn a_waiting_render_never_starts_another_on_its_thread() {
+ use effectcraft_engine::Session;
+ use effectcraft_engine::project::{Footage, FootageKind};
+ use effectcraft_engine::render::Image;
+ use effectcraft_engine::time::FrameRate;
+ use serde_json::json;
+ use std::cell::Cell;
+ use std::sync::atomic::AtomicUsize;
+ thread_local! {
+ static DEPTH: Cell<usize> = const { Cell::new(0) };
+ }
+ /// A decoder that works in parallel, as the renderer does: its thread joins the loop and
+ /// may wait for the parts other threads took.
+ #[derive(Default)]
+ struct Parallel {
+ calls: AtomicUsize,
+ deepest: AtomicUsize,
+ }
+ impl FootageSource for Parallel {
+ fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
+ let d = DEPTH.get() + 1;
+ DEPTH.set(d);
+ self.deepest.fetch_max(d, Ordering::SeqCst);
+ self.calls.fetch_add(1, Ordering::SeqCst);
+ (0..64).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1)));
+ DEPTH.set(d - 1);
+ Some(Arc::new(Image::new(4, 4)))
+ }
+ }
+ let mut s = Session::default();
+ let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
+ let clip = Footage {
+ kind: FootageKind::Video,
+ width: 4,
+ height: 4,
+ has_video: true,
+ frame_rate: FrameRate::FPS_30,
+ duration: Tick::from_seconds_f64(10.0),
+ ..Default::default()
+ };
+ let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
+ s.execute("layer.addItem", json!({"item": item.0})).unwrap();
+ let footage = Arc::new(Parallel::default());
+ let src = RenderSource {
+ project: s.project.clone(),
+ footage: footage.clone(),
+ expr: None,
+ layer_cache: Arc::default(),
+ gpu: None,
+ gpu_display: false,
+ disk: None,
+ };
+ let f = Frames::default();
+ let content = f.content_of(&s.project, s.revision, cid);
+ let frames = 60;
+ for frame in 0..frames {
+ let key = FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
+ f.request(&src, key, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
+ }
+ for _ in 0..4000 {
+ if f.inflight() == 0 {
+ break;
+ }
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ }
+ assert_eq!(f.inflight(), 0, "every queued frame rendered");
+ assert!(footage.calls.load(Ordering::SeqCst) >= frames as usize);
+ assert_eq!(footage.deepest.load(Ordering::SeqCst), 1, "renders nested on a waiting thread");
+ }
+
/// #284: scrubbing asks for a viewer frame at every step; a newer one drops the comp's viewer
/// frames still waiting (they would all render first), but not prefetch frames or another
/// comp's viewer frame.