monolith

public

Star0

Fork 0

Watch0

194 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `ad1f04ba8cb2`

tarball

atagen <boss@atagen.co>2026-10-19 07:56 UTC

2 files changed+108-27

render-vk: commit layouts only after the submit succeeds

acquire set the tracked layout while recording, so a failed vkQueueSubmit2 left images believed to be in layouts the GPU never reached. end_and_submit also dropped the command buffer from spare_cmds on every error. Layouts now go through a LayoutLog that finish commits, the command buffer returns to the spare list, and queued uploads are put back for the next attempt.

Modified file: crates/render-vk/src/barrier.rs+27 additions−3 deletions@@ -1,5 +1,28 @@
 use crate::image::{ImageInner, color_range};
 use ash::vk;
+use std::sync::Arc;
+
+/// Layout changes recorded into a command buffer that has not been submitted.
+/// Images keep their old layout until `commit`, so a failed submit leaves the
+/// tracking true to what the GPU has done.
+#[derive(Default)]
+pub(crate) struct LayoutLog(Vec<(Arc<ImageInner>, vk::ImageLayout)>);
+
+impl LayoutLog {
+    fn current(&self, image: &Arc<ImageInner>) -> vk::ImageLayout {
+        self.0
+            .iter()
+            .rev()
+            .find(|(i, _)| Arc::ptr_eq(i, image))
+            .map_or_else(|| image.layout(), |(_, layout)| *layout)
+    }
+
+    pub fn commit(self) {
+        for (image, layout) in self.0 {
+            image.set_layout(layout);
+        }
+    }
+}
 
 /// A full barrier between all earlier and later work on the image, optionally
 /// transferring ownership between queue families. Coarse, but correct for
@@ -39,8 +62,9 @@ pub(crate) unsafe fn acquire(
     d: &ash::Device,
     cmd: vk::CommandBuffer,
     family: u32,
-    image: &ImageInner,
+    image: &Arc<ImageInner>,
     layout: vk::ImageLayout,
+    log: &mut LayoutLog,
 ) {
     if image.external {
         unsafe {
@@ -55,7 +79,7 @@ pub(crate) unsafe fn acquire(
             )
         };
     } else {
-        let old = image.layout();
+        let old = log.current(image);
         if old != layout {
             unsafe {
                 barrier(
@@ -68,7 +92,7 @@ pub(crate) unsafe fn acquire(
                     vk::QUEUE_FAMILY_IGNORED,
                 )
             };
-            image.set_layout(layout);
+            log.0.push((image.clone(), layout));
         }
     }
 }

Modified file: crates/render-vk/src/renderer/mod.rs+81 additions−24 deletions@@ -5,7 +5,7 @@ use shm::stage_rows;
 use stall::{STALL, StallPhase};
 
 use crate::Error;
-use crate::barrier::{acquire, release};
+use crate::barrier::{LayoutLog, acquire, release};
 use crate::device::Shared;
 use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};
 use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
@@ -49,6 +49,20 @@ struct Upload {
     copy: vk::BufferImageCopy,
 }
 
+impl Upload {
+    fn bytes(&self) -> usize {
+        let extent = self.copy.image_extent;
+        extent.width as usize * extent.height as usize * BYTES_PER_PIXEL
+    }
+}
+
+/// What a command buffer holds besides its own commands. A failed submit
+/// takes the uploads back and drops the layouts.
+struct Recorded {
+    uploads: Vec<Upload>,
+    layouts: LayoutLog,
+}
+
 /// Queued staging memory past which uploads are submitted without waiting
 /// for a frame.
 const UPLOAD_BATCH_BYTES: usize = 64 * 1024 * 1024;
@@ -224,18 +238,31 @@ impl VulkanRenderer {
                 )?[0]
             },
         };
-        unsafe {
+        let began = unsafe {
             d.begin_command_buffer(
                 cmd,
                 &vk::CommandBufferBeginInfo::default()
                     .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT),
-            )?
+            )
         };
+        if let Err(e) = began {
+            self.spare_cmds.push(cmd);
+            return Err(e.into());
+        }
         Ok(cmd)
     }
 
+    /// Ends and submits `cmd`. It goes back to the spare list if that fails.
+    fn end_and_submit(&mut self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {
+        let submitted = self.submit_cmd(cmd);
+        if submitted.is_err() {
+            self.spare_cmds.push(cmd);
+        }
+        submitted
+    }
+
     #[profiling::function]
-    fn end_and_submit(&self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {
+    fn submit_cmd(&self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {
         let d = &self.shared.device.device;
         {
             profiling::scope!("end_command_buffer");
@@ -270,28 +297,39 @@ impl VulkanRenderer {
     /// go first, so `record` sees their pixels.
     fn one_shot(
         &mut self,
-        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),
+        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32, &mut LayoutLog),
     ) -> Result<(), Error> {
         let cmd = self.begin()?;
-        let uploads = self.record_uploads(cmd);
+        let mut recorded = self.record_uploads(cmd);
         record(
             &self.shared.device.device,
             cmd,
             self.shared.device.queue_family,
+            &mut recorded.layouts,
         );
-        let fence = self.finish(cmd, uploads, Vec::new())?;
+        let fence = self.finish(cmd, recorded, Vec::new())?;
         Ok(fence.wait()?)
     }
 
-    /// Submits `cmd`, which holds `uploads` and works on `keep`, and tracks
-    /// it until its fence signals.
+    /// Submits `cmd`, which holds `recorded` and works on `keep`, and tracks
+    /// it until its fence signals. On success the layouts it recorded take
+    /// effect, on failure the uploads are queued again.
     fn finish(
         &mut self,
         cmd: vk::CommandBuffer,
-        uploads: Vec<Upload>,
+        recorded: Recorded,
         mut keep: Vec<Arc<ImageInner>>,
     ) -> Result<Arc<FenceInner>, Error> {
-        let fence = self.end_and_submit(cmd)?;
+        let Recorded { uploads, layouts } = recorded;
+        let fence = match self.end_and_submit(cmd) {
+            Ok(fence) => fence,
+            Err(e) => {
+                self.upload_bytes += uploads.iter().map(Upload::bytes).sum::<usize>();
+                self.uploads.splice(0..0, uploads);
+                return Err(e);
+            }
+        };
+        layouts.commit();
         keep.extend(uploads.iter().map(|u| u.image.clone()));
         self.pending.push(Pending {
             fence: fence.clone(),
@@ -304,17 +342,25 @@ impl VulkanRenderer {
 
     /// Records every queued upload into `cmd` and hands them back to keep
     /// alive until it finishes.
-    fn record_uploads(&mut self, cmd: vk::CommandBuffer) -> Vec<Upload> {
+    fn record_uploads(&mut self, cmd: vk::CommandBuffer) -> Recorded {
         let uploads = std::mem::take(&mut self.uploads);
         self.upload_bytes = 0;
+        let mut layouts = LayoutLog::default();
         if uploads.is_empty() {
-            return uploads;
+            return Recorded { uploads, layouts };
         }
         let d = &self.shared.device.device;
         let family = self.shared.device.queue_family;
         unsafe {
             for u in &uploads {
-                acquire(d, cmd, family, &u.image, vk::ImageLayout::TRANSFER_DST_OPTIMAL);
+                acquire(
+                    d,
+                    cmd,
+                    family,
+                    &u.image,
+                    vk::ImageLayout::TRANSFER_DST_OPTIMAL,
+                    &mut layouts,
+                );
             }
             for (i, u) in uploads.iter().enumerate() {
                 if uploads[..i].iter().any(|e| Arc::ptr_eq(&e.image, &u.image)) {
@@ -343,10 +389,11 @@ impl VulkanRenderer {
                     family,
                     &u.image,
                     vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
+                    &mut layouts,
                 );
             }
         }
-        uploads
+        Recorded { uploads, layouts }
     }
 
     /// Submits the queued uploads without waiting for a frame to carry them.
@@ -355,8 +402,8 @@ impl VulkanRenderer {
             return Ok(());
         }
         let cmd = self.begin()?;
-        let uploads = self.record_uploads(cmd);
-        self.finish(cmd, uploads, Vec::new()).map(drop)
+        let recorded = self.record_uploads(cmd);
+        self.finish(cmd, recorded, Vec::new()).map(drop)
     }
 
     #[profiling::function]
@@ -385,7 +432,7 @@ impl VulkanRenderer {
             });
         }
         let cmd = self.begin()?;
-        let uploads = self.record_uploads(cmd);
+        let mut recorded = self.record_uploads(cmd);
         let d = &self.shared.device.device;
         let family = self.shared.device.queue_family;
         let push = &self.shared.device.push_descriptor;
@@ -393,7 +440,14 @@ impl VulkanRenderer {
         let sampler = self.sampler();
         unsafe {
             for t in &sampled {
-                acquire(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
+                acquire(
+                    d,
+                    cmd,
+                    family,
+                    t,
+                    vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
+                    &mut recorded.layouts,
+                );
             }
             acquire(
                 d,
@@ -401,6 +455,7 @@ impl VulkanRenderer {
                 family,
                 &image,
                 vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
+                &mut recorded.layouts,
             );
             let attachments = [vk::RenderingAttachmentInfo::default()
                 .image_view(image.view)
@@ -509,7 +564,7 @@ impl VulkanRenderer {
             }
         }
         sampled.push(image);
-        let fence = self.finish(cmd, uploads, sampled)?;
+        let fence = self.finish(cmd, recorded, sampled)?;
         Ok(SyncPoint::from(VkFence(fence)))
     }
 
@@ -585,12 +640,13 @@ impl VulkanRenderer {
                 height: h as u32,
                 depth: 1,
             });
-        self.uploads.push(Upload {
+        let upload = Upload {
             image: image.clone(),
             staging,
             copy,
-        });
-        self.upload_bytes += w * h * BYTES_PER_PIXEL;
+        };
+        self.upload_bytes += upload.bytes();
+        self.uploads.push(upload);
         if self.upload_bytes > UPLOAD_BATCH_BYTES {
             self.flush_uploads()?;
         }
@@ -636,13 +692,14 @@ impl VulkanRenderer {
                 });
             let buffer = staging.buffer;
             let source = image.clone();
-            self.one_shot(|d, cmd, family| unsafe {
+            self.one_shot(|d, cmd, family, layouts| unsafe {
                 acquire(
                     d,
                     cmd,
                     family,
                     &source,
                     vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                    layouts,
                 );
                 d.cmd_copy_image_to_buffer(
                     cmd,

monolith

Commit ad1f04ba8cb2

Commit `ad1f04ba8cb2`