monolith

public

Star0

Fork 0

Watch0

260 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7af1a807d966`

tarball

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

1 file changed+36-18

render-vk: flush queued uploads at the pool size and keep readback staging pinned

Uploads were batched up to 64 MiB, twice what StagingPool keeps, so each flush freed half of it and brought back the NVIDIA host-allocation stall the pool exists to avoid. read_back dropped its staging into the pool after a fence timeout while a hung GPU might still write it, so it now moves into the Pending entry. Shm commits also called the full reap, which walks four maps and locks the pool, where freeing finished fences is enough.

Modified file: crates/render-vk/src/renderer/mod.rs+36 additions−18 deletions@@ -12,7 +12,7 @@ use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
 use crate::frame::{Op, VulkanFrame};
 use crate::image::{ImageInner, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};
 use crate::pipeline::Pipelines;
-use crate::staging::{Staging, StagingPool};
+use crate::staging::{POOL_BYTES, Staging, StagingPool};
 use crate::sync::{FenceInner, VkFence};
 use ash::vk;
 use gpu_allocator::MemoryLocation;
@@ -63,10 +63,6 @@ struct Recorded {
     layouts: LayoutLog,
 }
 
-/// 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>,
@@ -212,6 +208,17 @@ impl VulkanRenderer {
     /// Recycles finished work. A fence that cannot be queried stays
     /// pending and fails the call, since its work may never have finished.
     fn reap(&mut self) -> Result<(), Error> {
+        let reaped = self.reap_fences();
+        self.dmabuf_textures.retain(|k, _| !k.is_gone());
+        self.dmabuf_targets.retain(|k, _| !k.is_gone());
+        self.staged.retain(|_, (b, _)| b.is_alive());
+        self.staging_pool.trim();
+        reaped
+    }
+
+    /// The part of `reap` that frees command buffers and staging, cheap enough
+    /// to run for every shm commit.
+    fn reap_fences(&mut self) -> Result<(), Error> {
         let spare = &mut self.spare_cmds;
         let mut failed = None;
         self.pending.retain(|p| match p.fence.status() {
@@ -225,10 +232,6 @@ impl VulkanRenderer {
                 true
             }
         });
-        self.dmabuf_textures.retain(|k, _| !k.is_gone());
-        self.dmabuf_targets.retain(|k, _| !k.is_gone());
-        self.staged.retain(|_, (b, _)| b.is_alive());
-        self.staging_pool.trim();
         failed.map_or(Ok(()), |e| Err(e.into()))
     }
 
@@ -303,12 +306,12 @@ impl VulkanRenderer {
         Ok(fence)
     }
 
-    /// Records, submits and waits for a short command buffer. Queued uploads
-    /// go first, so `record` sees their pixels.
+    /// Records and submits 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, &mut LayoutLog),
-    ) -> Result<(), Error> {
+    ) -> Result<Arc<FenceInner>, Error> {
         let cmd = self.begin()?;
         let mut recorded = self.record_uploads(cmd);
         record(
@@ -317,8 +320,7 @@ impl VulkanRenderer {
             self.shared.device.queue_family,
             &mut recorded.layouts,
         );
-        let fence = self.finish(cmd, recorded, Vec::new())?;
-        Ok(fence.wait()?)
+        self.finish(cmd, recorded, Vec::new())
     }
 
     /// Submits `cmd`, which holds `recorded` and works on `keep`, and tracks
@@ -406,8 +408,13 @@ impl VulkanRenderer {
         Recorded { uploads, layouts }
     }
 
+    /// Whether pixels are staged for a frame to carry to the GPU.
+    pub fn has_queued_uploads(&self) -> bool {
+        !self.uploads.is_empty()
+    }
+
     /// Submits the queued uploads without waiting for a frame to carry them.
-    fn flush_uploads(&mut self) -> Result<(), Error> {
+    pub fn flush_uploads(&mut self) -> Result<(), Error> {
         if self.uploads.is_empty() {
             return Ok(());
         }
@@ -613,7 +620,7 @@ impl VulkanRenderer {
         if image.external {
             return Err(Error::ForeignTexture);
         }
-        self.reap()?;
+        self.reap_fences()?;
         if region.size.w <= 0 || region.size.h <= 0 {
             return Ok(());
         }
@@ -653,7 +660,7 @@ impl VulkanRenderer {
         };
         self.upload_bytes += upload.bytes();
         self.uploads.push(upload);
-        if self.upload_bytes > UPLOAD_BATCH_BYTES {
+        if self.upload_bytes >= POOL_BYTES {
             self.flush_uploads()?;
         }
         Ok(())
@@ -698,7 +705,7 @@ impl VulkanRenderer {
                 });
             let buffer = staging.buffer;
             let source = image.clone();
-            self.one_shot(|d, cmd, family, layouts| unsafe {
+            let fence = self.one_shot(|d, cmd, family, layouts| unsafe {
                 let mut barriers = Barriers::default();
                 barriers.acquire(
                     family,
@@ -729,6 +736,17 @@ impl VulkanRenderer {
                     &vk::DependencyInfo::default().buffer_memory_barriers(&to_host),
                 );
             })?;
+            if let Err(e) = fence.wait() {
+                // A timed out GPU may still write the buffer, so it stays out of the pool.
+                if let Some(p) = self
+                    .pending
+                    .iter_mut()
+                    .find(|p| Arc::ptr_eq(&p.fence, &fence))
+                {
+                    p._staging.push(staging);
+                }
+                return Err(e.into());
+            }
         }
         let mut data = staging.bytes()?[..w as usize * h as usize * BYTES_PER_PIXEL].to_vec();
         if swap {

monolith

Commit 7af1a807d966

Commit `7af1a807d966`