monolith

public

Star0

Fork 0

Watch0

201 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `f8e6bc3e5529`

tarball

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

2 files changed+45-0

render-vk: flush and invalidate non-coherent staging memory

read_back read GPU-written staging memory and stage_rows wrote memory the GPU then read without vkInvalidateMappedMemoryRanges or vkFlushMappedMemoryRanges, which the spec requires when the allocator falls back to a memory type without HOST_COHERENT. Staging::bytes now invalidates and stage_rows flushes.

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

@@ -116,6 +116,7 @@ pub(super) fn stage_rows<'a>(

116116 for i in 0..h {

117117 dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));

118118 }

119+ staging.flush()?;

119120 Ok(staging)

120121 }

121122

Modified file: crates/render-vk/src/staging.rs+44 additions@@ -25,13 +25,23 @@ struct Pooled {
 pub(crate) struct StagingPool {
     shared: Arc<Shared>,
     free: Mutex<Vec<Pooled>>,
+    /// Granularity of flushes and invalidations of non-coherent memory.
+    atom: u64,
 }
 
 impl StagingPool {
     pub fn new(shared: &Arc<Shared>) -> Arc<Self> {
+        let limits = unsafe {
+            shared
+                .device
+                .instance
+                .get_physical_device_properties(shared.device.physical)
+        }
+        .limits;
         Arc::new(Self {
             shared: shared.clone(),
             free: Mutex::new(Vec::new()),
+            atom: limits.non_coherent_atom_size.max(1),
         })
     }
 
@@ -149,13 +159,47 @@ impl Staging {
         })
     }
 
+    /// The mapped bytes, with whatever the GPU wrote to them made visible.
     pub fn bytes(&self) -> Result<&[u8], Error> {
+        self.host_sync(false)?;
         self.allocation
             .as_ref()
             .and_then(|a| a.mapped_slice())
             .ok_or(Error::StagingUnmapped)
     }
 
+    /// Makes what the host wrote through `bytes_mut` visible to the GPU.
+    pub fn flush(&self) -> Result<(), Error> {
+        self.host_sync(true)
+    }
+
+    /// Flushes or invalidates the mapping. Coherent memory needs neither.
+    fn host_sync(&self, flush: bool) -> Result<(), Error> {
+        let Some(allocation) = self.allocation.as_ref() else {
+            return Ok(());
+        };
+        if allocation
+            .memory_properties()
+            .contains(vk::MemoryPropertyFlags::HOST_COHERENT)
+        {
+            return Ok(());
+        }
+        let atom = self.pool.atom;
+        let range = [vk::MappedMemoryRange::default()
+            .memory(unsafe { allocation.memory() })
+            .offset(allocation.offset() / atom * atom)
+            .size(vk::WHOLE_SIZE)];
+        let d = &self.pool.shared.device.device;
+        unsafe {
+            if flush {
+                d.flush_mapped_memory_ranges(&range)?;
+            } else {
+                d.invalidate_mapped_memory_ranges(&range)?;
+            }
+        }
+        Ok(())
+    }
+
     pub fn bytes_mut(&mut self) -> Result<&mut [u8], Error> {
         self.allocation
             .as_mut()

monolith

Commit f8e6bc3e5529

Commit `f8e6bc3e5529`