Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

Merge remote-tracking branch 'origin/main' into HEAD

Richie McIlroy756dbbde92ae
diff --cc crates/rendering/src/frame_pipeline.rs
index 0642ef888,b15d1616f..72bc348de
--- a/crates/rendering/src/frame_pipeline.rs
+++ b/crates/rendering/src/frame_pipeline.rs
@@@ -1656,6 -1657,40 +1656,48 @@@ 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 mut data = Vec::new();
++ reserve_readback(&mut data, active_bytes, frame_number)?;
++ Ok(data)
++}
++
++fn reserve_readback(
++ data: &mut Vec<u8>,
++ active_bytes: usize,
++ frame_number: u32,
++) -> Result<(), 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)
++ .map_err(|_| allocation_failed())
+ }
+
+ #[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 {
@@@ -1716,14 -1747,9 +1758,14 @@@
self.unmap();
return Err(RenderingError::BufferMapWaitingFailed);
};
- let buffer_slice = self.buffer.slice(..active_bytes as u64);
- let data = buffer_slice.get_mapped_range();
- let mut data_vec = allocate_readback(active_bytes, self.frame_number)?;
+ let mut data_vec = if self.export_deadlines {
+ recycled.take().unwrap_or_default()
+ } else {
+ Vec::new()
+ };
- data_vec.reserve_exact(active_bytes + 24);
++ reserve_readback(&mut data_vec, active_bytes, self.frame_number)?;
+ let buffer_slice = self.buffer.slice(..active_bytes as u64);
+ let data = buffer_slice.get_mapped_range();
data_vec.extend_from_slice(&data);
drop(data);
@@@ -2352,7 -2347,79 +2394,82 @@@ 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,
++ pending.wait(&device, &mut Default::default()).await,
+ Err(RenderingError::ReadbackAllocationFailed { frame_number: 7 })
+ ));
+ } else {
- let frame = pending.wait(&device).await.expect("remapped readback");
++ let frame = pending
++ .wait(&device, &mut Default::default())
++ .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() {