monolith

public

Star0

Fork 0

Watch0

193 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `61ebcd0a3619`

tarball

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

3 files changed+147-42

render-vk: batch shm uploads into the next submit

copy_staged ended in its own queue submit, so a frame uploading more than eight surfaces could step past the ABSORB_AHEAD window and take the NVIDIA 1024th-submit stall mid-frame. Uploads now queue as Upload entries and are recorded at the head of the frame's command buffer, or of the read_back command buffer, so a frame is one submit however many surfaces changed.

Modified file: crates/render-vk/src/renderer/mod.rs+109 additions−41 deletions@@ -39,11 +39,24 @@ struct Pending {
     fence: Arc<FenceInner>,
     cmd: vk::CommandBuffer,
     _keep: Vec<Arc<ImageInner>>,
-    _staging: Option<Staging>,
+    _staging: Vec<Staging>,
 }
 
+/// A queued copy of staged pixels into `image`, recorded by the next submit.
+struct Upload {
+    image: Arc<ImageInner>,
+    staging: Staging,
+    copy: vk::BufferImageCopy,
+}
+
+/// Queued staging memory past which uploads are submitted without waiting
+/// for a frame.
+const UPLOAD_BATCH_BYTES: usize = 64 * 1024 * 1024;
+
 pub struct VulkanRenderer {
     pending: Vec<Pending>,
+    uploads: Vec<Upload>,
+    upload_bytes: usize,
     dmabuf_textures: HashMap<WeakDmabuf, VulkanTexture>,
     dmabuf_targets: HashMap<WeakDmabuf, Arc<ImageInner>>,
     pipelines: Pipelines,
@@ -118,6 +131,8 @@ impl VulkanRenderer {
         }
         Ok(Self {
             pending: Vec::new(),
+            uploads: Vec::new(),
+            upload_bytes: 0,
             dmabuf_textures: HashMap::new(),
             dmabuf_targets: HashMap::new(),
             pipelines: Pipelines::new(&shared)?,
@@ -251,21 +266,97 @@ impl VulkanRenderer {
         Ok(fence)
     }
 
-    /// Records, submits and waits for a short command buffer.
+    /// Records, submits and waits for a short command buffer. Queued uploads
+    /// go first, so `record` sees their pixels.
     fn one_shot(
         &mut self,
         record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),
     ) -> Result<(), Error> {
         let cmd = self.begin()?;
+        let uploads = self.record_uploads(cmd);
         record(
             &self.shared.device.device,
             cmd,
             self.shared.device.queue_family,
         );
+        let fence = self.finish(cmd, uploads, Vec::new())?;
+        Ok(fence.wait()?)
+    }
+
+    /// Submits `cmd`, which holds `uploads` and works on `keep`, and tracks
+    /// it until its fence signals.
+    fn finish(
+        &mut self,
+        cmd: vk::CommandBuffer,
+        uploads: Vec<Upload>,
+        mut keep: Vec<Arc<ImageInner>>,
+    ) -> Result<Arc<FenceInner>, Error> {
         let fence = self.end_and_submit(cmd)?;
-        let res = fence.wait();
-        self.spare_cmds.push(cmd);
-        Ok(res?)
+        keep.extend(uploads.iter().map(|u| u.image.clone()));
+        self.pending.push(Pending {
+            fence: fence.clone(),
+            cmd,
+            _keep: keep,
+            _staging: uploads.into_iter().map(|u| u.staging).collect(),
+        });
+        Ok(fence)
+    }
+
+    /// 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> {
+        let uploads = std::mem::take(&mut self.uploads);
+        self.upload_bytes = 0;
+        if uploads.is_empty() {
+            return uploads;
+        }
+        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);
+            }
+            for (i, u) in uploads.iter().enumerate() {
+                if uploads[..i].iter().any(|e| Arc::ptr_eq(&e.image, &u.image)) {
+                    let order = [vk::MemoryBarrier2::default()
+                        .src_stage_mask(vk::PipelineStageFlags2::TRANSFER)
+                        .src_access_mask(vk::AccessFlags2::TRANSFER_WRITE)
+                        .dst_stage_mask(vk::PipelineStageFlags2::TRANSFER)
+                        .dst_access_mask(vk::AccessFlags2::TRANSFER_WRITE)];
+                    d.cmd_pipeline_barrier2(
+                        cmd,
+                        &vk::DependencyInfo::default().memory_barriers(&order),
+                    );
+                }
+                d.cmd_copy_buffer_to_image(
+                    cmd,
+                    u.staging.buffer,
+                    u.image.image,
+                    vk::ImageLayout::TRANSFER_DST_OPTIMAL,
+                    &[u.copy],
+                );
+            }
+            for u in &uploads {
+                acquire(
+                    d,
+                    cmd,
+                    family,
+                    &u.image,
+                    vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
+                );
+            }
+        }
+        uploads
+    }
+
+    /// Submits the queued uploads without waiting for a frame to carry them.
+    fn flush_uploads(&mut self) -> Result<(), Error> {
+        if self.uploads.is_empty() {
+            return Ok(());
+        }
+        let cmd = self.begin()?;
+        let uploads = self.record_uploads(cmd);
+        self.finish(cmd, uploads, Vec::new()).map(drop)
     }
 
     #[profiling::function]
@@ -294,6 +385,7 @@ impl VulkanRenderer {
             });
         }
         let cmd = self.begin()?;
+        let uploads = self.record_uploads(cmd);
         let d = &self.shared.device.device;
         let family = self.shared.device.queue_family;
         let push = &self.shared.device.push_descriptor;
@@ -416,14 +508,8 @@ impl VulkanRenderer {
                 release(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
             }
         }
-        let fence = self.end_and_submit(cmd)?;
         sampled.push(image);
-        self.pending.push(Pending {
-            fence: fence.clone(),
-            cmd,
-            _keep: sampled,
-            _staging: None,
-        });
+        let fence = self.finish(cmd, uploads, sampled)?;
         Ok(SyncPoint::from(VkFence(fence)))
     }
 
@@ -454,8 +540,8 @@ impl VulkanRenderer {
     }
 
     /// Uploads `region` of `image`, taking each image row `y` in the region
-    /// from `row(y)`. The CPU does not wait: the copy is ordered before later
-    /// frames by its barrier, and its staging memory lives until its fence.
+    /// from `row(y)`. The pixels are staged now and copied by the next submit,
+    /// which the CPU does not wait for.
     #[profiling::function]
     fn upload_with<'a>(
         &mut self,
@@ -474,7 +560,7 @@ impl VulkanRenderer {
         self.copy_staged(image, region, staging)
     }
 
-    /// Copies staged pixels into `region` of `image` on the GPU.
+    /// Queues staged pixels to be copied into `region` of `image`.
     fn copy_staged(
         &mut self,
         image: &Arc<ImageInner>,
@@ -499,33 +585,15 @@ impl VulkanRenderer {
                 height: h as u32,
                 depth: 1,
             });
-        let cmd = self.begin()?;
-        let d = &self.shared.device.device;
-        let family = self.shared.device.queue_family;
-        unsafe {
-            acquire(d, cmd, family, image, vk::ImageLayout::TRANSFER_DST_OPTIMAL);
-            d.cmd_copy_buffer_to_image(
-                cmd,
-                staging.buffer,
-                image.image,
-                vk::ImageLayout::TRANSFER_DST_OPTIMAL,
-                &[copy],
-            );
-            acquire(
-                d,
-                cmd,
-                family,
-                image,
-                vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
-            );
-        }
-        let fence = self.end_and_submit(cmd)?;
-        self.pending.push(Pending {
-            fence,
-            cmd,
-            _keep: vec![image.clone()],
-            _staging: Some(staging),
+        self.uploads.push(Upload {
+            image: image.clone(),
+            staging,
+            copy,
         });
+        self.upload_bytes += w * h * BYTES_PER_PIXEL;
+        if self.upload_bytes > UPLOAD_BATCH_BYTES {
+            self.flush_uploads()?;
+        }
         Ok(())
     }
 

Modified file: crates/render-vk/src/renderer/stall.rs+1−1

@@ -64,7 +64,7 @@ impl VulkanRenderer {

6464 fence,

6565 cmd,

6666 _keep: Vec::new(),

67- _staging: None,

67+ _staging: Vec::new(),

6868 });

6969 }

7070 Ok(())

Modified file: crates/render-vk/tests/golden.rs+37 additions@@ -238,3 +238,40 @@ fn quarter_turn_on_a_wide_output_fills_it() {
         assert!(g.0 != r.0 && g.1 != r.1, "{transform:?} not diagonal");
     }
 }
+
+#[test]
+fn queued_uploads_to_one_texture_land_in_order() {
+    let mut s = Scene::new();
+    let size = (2, 2);
+    let bytes = |p: Pixel| -> Vec<u8> { [p; 4].iter().flatten().copied().collect() };
+    let tex = s.texture(size, &[RED; 4]);
+    for colour in [WHITE, GREEN] {
+        s.renderer
+            .update_memory(&tex, &bytes(colour), Rectangle::from_size(size.into()))
+            .unwrap();
+    }
+    let read = s
+        .renderer
+        .copy_texture(&tex, Rectangle::from_size(size.into()), Fourcc::Abgr8888)
+        .unwrap();
+    assert_eq!(s.renderer.map_texture(&read).unwrap()[..4], GREEN);
+    s.renderer
+        .update_memory(&tex, &bytes(WHITE), Rectangle::from_size(size.into()))
+        .unwrap();
+    s.renderer
+        .update_memory(&tex, &bytes(RED), Rectangle::from_size(size.into()))
+        .unwrap();
+    s.draw(Transform::Normal, |f| {
+        f.render_texture_from_to(
+            &tex,
+            Rectangle::from_size((2.0, 2.0).into()),
+            full(),
+            &[full()],
+            &[],
+            Transform::Normal,
+            1.0,
+        )
+        .unwrap();
+    });
+    assert_eq!(at(&s.pixels(), 32, 32), RED);
+}

monolith

Commit 61ebcd0a3619

Commit `61ebcd0a3619`