Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(rendering): stop exports on readback allocation failure

Richie McIlroy82eb43943b0f
diff --git a/crates/rendering/src/frame_pipeline.rs b/crates/rendering/src/frame_pipeline.rs
index 458687ab3..f56dc0d11 100644
--- a/crates/rendering/src/frame_pipeline.rs
+++ b/crates/rendering/src/frame_pipeline.rs
@@ -1657,6 +1657,40 @@ fn active_readback_byte_len(
.filter(|&active_bytes| active_bytes > 0 && active_bytes <= mapped_bytes)
}
+fn allocate_readback(active_bytes: usize, frame_number: u32) -> Result<Vec<u8>, RenderingError> {
+ let allocation_failed = || RenderingError::ReadbackAllocationFailed { frame_number };
+ let capacity = active_bytes.checked_add(24).ok_or_else(allocation_failed)?;
+ #[cfg(test)]
+ let capacity = readback_allocation_failure::capacity(frame_number, capacity);
+ let mut data = Vec::new();
+ data.try_reserve_exact(capacity)
+ .map_err(|_| allocation_failed())?;
+ Ok(data)
+}
+
+#[cfg(test)]
+pub(crate) mod readback_allocation_failure {
+ use std::cell::Cell;
+
+ thread_local! {
+ static FRAME: Cell<Option<u32>> = const { Cell::new(None) };
+ }
+
+ pub(crate) fn inject(frame_number: u32) {
+ FRAME.set(Some(frame_number));
+ }
+
+ pub(super) fn capacity(frame_number: u32, capacity: usize) -> usize {
+ if FRAME.get() == Some(frame_number) {
+ // Fail one reservation without exhausting memory; a retry would succeed.
+ FRAME.set(None);
+ usize::MAX
+ } else {
+ capacity
+ }
+ }
+}
+
impl PendingReadback {
fn unmap(&mut self) {
if self.mapped {
@@ -1713,9 +1747,9 @@ impl PendingReadback {
self.unmap();
return Err(RenderingError::BufferMapWaitingFailed);
};
+ let mut data_vec = allocate_readback(active_bytes, self.frame_number)?;
let buffer_slice = self.buffer.slice(..active_bytes as u64);
let data = buffer_slice.get_mapped_range();
- let mut data_vec = Vec::with_capacity(active_bytes + 24);
data_vec.extend_from_slice(&data);
drop(data);
@@ -2313,7 +2347,79 @@ pub async fn flush_pending_readback(
#[cfg(test)]
mod readback_output_tests {
- use super::active_readback_byte_len;
+ use super::*;
+
+ #[test]
+ fn readback_allocation_reserves_frame_and_metadata_without_changing_length() {
+ let data = allocate_readback(8_294_400, 7).expect("readback allocation");
+ assert!(data.is_empty());
+ assert!(data.capacity() >= 8_294_424);
+ }
+
+ #[test]
+ fn readback_allocation_overflow_is_terminal() {
+ for active_bytes in [usize::MAX, usize::MAX - 24] {
+ assert!(matches!(
+ allocate_readback(active_bytes, 7),
+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })
+ ));
+ }
+ }
+
+ #[tokio::test]
+ async fn readback_allocation_failure_unmaps_the_buffer() {
+ let instance = crate::create_wgpu_instance_sync();
+ let Ok(adapter) = instance
+ .request_adapter(&wgpu::RequestAdapterOptions::default())
+ .await
+ else {
+ eprintln!("No graphics adapter available for readback cleanup test");
+ return;
+ };
+ let (device, queue) = adapter
+ .request_device(&wgpu::DeviceDescriptor::default())
+ .await
+ .expect("graphics device");
+ let buffer = Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some("readback allocation cleanup"),
+ size: 256,
+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+ mapped_at_creation: false,
+ }));
+ for fail in [true, false] {
+ let submission = queue.submit([]);
+ let (tx, rx) = oneshot::channel();
+ buffer
+ .slice(..)
+ .map_async(wgpu::MapMode::Read, move |result| {
+ tx.send(result).expect("map receiver");
+ });
+ let pending = PendingReadback {
+ readiness_phase: None,
+ rx,
+ submission,
+ mapped: true,
+ buffer: buffer.clone(),
+ padded_bytes_per_row: 256,
+ width: 64,
+ height: 1,
+ frame_number: 7,
+ frame_rate: 30,
+ export_deadlines: false,
+ };
+ if fail {
+ readback_allocation_failure::inject(7);
+ assert!(matches!(
+ pending.wait(&device).await,
+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })
+ ));
+ } else {
+ let frame = pending.wait(&device).await.expect("remapped readback");
+ assert_eq!(frame.data.as_slice(), &[0; 256]);
+ assert!(frame.data.capacity() >= 280);
+ }
+ }
+ }
#[test]
fn oversized_readback_buffers_only_include_active_rows() {
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index 6abde058f..85579fe87 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -729,6 +729,10 @@ pub enum RenderingError {
BufferMapWaitingFailed,
#[error(transparent)]
BufferMapFailed(#[from] wgpu::BufferAsyncError),
+ #[error(
+ "Not enough memory to read back frame {frame_number}. Close other apps or lower the export resolution and try again."
+ )]
+ ReadbackAllocationFailed { frame_number: u32 },
#[error("Sending frame to channel failed")]
ChannelSendFrameFailed(#[from] mpsc::error::SendError<(RenderedFrame, u32)>),
#[error("Sending NV12 frame to channel failed")]
@@ -1157,6 +1161,7 @@ pub async fn render_video_to_channel(
}
}
Ok(None) => in_flight.rendered(current_frame_number, None)?,
+ Err(e @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(e),
Err(e) => {
tracing::error!(
frame_number = current_frame_number,
@@ -1901,6 +1906,7 @@ pub async fn render_video_to_channel_nv12(
}
}
Ok(None) => in_flight.rendered(current_frame_number, None)?,
+ Err(e @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(e),
Err(e) => {
tracing::error!(
frame_number = current_frame_number,
@@ -2100,6 +2106,7 @@ impl InFlightFrame {
let expected = self.0.take();
let frame = match flushed.transpose() {
Ok(frame) => frame,
+ Err(error @ RenderingError::ReadbackAllocationFailed { .. }) => return Err(error),
Err(error) => {
if let Some(frame_number) = expected {
tracing::error!(frame_number, %error, "In-flight export frame readback failed");
@@ -6510,6 +6517,7 @@ mod export_order_tests {
async fn export(
constants: &RenderVideoConstants,
screen: AsyncVideoDecoderHandle,
+ rgba: bool,
) -> (Result<(), RenderingError>, Vec<u32>) {
let project = ProjectConfiguration {
timeline: Some(
@@ -6541,6 +6549,29 @@ mod export_order_tests {
render_display: true,
}];
let recordings = ProjectRecordingsMeta { segments: vec![] };
+ if rgba {
+ let (sender, mut receiver) = mpsc::channel(8);
+ let render = render_video_to_channel(
+ constants,
+ &project,
+ sender,
+ &constants.recording_meta,
+ &constants.meta,
+ segments,
+ FPS,
+ XY::new(SIZE, SIZE),
+ &recordings,
+ None,
+ );
+ let collect = async {
+ let mut order = Vec::new();
+ while let Some((frame, _)) = receiver.recv().await {
+ order.push(frame.frame_number);
+ }
+ order
+ };
+ return tokio::join!(render, collect);
+ }
let (sender, mut receiver) = mpsc::channel(8);
let render = render_video_to_channel_nv12(
constants,
@@ -6573,6 +6604,16 @@ mod export_order_tests {
software_path: bool,
slow_decode: Option<(u32, Duration)>,
slow_readback: Option<(u32, Duration)>,
+ ) -> Option<(Result<(), RenderingError>, Vec<u32>)> {
+ run_export_with_allocation_failure(software_path, slow_decode, slow_readback, None, false)
+ }
+
+ fn run_export_with_allocation_failure(
+ software_path: bool,
+ slow_decode: Option<(u32, Duration)>,
+ slow_readback: Option<(u32, Duration)>,
+ allocation_failure: Option<u32>,
+ rgba: bool,
) -> Option<(Result<(), RenderingError>, Vec<u32>)> {
let _one_export_at_a_time = EXPORTS
.lock()
@@ -6586,14 +6627,18 @@ mod export_order_tests {
.build()
.expect("runtime")
.block_on(async move {
- let Some(constants) = constants(software_path).await else {
+ let Some(mut constants) = constants(software_path).await else {
eprintln!("No graphics adapter available for export order test");
return None;
};
if let Some((frame_number, delay)) = slow_readback {
frame_pipeline::readback_delay::inject(frame_number, delay);
}
- Some(export(&constants, scripted_decoder(slow_decode)).await)
+ if let Some(frame_number) = allocation_failure {
+ constants.is_software_adapter = true;
+ frame_pipeline::readback_allocation_failure::inject(frame_number);
+ }
+ Some(export(&constants, scripted_decoder(slow_decode), rgba).await)
})
})
.expect("export thread")
@@ -6606,6 +6651,32 @@ mod export_order_tests {
result
}
+ #[test]
+ fn readback_allocation_failure_stops_export_without_retry_or_substitution() {
+ for rgba in [true, false] {
+ for failed_frame in [0, 5, FRAMES - 1] {
+ let Some((result, order)) =
+ run_export_with_allocation_failure(false, None, None, Some(failed_frame), rgba)
+ else {
+ return;
+ };
+ assert!(
+ matches!(
+ result,
+ Err(RenderingError::ReadbackAllocationFailed { frame_number })
+ if frame_number == failed_frame
+ ),
+ "rgba={rgba}, failed_frame={failed_frame}: {result:?}"
+ );
+ assert_eq!(
+ order,
+ (0..failed_frame).collect::<Vec<_>>(),
+ "rgba={rgba}, failed_frame={failed_frame}"
+ );
+ }
+ }
+ }
+
#[test]
fn slow_decode_keeps_every_frame_in_order() {
let decode_deadline = Duration::from_secs(2);
@@ -6678,6 +6749,18 @@ mod export_order_tests {
}
}
+ #[test]
+ fn in_flight_frame_preserves_readback_allocation_failure() {
+ let mut in_flight = InFlightFrame::default();
+ in_flight.rendered(5, None).unwrap();
+ assert!(matches!(
+ in_flight.drain::<RenderedFrame>(Some(Err(RenderingError::ReadbackAllocationFailed {
+ frame_number: 5,
+ }))),
+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 5 })
+ ));
+ }
+
#[test]
fn in_flight_frame_must_come_out_next() {
let mut in_flight = InFlightFrame::default();