EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Export: cap GPU frames rendering at once (#879)
Matej Kozlovský742472440eda
diff --git a/crates/export/src/pipeline.rs b/crates/export/src/pipeline.rsindex 7b451726d..e58ee849c 100644--- a/crates/export/src/pipeline.rs+++ b/crates/export/src/pipeline.rs@@ -15,6 +15,36 @@ use web_time::Instant;use crate::{Job, RenderQuality, out};+/// GPU frames rendered at once by default, the same cap as the export scheduler's+/// `MAX_INFLIGHT` (3 hides readback and recording without stacking up working textures).+pub(crate) const GPU_INFLIGHT_DEFAULT: usize = 3;+/// Overrides [`GPU_INFLIGHT_DEFAULT`]: a whole number of frames, at least 1.+pub(crate) const GPU_INFLIGHT_ENV: &str = "EFFECTCRAFT_GPU_INFLIGHT";++/// GPU frames in flight from the `EFFECTCRAFT_GPU_INFLIGHT` value: a positive whole number, or+/// the default when it is unset, 0 or not a number.+pub(crate) fn gpu_inflight(var: Option<&str>) -> usize {+ var.and_then(|v| v.trim().parse::<usize>().ok()).filter(|&n| n >= 1).unwrap_or(GPU_INFLIGHT_DEFAULT)+}++/// `f` over the frames `ks` in parallel, results in `ks` order. With `cap`, at most that many+/// run at once: the frames go in consecutive chunks of `cap`, each rendered in parallel. A+/// chunk holds no lock or slot, so a failing or panicking frame cannot leak one, and nested+/// parallelism inside `f` (or a single thread) cannot deadlock.+pub(crate) fn map_frames<T: Send>(ks: Vec<u64>, cap: Option<usize>, f: impl Fn(u64) -> T + Sync + Send) -> Vec<T> {+ use rayon::prelude::*;+ match cap {+ None => ks.into_par_iter().map(f).collect(),+ Some(n) => {+ let mut out = Vec::with_capacity(ks.len());+ for chunk in ks.chunks(n.max(1)) {+ out.par_extend(chunk.par_iter().map(|&k| f(k)));+ }+ out+ }+ }+}+/// A job being exported: the job, the project with the Render Settings overrides applied, the/// job's layer cache and per-frame timing for the render log.pub(crate) struct Cx<'a> {@@ -132,8 +162,11 @@ impl<'a> Cx<'a> {}return out;}- use rayon::prelude::*;- ks.into_par_iter().map(|k| f(k, self.frame(comp, k))).collect()+ // #879: with a GPU accelerator every frame in flight holds its own working textures, so+ // a whole batch rendered at once can exhaust VRAM (or shared memory, which crashes+ // instead of falling back). Cap the frames rendering at once; the CPU path is unchanged.+ let cap = self.job.accel.map(|_| gpu_inflight(std::env::var(GPU_INFLIGHT_ENV).ok().as_deref()));+ map_frames(ks, cap, |k| f(k, self.frame(comp, k)))}/// Output frame `i`: sampled (fields, pulldown), at the colour depth, cropped and resized.@@ -367,6 +400,83 @@ fn premultiplied8(img: &Image) -> Vec<u8> {#[cfg(test)]mod tests {use super::*;+ use rayon::prelude::*;++ /// Frames `0..n` through [`map_frames`] with `cap`, recording the most running at once.+ fn run_capped(n: u64, cap: Option<usize>) -> (Vec<u64>, usize) {+ use std::sync::atomic::{AtomicUsize, Ordering};+ let (now, max) = (AtomicUsize::new(0), AtomicUsize::new(0));+ let out = map_frames((0..n).collect(), cap, |k| {+ let c = now.fetch_add(1, Ordering::SeqCst) + 1;+ max.fetch_max(c, Ordering::SeqCst);+ std::thread::sleep(std::time::Duration::from_millis(2));+ now.fetch_sub(1, Ordering::SeqCst);+ k * 10+ });+ (out, max.load(Ordering::SeqCst))+ }++ #[test]+ fn capped_frames_keep_their_order() {+ let want: Vec<u64> = (0..40).map(|k| k * 10).collect();+ for cap in [None, Some(1), Some(3), Some(7)] {+ assert_eq!(run_capped(40, cap).0, want, "cap {cap:?}");+ }+ }++ #[test]+ fn gpu_frames_in_flight_respect_the_cap() {+ // #879: every frame of a batch rendered on the GPU at once and exhausted VRAM.+ let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();+ pool.install(|| {+ for cap in [1, 2, 3] {+ let (out, max) = run_capped(30, Some(cap));+ assert_eq!(out.len(), 30);+ assert!(max <= cap, "cap {cap}: {max} frames ran at once");+ }+ });+ }++ #[test]+ fn a_cap_above_the_frame_count_renders_them_all() {+ let (out, max) = run_capped(2, Some(8));+ assert_eq!(out, vec![0, 10]);+ assert!(max <= 2);+ assert!(run_capped(0, Some(3)).0.is_empty());+ }++ #[test]+ fn cap_one_on_a_single_thread_does_not_deadlock() {+ let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap();+ let (out, max) = pool.install(|| run_capped(10, Some(1)));+ assert_eq!(out.len(), 10);+ assert_eq!(max, 1);+ // Nested parallelism inside a frame (as the renderer has) on one thread.+ let out = pool.install(|| map_frames((0..6).collect(), Some(2), |k| (0..4u64).into_par_iter().map(|i| i + k).sum::<u64>()));+ assert_eq!(out, (0..6).map(|k| 6 + 4 * k).collect::<Vec<_>>());+ }++ #[test]+ fn a_failing_frame_does_not_hold_up_the_rest() {+ let out = map_frames((0..9).collect(), Some(1), |k| if k == 3 { Err(k) } else { Ok(k) });+ assert_eq!(out.iter().filter(|r| r.is_err()).count(), 1);+ assert_eq!(out.len(), 9);+ assert_eq!(out[8], Ok(8));+ // A panicking frame propagates once and leaves no slot behind: the next batch runs.+ let r = std::panic::catch_unwind(|| map_frames((0..6).collect(), Some(2), |k| if k == 2 { panic!("frame {k}") } else { k }));+ assert!(r.is_err());+ assert_eq!(run_capped(6, Some(2)).0.len(), 6);+ }++ #[test]+ fn gpu_inflight_override_is_a_positive_number_or_the_default() {+ assert_eq!(gpu_inflight(None), GPU_INFLIGHT_DEFAULT);+ assert_eq!(gpu_inflight(Some("1")), 1);+ assert_eq!(gpu_inflight(Some(" 5 ")), 5);+ for bad in ["0", "", "-2", "three", "2.5"] {+ assert_eq!(gpu_inflight(Some(bad)), GPU_INFLIGHT_DEFAULT, "{bad:?}");+ }+ }#[test]fn layers_render_once_per_job() {