EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
GPU: an effect kernel the shader compiler rejects no longer turns the GPU compositor off (#613)
Claudee2a47495eb8a
diff --git a/crates/gpu/src/context.rs b/crates/gpu/src/context.rsindex e994dd1bd..c5065eae5 100644--- a/crates/gpu/src/context.rs+++ b/crates/gpu/src/context.rs@@ -18,14 +18,6 @@ const ENTRIES: &[&str] = &["quantize","convert","half",- "box_h",- "box_v",- "directional",- "glow_bright",- "glow_combine",- "shadow_make",- "shadow_combine",- "pointwise","adjust_mix","bokeh_boost","bokeh_prefix",@@ -33,6 +25,11 @@ const ENTRIES: &[&str] = &["fill",];+/// Effect entry points in `kernels.wgsl`. Like the `fx_*` kernels, one that fails to build+/// (a driver's shader compiler rejecting it, #613) leaves its effects to the CPU instead of+/// turning the whole compositor off.+const EFFECT_ENTRIES: &[&str] = &["box_h", "box_v", "directional", "glow_bright", "glow_combine", "shadow_make", "shadow_combine", "pointwise"];+/// Entry points that also bind group 1 (four read-only storage buffers; see/// [`Enc::dispatch_ext`]).const EXT_ENTRIES: &[&str] = &["classic3d"];@@ -244,6 +241,8 @@ pub struct GpuContext {bgl: wgpu::BindGroupLayout,bgl_ext: wgpu::BindGroupLayout,pipelines: HashMap<&'static str, wgpu::ComputePipeline>,+ /// Effect kernels that failed to build, and why (their effects render on the CPU).+ unavailable: Vec<(&'static str, String)>,display_bgl: wgpu::BindGroupLayout,display: wgpu::ComputePipeline,/// The display texture's next mip level from the one above (`display.wgsl` `mip`).@@ -450,7 +449,29 @@ impl GpuContext {immediate_size: 0,})})?;- let pipelines = ENTRIES+ let build = |e: &'static str, layout: &wgpu::PipelineLayout| {+ init_resource(&device, e, || {+ device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {+ label: Some(e),+ layout: Some(layout),+ module: &module,+ entry_point: Some(e),+ compilation_options: Default::default(),+ cache: None,+ })+ })+ };+ // The compositor's own kernels are required; an effect kernel that doesn't build is+ // left out, and its effects render on the CPU (see `Enc::take_missing`).+ let mut pipelines = ENTRIES+ .iter()+ .chain(crate::adv3d::SKY_KERNELS)+ .map(|e| (e, &layout))+ .chain(EXT_ENTRIES.iter().map(|e| (e, &layout_ext)))+ .map(|(e, layout)| Ok((*e, build(e, layout)?)))+ .collect::<Result<HashMap<_, _>, String>>()?;+ let mut unavailable = vec![];+ for e in EFFECT_ENTRIES.iter().chain(crate::fx_color::KERNELS).chain(crate::fx_distort::KERNELS)@@ -472,23 +493,17 @@ impl GpuContext {.chain(crate::fx_time::KERNELS).chain(crate::fx_pixel2::KERNELS).chain(crate::fx_gen2::KERNELS)- .chain(crate::adv3d::SKY_KERNELS)- .map(|e| (e, &layout))- .chain(EXT_ENTRIES.iter().map(|e| (e, &layout_ext)))- .map(|(e, layout)| {- let p = init_resource(&device, e, || {- device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {- label: Some(e),- layout: Some(layout),- module: &module,- entry_point: Some(e),- compilation_options: Default::default(),- cache: None,- })- })?;- Ok((*e, p))- })- .collect::<Result<HashMap<_, _>, String>>()?;+ {+ match build(e, &layout) {+ Ok(p) => {+ pipelines.insert(*e, p);+ }+ Err(why) => {+ log::warn!("gpu {name}: kernel {e} unavailable, its effects render on the CPU: {why}");+ unavailable.push((*e, why));+ }+ }+ }let dmodule = init_resource(&device, "display shader module", || {device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some("effectcraft display"),@@ -547,6 +562,7 @@ impl GpuContext {bgl,bgl_ext,pipelines,+ unavailable,display_bgl,display,display_mip,@@ -721,6 +737,18 @@ impl GpuContext {/// Readbacks (GPU → CPU) are possible: waited for natively, or deferred (a browser/// worker, [`crate::deferred`]). Impossible on the browser's main thread.+ /// Effect kernels the device couldn't build, with why: their effects render on the CPU.+ pub fn unavailable_kernels(&self) -> &[(&'static str, String)] {+ &self.unavailable+ }++ /// Leave kernel `entry` out, as if it had failed to build (tests of the CPU fallback).+ #[cfg(test)]+ pub(crate) fn drop_kernel(&mut self, entry: &'static str) {+ self.pipelines.remove(entry);+ self.unavailable.push((entry, "dropped by a test".into()));+ }+pub fn can_readback(&self) -> bool {self.readbacks.check().is_ok() && (self.can_wait() || self.deferred.is_some())}@@ -859,6 +887,8 @@ pub(crate) struct Enc<'g> {/// The open command encoder and its id in the texture pool.enc: Option<(wgpu::CommandEncoder, u64)>,pending: usize,+ /// A dispatch named a kernel the device doesn't have (see [`Enc::take_missing`]).+ missing: bool,}impl Drop for Enc<'_> {@@ -874,7 +904,13 @@ impl Drop for Enc<'_> {impl<'g> Enc<'g> {pub fn new(g: &'g GpuContext) -> Enc<'g> {- Enc { g, enc: None, pending: 0 }+ Enc { g, enc: None, pending: 0, missing: false }+ }++ /// Whether a dispatch since the last call named a kernel the device doesn't have (one+ /// that failed to build): its output is wrong, and the effect must render on the CPU.+ pub(crate) fn take_missing(&mut self) -> bool {+ std::mem::take(&mut self.missing)}pub(crate) fn encoder(&mut self) -> &mut wgpu::CommandEncoder {@@ -954,7 +990,10 @@ impl<'g> Enc<'g> {) {let g = self.g;let Some(pipe) = g.pipelines.get(entry) else {- log::error!("gpu: no kernel {entry}");+ if !g.unavailable.iter().any(|(e, _)| *e == entry) {+ log::error!("gpu: no kernel {entry}");+ }+ self.missing = true;return;};let ub = g.device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: None, contents: &p.bytes(), usage: wgpu::BufferUsages::UNIFORM });diff --git a/crates/gpu/src/effects.rs b/crates/gpu/src/effects.rsindex 00cc4fd97..426931d78 100644--- a/crates/gpu/src/effects.rs+++ b/crates/gpu/src/effects.rs@@ -66,8 +66,12 @@ pub(crate) fn run_chain(e: &mut Enc, chain: &[FxStep], buf: &Buf, levels: Option}let misses = deferred.as_ref().map(|d| d.misses());let mut b = GBuf { img: e.g.upload_image(&buf.img)?, offset: buf.offset, scale: buf.scale };+ e.take_missing();for step in chain {b = apply(e, step.spec.id, &step.ctx, b)?;+ if e.take_missing() {+ return None;+ }if let Some(l) = levels {b.img = ops::quantize(e, &b.img, l);}@@ -119,8 +123,13 @@ impl effectcraft_render::FxTarget for GpuFx<'_, '_> {fn gpu(&mut self, steps: &[FxStep]) -> bool {let Some(b) = &self.b else { return false };let mut cur = GBuf { img: b.img.clone(), offset: b.offset, scale: b.scale };+ self.e.take_missing();for step in steps {let Some(next) = apply(self.e, step.spec.id, &step.ctx, cur) else { return false };+ // A kernel the device couldn't build: the effects render on the CPU (#613).+ if self.e.take_missing() {+ return false;+ }cur = next;if let Some(l) = self.levels {cur.img = ops::quantize(self.e, &cur.img, l);diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rsindex 39be29a97..3629d8ead 100644--- a/crates/gpu/src/tests.rs+++ b/crates/gpu/src/tests.rs@@ -745,3 +745,35 @@ fn within_memory_returns_the_work_when_there_is_room() {let img = g.within_memory(|| g.ctx.image(64, 32)).expect("room for a 64×32 texture");assert_eq!((img.width, img.height), (64, 32));}++/// #613: an effect kernel the device's shader compiler rejects (FXC on DirectX 12 aborting on+/// `pointwise`) no longer turns the whole GPU compositor off: the context is built without it,+/// lists it, and the effects that need it render on the CPU, matching the CPU render.+#[test]+fn effects_whose_kernels_failed_render_on_the_cpu() {+ if gpu().is_none() {+ return;+ }+ let Ok(mut ctx) = pollster::block_on(crate::context::GpuContext::request()) else { return };+ ctx.drop_kernel("pointwise");+ ctx.drop_kernel("box_h");+ let names: Vec<&str> = ctx.unavailable_kernels().iter().map(|(e, _)| *e).collect();+ assert_eq!(names, ["pointwise", "box_h"]);+ let g = Gpu::from_context(ctx);+ for depth in [BitDepth::Bpc8, BitDepth::Bpc32] {+ let mut s = Scene::new(depth);+ let mut l = s.footage(80, 50);+ s.effect(&mut l, "ec.color.exposure", &[("master/exposure", n(0.7))]);+ s.effect(&mut l, "ec.color.tint", &[("black", c(0.1, 0.0, 0.3)), ("amount", n(80.0))]);+ s.effect(&mut l, "ec.blur.gaussian", &[("blurriness", n(5.0))]);+ s.effect(&mut l, "ec.channel.invert", &[("blend", n(50.0))]);+ s.push(l);+ let cpu = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Cpu, ..opts() }).comp_frame_cpu(s.cid, Tick::ZERO);+ let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });+ r.accel = Some(&g);+ let img = g.render(&r, s.cid, Tick::ZERO).expect("the GPU renders the frame");+ let mut d = diff(&cpu, &img, tolerance(depth));+ d.quantized = depth != BitDepth::Bpc32;+ check(&format!("missing kernels {depth:?}"), Some(d), 0.0);+ }+}