Files
effectcraft/crates/gpu/src/deferred.rs
T

294 lines
9.8 KiB
Rust
Raw Normal View History

//! Deferred readbacks: rendering on a device whose readbacks cannot be waited for (WebGPU in a
//! browser worker: a buffer maps only once the worker returns to its event loop).
//!
//! A frame renders in passes (see [`effectcraft_render::Accelerator::frame_begin`]). Every
//! readback the renderer needs is keyed by what determines its pixels: a GPU effect chain by
//! its input buffer's pixels and the chain's parameters, the top-level frame by comp, time and
//! render options. A key seen for the first time records the GPU work, starts an asynchronous
//! copy (`map_async`) and *misses*: the step returns a placeholder and the pass is marked missed
//! (raising the gate that keeps placeholder-derived buffers out of the layer cache). The caller
//! awaits [`Deferred::settled`] and renders again; keys whose bytes arrived are served from
//! here. A pass without a miss is the finished frame.
//!
//! Correctness: a result is only computed from genuine inputs. Pixels a chain reads are part
//! of its key, and a chain whose kernels read other data through the effect host (other layers,
//! other times) is not started when that data missed while it ran (the miss counter moved).
use std::collections::{HashMap, HashSet};
use std::future::Future;
use std::hash::{Hash, Hasher};
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, Waker};
use effectcraft_effects::Buf;
use effectcraft_render::FxStep;
/// Bytes read back for one key, with the geometry they describe.
#[derive(Clone, Debug)]
pub(crate) struct Readback {
pub bytes: Vec<u8>,
pub width: u32,
pub height: u32,
/// Layer buffer offset and scale (chains).
pub offset: [f64; 2],
pub scale: f64,
}
/// What [`Deferred::lookup`] knows about a key.
pub(crate) enum Lookup {
/// The bytes arrived (`None`: the readback failed; render this step another way).
Ready(Option<Readback>),
/// Started in this frame, not arrived yet.
InFlight,
/// Never asked for in this frame.
Absent,
}
#[derive(Default)]
struct State {
/// Frame generation: results of an older frame's readbacks are dropped.
generation: u64,
ready: HashMap<u128, Option<Readback>>,
waiting: HashSet<u128>,
in_flight: usize,
/// Misses so far in this frame (a counter, so a chain sees misses during its own work).
misses: u64,
wakers: Vec<Waker>,
}
/// Deferred readback state of a device (see the module docs).
#[derive(Default)]
pub struct Deferred {
st: Mutex<State>,
/// Raised from the pass's first miss to its end.
gate: Arc<AtomicBool>,
/// Passes and readbacks (diagnostics).
pub(crate) passes: std::sync::atomic::AtomicU64,
pub(crate) readbacks: std::sync::atomic::AtomicU64,
}
impl Deferred {
pub fn frame_begin(&self) {
if let Ok(mut s) = self.st.lock() {
s.generation += 1;
s.ready.clear();
s.waiting.clear();
s.misses = 0;
}
self.gate.store(false, Ordering::Relaxed);
}
pub fn pass_begin(&self) {
self.gate.store(false, Ordering::Relaxed);
self.passes.fetch_add(1, Ordering::Relaxed);
}
pub fn missed(&self) -> bool {
self.gate.load(Ordering::Relaxed)
}
pub fn gate(&self) -> Arc<AtomicBool> {
self.gate.clone()
}
/// Misses so far in this frame.
pub(crate) fn misses(&self) -> u64 {
self.st.lock().map(|s| s.misses).unwrap_or(0)
}
/// Mark the pass as missed.
pub(crate) fn miss(&self) {
if let Ok(mut s) = self.st.lock() {
s.misses += 1;
}
self.gate.store(true, Ordering::Relaxed);
}
pub(crate) fn lookup(&self, key: u128) -> Lookup {
let Ok(s) = self.st.lock() else { return Lookup::Ready(None) };
if let Some(r) = s.ready.get(&key) {
return Lookup::Ready(r.clone());
}
if s.waiting.contains(&key) { Lookup::InFlight } else { Lookup::Absent }
}
/// A readback for `key` is being started; returns the callback that stores its bytes.
pub(crate) fn start(self: &Arc<Self>, key: u128, width: u32, height: u32, offset: [f64; 2], scale: f64) -> impl FnOnce(Option<Vec<u8>>) + 'static {
let generation = match self.st.lock() {
Ok(mut s) => {
s.waiting.insert(key);
s.in_flight += 1;
s.generation
}
Err(_) => 0,
};
self.readbacks.fetch_add(1, Ordering::Relaxed);
let me = self.clone();
move |bytes: Option<Vec<u8>>| {
let wakers = match me.st.lock() {
Ok(mut s) => {
s.in_flight = s.in_flight.saturating_sub(1);
if s.generation == generation {
s.waiting.remove(&key);
s.ready.insert(key, bytes.map(|bytes| Readback { bytes, width, height, offset, scale }));
}
if s.in_flight == 0 { std::mem::take(&mut s.wakers) } else { vec![] }
}
Err(_) => vec![],
};
for w in wakers {
w.wake();
}
}
}
/// Readbacks still in flight.
pub fn in_flight(&self) -> usize {
self.st.lock().map(|s| s.in_flight).unwrap_or(0)
}
/// Resolves once no readback is in flight (on the web the browser's event loop delivers
/// them; natively a device poll does).
pub fn settled(self: &Arc<Self>) -> Settled {
Settled(self.clone())
}
}
/// See [`Deferred::settled`].
pub struct Settled(Arc<Deferred>);
impl Future for Settled {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
let Ok(mut s) = self.0.st.lock() else { return Poll::Ready(()) };
if s.in_flight == 0 {
return Poll::Ready(());
}
s.wakers.push(cx.waker().clone());
Poll::Pending
}
}
/// 128-bit key from two differently seeded std hashers (deterministic within a process).
pub(crate) struct Key(std::collections::hash_map::DefaultHasher, std::collections::hash_map::DefaultHasher);
impl Key {
pub fn new(tag: u64) -> Key {
let mut a = std::collections::hash_map::DefaultHasher::new();
let mut b = std::collections::hash_map::DefaultHasher::new();
tag.hash(&mut a);
(tag ^ 0x9e37_79b9_7f4a_7c15).hash(&mut b);
0xa5u8.hash(&mut b);
Key(a, b)
}
pub fn bytes(&mut self, v: &[u8]) {
self.0.write(v);
self.1.write(v);
}
pub fn u64(&mut self, v: u64) {
self.bytes(&v.to_le_bytes());
}
pub fn f64(&mut self, v: f64) {
self.u64(v.to_bits());
}
pub fn debug(&mut self, v: &impl std::fmt::Debug) {
self.bytes(format!("{v:?}").as_bytes());
self.bytes(&[0xff]);
}
pub fn finish(&self) -> u128 {
((self.0.finish() as u128) << 64) | self.1.finish() as u128
}
}
/// Key of a GPU effect chain on `buf`: the input pixels and geometry, the bit depth, and every
/// step's effect, parameters (sorted) and context.
pub(crate) fn chain_key(chain: &[FxStep], buf: &Buf, levels: Option<f32>) -> u128 {
let mut k = Key::new(1);
k.u64(buf.img.width as u64);
k.u64(buf.img.height as u64);
k.bytes(bytemuck::cast_slice(&buf.img.data));
k.f64(buf.offset[0]);
k.f64(buf.offset[1]);
k.f64(buf.scale);
k.debug(&levels);
for s in chain {
let c = &s.ctx;
k.bytes(s.spec.id.as_bytes());
let mut names: Vec<&String> = c.params.values.keys().collect();
names.sort();
for n in names {
k.bytes(n.as_bytes());
k.debug(&c.params.values[n]);
}
k.f64(c.time);
k.f64(c.layer_size[0]);
k.f64(c.layer_size[1]);
k.u64(c.seed as u64);
k.u64(c.adjustment as u64);
let e = &c.env;
k.debug(&e.masks);
k.u64(e.host.is_some() as u64);
k.f64(e.comp_time);
k.f64(e.frame_rate);
k.u64(e.effect_index as u64);
k.debug(&e.working_space);
k.u64(e.working_linear as u64);
k.debug(&e.shutter);
}
k.finish()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn keys_are_stable_and_distinct() {
let mut a = Key::new(1);
a.bytes(b"abc");
let mut b = Key::new(1);
b.bytes(b"abc");
let mut c = Key::new(2);
c.bytes(b"abc");
assert_eq!(a.finish(), b.finish());
assert_ne!(a.finish(), c.finish());
}
#[test]
fn readbacks_resolve_and_old_frames_are_dropped() {
let d = Arc::new(Deferred::default());
d.frame_begin();
d.pass_begin();
assert!(matches!(d.lookup(7), Lookup::Absent));
let done = d.start(7, 2, 1, [1.0, 2.0], 0.5);
d.miss();
assert!(d.missed() && d.gate().load(Ordering::Relaxed));
assert!(matches!(d.lookup(7), Lookup::InFlight));
assert_eq!(d.in_flight(), 1);
// The settle future wakes when the last readback lands.
let mut fut = std::pin::pin!(d.settled());
let waker = Waker::noop();
assert!(fut.as_mut().poll(&mut Context::from_waker(waker)).is_pending());
done(Some(vec![1, 2, 3, 4, 5, 6, 7, 8]));
assert!(fut.as_mut().poll(&mut Context::from_waker(waker)).is_ready());
let Lookup::Ready(Some(r)) = d.lookup(7) else { panic!("not ready") };
assert_eq!((r.width, r.height, r.offset, r.scale, r.bytes.len()), (2, 1, [1.0, 2.0], 0.5, 8));
d.pass_begin();
assert!(!d.missed());
// A readback of the previous frame arriving late is dropped.
let late = d.start(9, 1, 1, [0.0; 2], 1.0);
d.frame_begin();
late(Some(vec![0; 4]));
assert!(matches!(d.lookup(9), Lookup::Absent));
assert!(matches!(d.lookup(7), Lookup::Absent));
assert_eq!(d.in_flight(), 0);
}
}