monolith

public

Star0

Fork 0

Watch0

90 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `de1e9f21296c`

tarball

atagen <boss@atagen.co>2026-10-17 04:56 UTC

6 files changed+1249-1220

render-vk: split stall handling, shm import and barriers out of the renderer

renderer.rs mixed the smithay trait impls with three self-contained concerns. Stall handling and the shm import stay submodules so they keep access to the renderer's fields, while the barriers only touch an image and a command buffer and move to the crate root.

Added file: crates/render-vk/src/barrier.rs+97 additions@@ -0,0 +1,97 @@
+use crate::image::{ImageInner, color_range};
+use ash::vk;
+
+/// A full barrier between all earlier and later work on the image, optionally
+/// transferring ownership between queue families. Coarse, but correct for
+/// every transition the renderer makes.
+pub(crate) unsafe fn barrier(
+    d: &ash::Device,
+    cmd: vk::CommandBuffer,
+    image: vk::Image,
+    old: vk::ImageLayout,
+    new: vk::ImageLayout,
+    src_family: u32,
+    dst_family: u32,
+) {
+    let b = [vk::ImageMemoryBarrier2::default()
+        .src_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)
+        .src_access_mask(vk::AccessFlags2::MEMORY_WRITE)
+        .dst_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)
+        .dst_access_mask(vk::AccessFlags2::MEMORY_READ | vk::AccessFlags2::MEMORY_WRITE)
+        .old_layout(old)
+        .new_layout(new)
+        .src_queue_family_index(src_family)
+        .dst_queue_family_index(dst_family)
+        .image(image)
+        .subresource_range(color_range())];
+    unsafe {
+        d.cmd_pipeline_barrier2(
+            cmd,
+            &vk::DependencyInfo::default().image_memory_barriers(&b),
+        )
+    };
+}
+
+/// Moves an image into `layout` for use on this queue. Dmabuf images come
+/// from the foreign queue family in the general layout, others continue from
+/// their tracked layout.
+pub(crate) unsafe fn acquire(
+    d: &ash::Device,
+    cmd: vk::CommandBuffer,
+    family: u32,
+    image: &ImageInner,
+    layout: vk::ImageLayout,
+) {
+    if image.external {
+        unsafe {
+            barrier(
+                d,
+                cmd,
+                image.image,
+                vk::ImageLayout::GENERAL,
+                layout,
+                vk::QUEUE_FAMILY_FOREIGN_EXT,
+                family,
+            )
+        };
+    } else {
+        let old = image.layout();
+        if old != layout {
+            unsafe {
+                barrier(
+                    d,
+                    cmd,
+                    image.image,
+                    old,
+                    layout,
+                    vk::QUEUE_FAMILY_IGNORED,
+                    vk::QUEUE_FAMILY_IGNORED,
+                )
+            };
+            image.set_layout(layout);
+        }
+    }
+}
+
+/// Hands a dmabuf image back to the foreign queue family after use.
+pub(crate) unsafe fn release(
+    d: &ash::Device,
+    cmd: vk::CommandBuffer,
+    family: u32,
+    image: &ImageInner,
+    layout: vk::ImageLayout,
+) {
+    if image.external {
+        unsafe {
+            barrier(
+                d,
+                cmd,
+                image.image,
+                layout,
+                vk::ImageLayout::GENERAL,
+                family,
+                vk::QUEUE_FAMILY_FOREIGN_EXT,
+            )
+        };
+    }
+}

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

@@ -3,6 +3,7 @@

33 //! A frame records its draws as a list of operations and submits them in one

44 //! command buffer when it finishes, returning a fence as its sync point.

6+mod barrier;

67 mod device;

78 mod dmabuf;

89 mod error;

Deleted file: crates/render-vk/src/renderer.rs−1220 deletions@@ -1,1220 +0,0 @@
-use crate::Error;
-use crate::device::Shared;
-use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};
-use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
-use crate::frame::{Op, VulkanFrame};
-use crate::image::{
-    ImageInner, Staging, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture, color_range,
-};
-use crate::pipeline::Pipelines;
-use crate::sync::{FenceInner, VkFence};
-use ash::vk;
-use gpu_allocator::MemoryLocation;
-use smithay::backend::allocator::Fourcc;
-use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
-use smithay::backend::allocator::format::FormatSet;
-use smithay::backend::renderer::ImportMemWl;
-use smithay::backend::renderer::sync::SyncPoint;
-use smithay::backend::renderer::{
-    Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,
-    RendererSuper, Texture, TextureFilter,
-};
-use smithay::reexports::wayland_server::Resource;
-use smithay::reexports::wayland_server::backend::ObjectId;
-use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
-use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};
-use smithay::wayland::compositor::SurfaceData;
-use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents};
-use std::cell::Cell;
-use std::collections::HashMap;
-use std::fmt;
-use std::marker::PhantomData;
-use std::sync::{Arc, Mutex};
-use std::time::{Duration, Instant};
-
-struct Pending {
-    fence: Arc<FenceInner>,
-    cmd: vk::CommandBuffer,
-    _keep: Vec<Arc<ImageInner>>,
-    _staging: Option<Staging>,
-}
-
-pub struct VulkanRenderer {
-    pending: Vec<Pending>,
-    dmabuf_textures: HashMap<WeakDmabuf, VulkanTexture>,
-    dmabuf_targets: HashMap<WeakDmabuf, Arc<ImageInner>>,
-    pipelines: Pipelines,
-    pool: vk::CommandPool,
-    /// Command buffers whose work finished, reset and reused by `begin`.
-    spare_cmds: Vec<vk::CommandBuffer>,
-    samplers: [vk::Sampler; 4],
-    min_filter: TextureFilter,
-    mag_filter: TextureFilter,
-    debug: DebugFlags,
-    context: ContextId<VulkanTexture>,
-    caps: Arc<DmabufCaps>,
-    shared: Arc<Shared>,
-    submissions: Cell<u64>,
-    /// Shm uploads staged off the main thread, by buffer.
-    staged: HashMap<ObjectId, (WlBuffer, StagedShm)>,
-    stall: Cell<StallPhase>,
-}
-
-/// Where in every 1024 submissions the driver stalls. A phase is trusted
-/// once two stalls land on it.
-#[derive(Clone, Copy, Default)]
-struct StallPhase {
-    phase: Option<u64>,
-    seen: Option<u64>,
-}
-
-impl StallPhase {
-    fn saw(self, at: u64) -> Self {
-        if self.seen == Some(at) {
-            if self.phase != Some(at) {
-                tracing::debug!(phase = at, "queue submissions stall periodically");
-            }
-            Self {
-                phase: Some(at),
-                seen: Some(at),
-            }
-        } else {
-            Self {
-                seen: Some(at),
-                ..self
-            }
-        }
-    }
-}
-
-/// A submission this slow is a driver stall rather than work.
-const STALL: Duration = Duration::from_micros(1500);
-/// How many submissions early a stall is absorbed. Each empty one costs
-/// tens of microseconds.
-const ABSORB_AHEAD: u64 = 8;
-
-impl fmt::Debug for VulkanRenderer {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("VulkanRenderer")
-            .field("device", &self.shared.device.name)
-            .finish()
-    }
-}
-
-impl VulkanRenderer {
-    pub fn new() -> Result<Self, Error> {
-        Self::with_node(None)
-    }
-
-    /// A renderer on the GPU behind DRM device number `node`, so it can
-    /// render into buffers that GPU scans out.
-    pub fn for_node(node: u64) -> Result<Self, Error> {
-        Self::with_node(Some(node))
-    }
-
-    fn with_node(node: Option<u64>) -> Result<Self, Error> {
-        let shared = Arc::new(Shared::new(node)?);
-        let d = &shared.device.device;
-        let pool = unsafe {
-            d.create_command_pool(
-                &vk::CommandPoolCreateInfo::default()
-                    .queue_family_index(shared.device.queue_family)
-                    .flags(
-                        vk::CommandPoolCreateFlags::TRANSIENT
-                            | vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER,
-                    ),
-                None,
-            )?
-        };
-        let filter = |f: TextureFilter| match f {
-            TextureFilter::Linear => vk::Filter::LINEAR,
-            TextureFilter::Nearest => vk::Filter::NEAREST,
-        };
-        let mut samplers = [vk::Sampler::null(); 4];
-        for (i, s) in samplers.iter_mut().enumerate() {
-            let (min, mag) = (sampler_filter(i >> 1), sampler_filter(i & 1));
-            *s = unsafe {
-                d.create_sampler(
-                    &vk::SamplerCreateInfo::default()
-                        .min_filter(filter(min))
-                        .mag_filter(filter(mag))
-                        .address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
-                        .address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
-                        .address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE),
-                    None,
-                )?
-            };
-        }
-        Ok(Self {
-            pending: Vec::new(),
-            dmabuf_textures: HashMap::new(),
-            dmabuf_targets: HashMap::new(),
-            pipelines: Pipelines::new(&shared)?,
-            pool,
-            spare_cmds: Vec::new(),
-            submissions: Cell::new(0),
-            staged: HashMap::new(),
-            stall: Cell::new(StallPhase {
-                // Measured on an RTX 3060, see research/nvidia.md.
-                phase: shared.device.name.contains("NVIDIA").then_some(1015),
-                seen: None,
-            }),
-            samplers,
-            min_filter: TextureFilter::Linear,
-            mag_filter: TextureFilter::Linear,
-            debug: DebugFlags::empty(),
-            context: ContextId::new(),
-            caps: Arc::new(DmabufCaps::query(&shared)),
-            shared,
-        })
-    }
-
-    /// Name of the physical device in use.
-    pub fn device_name(&self) -> &str {
-        &self.shared.device.name
-    }
-
-    /// Whether dmabufs can be imported, rendered into and allocated.
-    pub fn supports_dmabuf(&self) -> bool {
-        self.caps.render.iter().next().is_some()
-    }
-
-    /// Formats and modifiers this renderer can render into as dmabufs.
-    pub fn render_formats(&self) -> FormatSet {
-        self.caps.render.clone()
-    }
-
-    /// An allocator for render-capable dmabufs on this device.
-    pub fn allocator(&self) -> VulkanAllocator {
-        VulkanAllocator {
-            shared: self.shared.clone(),
-            caps: self.caps.clone(),
-        }
-    }
-
-    pub(crate) fn shared(&self) -> &Arc<Shared> {
-        &self.shared
-    }
-
-    pub(crate) fn context_id_ref(&self) -> &ContextId<VulkanTexture> {
-        &self.context
-    }
-
-    fn sampler(&self) -> vk::Sampler {
-        let idx = |f: TextureFilter| usize::from(f == TextureFilter::Nearest);
-        self.samplers[(idx(self.min_filter) << 1) | idx(self.mag_filter)]
-    }
-
-    fn reap(&mut self) {
-        let spare = &mut self.spare_cmds;
-        self.pending.retain(|p| {
-            if !p.fence.signaled() {
-                return true;
-            }
-            spare.push(p.cmd);
-            false
-        });
-        self.dmabuf_textures.retain(|k, _| !k.is_gone());
-        self.dmabuf_targets.retain(|k, _| !k.is_gone());
-    }
-
-    fn begin(&mut self) -> Result<vk::CommandBuffer, Error> {
-        let d = &self.shared.device.device;
-        let cmd = match self.spare_cmds.pop() {
-            Some(cmd) => {
-                unsafe { d.reset_command_buffer(cmd, vk::CommandBufferResetFlags::empty())? };
-                cmd
-            }
-            None => unsafe {
-                d.allocate_command_buffers(
-                    &vk::CommandBufferAllocateInfo::default()
-                        .command_pool(self.pool)
-                        .level(vk::CommandBufferLevel::PRIMARY)
-                        .command_buffer_count(1),
-                )?[0]
-            },
-        };
-        unsafe {
-            d.begin_command_buffer(
-                cmd,
-                &vk::CommandBufferBeginInfo::default()
-                    .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT),
-            )?
-        };
-        Ok(cmd)
-    }
-
-    #[profiling::function]
-    fn end_and_submit(&self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {
-        let d = &self.shared.device.device;
-        {
-            profiling::scope!("end_command_buffer");
-            unsafe { d.end_command_buffer(cmd)? };
-        }
-        let fence = {
-            profiling::scope!("create_fence");
-            FenceInner::new(&self.shared)?
-        };
-        let cmds = [vk::CommandBufferSubmitInfo::default().command_buffer(cmd)];
-        let submit = vk::SubmitInfo2::default().command_buffer_infos(&cmds);
-        let queue = self
-            .shared
-            .device
-            .queue
-            .lock()
-            .unwrap_or_else(|e| e.into_inner());
-        let began = Instant::now();
-        {
-            profiling::scope!("queue_submit");
-            unsafe { d.queue_submit2(*queue, &[submit], fence.fence())? };
-        }
-        let n = self.submissions.get();
-        self.submissions.set(n + 1);
-        if began.elapsed() > STALL {
-            self.stall.set(self.stall.get().saw(n % 1024));
-        }
-        Ok(fence)
-    }
-
-    /// Spends an upcoming stalling submission on empty command buffers, so
-    /// the stall lands now, in idle time, instead of in a frame. Call it
-    /// right after a flip. NVIDIA stalls for milliseconds on every 1024th
-    /// submission, see research/nvidia.md.
-    pub fn absorb_submit_stall(&mut self) -> Result<(), Error> {
-        self.reap();
-        let Some(phase) = self.stall.get().phase else {
-            return Ok(());
-        };
-        let ahead = (phase + 1024 - self.submissions.get() % 1024) % 1024;
-        if ahead >= ABSORB_AHEAD {
-            return Ok(());
-        }
-        for _ in 0..=ahead {
-            let cmd = self.begin()?;
-            let fence = self.end_and_submit(cmd)?;
-            self.pending.push(Pending {
-                fence,
-                cmd,
-                _keep: Vec::new(),
-                _staging: None,
-            });
-        }
-        Ok(())
-    }
-
-    /// Records, submits and waits for a short command buffer.
-    fn one_shot(
-        &mut self,
-        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),
-    ) -> Result<(), Error> {
-        let cmd = self.begin()?;
-        record(
-            &self.shared.device.device,
-            cmd,
-            self.shared.device.queue_family,
-        );
-        let fence = self.end_and_submit(cmd)?;
-        let res = fence.wait();
-        self.spare_cmds.push(cmd);
-        Ok(res?)
-    }
-
-    #[profiling::function]
-    pub(crate) fn submit(
-        &mut self,
-        target: &mut VulkanTarget<'_>,
-        ops: Vec<Op>,
-    ) -> Result<SyncPoint, Error> {
-        self.reap();
-        let image = target.0.clone();
-        let mut sampled: Vec<Arc<ImageInner>> = Vec::new();
-        for op in &ops {
-            if let Op::Draw {
-                texture: Some(t), ..
-            } = op
-                && !sampled.iter().any(|s| Arc::ptr_eq(s, &t.0))
-            {
-                sampled.push(t.0.clone());
-            }
-        }
-        let mut pipelines = Vec::with_capacity(ops.len());
-        for op in &ops {
-            pipelines.push(match op {
-                Op::Draw { kind, .. } => Some(self.pipelines.get(image.format, *kind)?),
-                Op::Clear { .. } => None,
-            });
-        }
-        let cmd = self.begin()?;
-        let d = &self.shared.device.device;
-        let family = self.shared.device.queue_family;
-        let push = &self.shared.device.push_descriptor;
-        let (w, h) = (image.width, image.height);
-        let sampler = self.sampler();
-        unsafe {
-            for t in &sampled {
-                acquire(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
-            }
-            acquire(
-                d,
-                cmd,
-                family,
-                &image,
-                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
-            );
-            let attachments = [vk::RenderingAttachmentInfo::default()
-                .image_view(image.view)
-                .image_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)
-                .load_op(vk::AttachmentLoadOp::LOAD)
-                .store_op(vk::AttachmentStoreOp::STORE)];
-            let area = vk::Rect2D {
-                offset: vk::Offset2D::default(),
-                extent: vk::Extent2D {
-                    width: w,
-                    height: h,
-                },
-            };
-            d.cmd_begin_rendering(
-                cmd,
-                &vk::RenderingInfo::default()
-                    .render_area(area)
-                    .layer_count(1)
-                    .color_attachments(&attachments),
-            );
-            d.cmd_set_viewport(
-                cmd,
-                0,
-                &[vk::Viewport {
-                    x: 0.0,
-                    y: 0.0,
-                    width: w as f32,
-                    height: h as f32,
-                    min_depth: 0.0,
-                    max_depth: 1.0,
-                }],
-            );
-            let mut bound = vk::Pipeline::null();
-            for (op, pipeline) in ops.iter().zip(pipelines) {
-                match op {
-                    Op::Clear { color, rects } => {
-                        let clear = [vk::ClearAttachment {
-                            aspect_mask: vk::ImageAspectFlags::COLOR,
-                            color_attachment: 0,
-                            clear_value: vk::ClearValue {
-                                color: vk::ClearColorValue { float32: *color },
-                            },
-                        }];
-                        let rects: Vec<_> = rects
-                            .iter()
-                            .map(|&rect| vk::ClearRect {
-                                rect,
-                                base_array_layer: 0,
-                                layer_count: 1,
-                            })
-                            .collect();
-                        d.cmd_clear_attachments(cmd, &clear, &rects);
-                    }
-                    Op::Draw {
-                        texture,
-                        push: constants,
-                        scissors,
-                        ..
-                    } => {
-                        let pipeline = pipeline.unwrap_or_default();
-                        if pipeline != bound {
-                            d.cmd_bind_pipeline(cmd, vk::PipelineBindPoint::GRAPHICS, pipeline);
-                            bound = pipeline;
-                        }
-                        if let Some(t) = texture {
-                            let info = [vk::DescriptorImageInfo::default()
-                                .image_view(t.0.view)
-                                .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
-                                .sampler(sampler)];
-                            let write = vk::WriteDescriptorSet::default()
-                                .dst_binding(0)
-                                .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
-                                .image_info(&info);
-                            push.cmd_push_descriptor_set(
-                                cmd,
-                                vk::PipelineBindPoint::GRAPHICS,
-                                self.pipelines.layout,
-                                0,
-                                &[write],
-                            );
-                        }
-                        d.cmd_push_constants(
-                            cmd,
-                            self.pipelines.layout,
-                            vk::ShaderStageFlags::VERTEX | vk::ShaderStageFlags::FRAGMENT,
-                            0,
-                            constants.bytes(),
-                        );
-                        for s in scissors {
-                            d.cmd_set_scissor(cmd, 0, &[*s]);
-                            d.cmd_draw(cmd, 4, 1, 0, 0);
-                        }
-                    }
-                }
-            }
-            d.cmd_end_rendering(cmd);
-            release(
-                d,
-                cmd,
-                family,
-                &image,
-                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
-            );
-            for t in &sampled {
-                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,
-        });
-        Ok(SyncPoint::from(VkFence(fence)))
-    }
-
-    /// Copies `region` of a full-image `data` into `image`, rows top-down or
-    /// flipped.
-    fn upload(
-        &mut self,
-        image: &Arc<ImageInner>,
-        data: &[u8],
-        region: Rectangle<i32, Buffer>,
-        flipped: bool,
-    ) -> Result<(), Error> {
-        let width = image.width as usize;
-        let rows = image.height as usize;
-        let needed = width * rows * BYTES_PER_PIXEL;
-        if data.len() < needed {
-            return Err(Error::BufferTooSmall {
-                needed,
-                got: data.len(),
-            });
-        }
-        let stride = width * BYTES_PER_PIXEL;
-        self.upload_with(image, region, |y| {
-            let from = if flipped { rows - 1 - y } else { y };
-            let start = from * stride + region.loc.x as usize * BYTES_PER_PIXEL;
-            &data[start..start + region.size.w as usize * BYTES_PER_PIXEL]
-        })
-    }
-
-    /// 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.
-    #[profiling::function]
-    fn upload_with<'a>(
-        &mut self,
-        image: &Arc<ImageInner>,
-        region: Rectangle<i32, Buffer>,
-        row: impl Fn(usize) -> &'a [u8],
-    ) -> Result<(), Error> {
-        if image.external {
-            return Err(Error::ForeignTexture);
-        }
-        self.reap();
-        if region.size.w <= 0 || region.size.h <= 0 {
-            return Ok(());
-        }
-        let staging = stage_rows(&self.shared, region, row)?;
-        self.copy_staged(image, region, staging)
-    }
-
-    /// Copies staged pixels into `region` of `image` on the GPU.
-    fn copy_staged(
-        &mut self,
-        image: &Arc<ImageInner>,
-        region: Rectangle<i32, Buffer>,
-        staging: Staging,
-    ) -> Result<(), Error> {
-        let (w, h) = (region.size.w as usize, region.size.h as usize);
-        let copy = vk::BufferImageCopy::default()
-            .buffer_row_length(w as u32)
-            .image_subresource(
-                vk::ImageSubresourceLayers::default()
-                    .aspect_mask(vk::ImageAspectFlags::COLOR)
-                    .layer_count(1),
-            )
-            .image_offset(vk::Offset3D {
-                x: region.loc.x,
-                y: region.loc.y,
-                z: 0,
-            })
-            .image_extent(vk::Extent3D {
-                width: w as u32,
-                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),
-        });
-        Ok(())
-    }
-
-    fn read_back(
-        &mut self,
-        image: &Arc<ImageInner>,
-        region: Rectangle<i32, Buffer>,
-        fourcc: Fourcc,
-    ) -> Result<VulkanMapping, Error> {
-        let region = region
-            .intersection(Rectangle::from_size(
-                (image.width as i32, image.height as i32).into(),
-            ))
-            .unwrap_or_default();
-        let (w, h) = (region.size.w.max(0) as u32, region.size.h.max(0) as u32);
-        let swap = needs_swizzle(image.fourcc, fourcc)?;
-        let len = (w as usize * h as usize * BYTES_PER_PIXEL).max(BYTES_PER_PIXEL);
-        let staging = Staging::new(
-            &self.shared,
-            len,
-            vk::BufferUsageFlags::TRANSFER_DST,
-            MemoryLocation::GpuToCpu,
-        )?;
-        if w > 0 && h > 0 {
-            let copy = vk::BufferImageCopy::default()
-                .image_subresource(
-                    vk::ImageSubresourceLayers::default()
-                        .aspect_mask(vk::ImageAspectFlags::COLOR)
-                        .layer_count(1),
-                )
-                .image_offset(vk::Offset3D {
-                    x: region.loc.x,
-                    y: region.loc.y,
-                    z: 0,
-                })
-                .image_extent(vk::Extent3D {
-                    width: w,
-                    height: h,
-                    depth: 1,
-                });
-            let buffer = staging.buffer;
-            let source = image.clone();
-            self.one_shot(|d, cmd, family| unsafe {
-                acquire(
-                    d,
-                    cmd,
-                    family,
-                    &source,
-                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
-                );
-                d.cmd_copy_image_to_buffer(
-                    cmd,
-                    source.image,
-                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
-                    buffer,
-                    &[copy],
-                );
-                release(
-                    d,
-                    cmd,
-                    family,
-                    &source,
-                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
-                );
-            })?;
-        }
-        let mut data = staging.bytes()[..w as usize * h as usize * BYTES_PER_PIXEL].to_vec();
-        if swap {
-            for px in data.as_chunks_mut::<BYTES_PER_PIXEL>().0 {
-                px.swap(0, 2);
-            }
-        }
-        Ok(VulkanMapping {
-            data,
-            width: w,
-            height: h,
-            fourcc,
-        })
-    }
-
-    fn own(&self, image: &Arc<ImageInner>) -> Result<(), Error> {
-        if Arc::ptr_eq(&image.shared, &self.shared) {
-            Ok(())
-        } else {
-            Err(Error::ForeignTexture)
-        }
-    }
-}
-
-impl Drop for VulkanRenderer {
-    fn drop(&mut self) {
-        let d = &self.shared.device.device;
-        unsafe {
-            let _ = d.device_wait_idle();
-            for p in self.pending.drain(..) {
-                d.free_command_buffers(self.pool, &[p.cmd]);
-            }
-            for s in self.samplers {
-                d.destroy_sampler(s, None);
-            }
-            d.destroy_command_pool(self.pool, None);
-        }
-    }
-}
-
-fn sampler_filter(bit: usize) -> TextureFilter {
-    if bit == 0 {
-        TextureFilter::Linear
-    } else {
-        TextureFilter::Nearest
-    }
-}
-
-/// A full barrier between all earlier and later work on the image, optionally
-/// transferring ownership between queue families. Coarse, but correct for
-/// every transition the renderer makes.
-unsafe fn barrier(
-    d: &ash::Device,
-    cmd: vk::CommandBuffer,
-    image: vk::Image,
-    old: vk::ImageLayout,
-    new: vk::ImageLayout,
-    src_family: u32,
-    dst_family: u32,
-) {
-    let b = [vk::ImageMemoryBarrier2::default()
-        .src_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)
-        .src_access_mask(vk::AccessFlags2::MEMORY_WRITE)
-        .dst_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)
-        .dst_access_mask(vk::AccessFlags2::MEMORY_READ | vk::AccessFlags2::MEMORY_WRITE)
-        .old_layout(old)
-        .new_layout(new)
-        .src_queue_family_index(src_family)
-        .dst_queue_family_index(dst_family)
-        .image(image)
-        .subresource_range(color_range())];
-    unsafe {
-        d.cmd_pipeline_barrier2(
-            cmd,
-            &vk::DependencyInfo::default().image_memory_barriers(&b),
-        )
-    };
-}
-
-/// Moves an image into `layout` for use on this queue. Dmabuf images come
-/// from the foreign queue family in the general layout, others continue from
-/// their tracked layout.
-unsafe fn acquire(
-    d: &ash::Device,
-    cmd: vk::CommandBuffer,
-    family: u32,
-    image: &ImageInner,
-    layout: vk::ImageLayout,
-) {
-    if image.external {
-        unsafe {
-            barrier(
-                d,
-                cmd,
-                image.image,
-                vk::ImageLayout::GENERAL,
-                layout,
-                vk::QUEUE_FAMILY_FOREIGN_EXT,
-                family,
-            )
-        };
-    } else {
-        let old = image.layout();
-        if old != layout {
-            unsafe {
-                barrier(
-                    d,
-                    cmd,
-                    image.image,
-                    old,
-                    layout,
-                    vk::QUEUE_FAMILY_IGNORED,
-                    vk::QUEUE_FAMILY_IGNORED,
-                )
-            };
-            image.set_layout(layout);
-        }
-    }
-}
-
-/// Hands a dmabuf image back to the foreign queue family after use.
-unsafe fn release(
-    d: &ash::Device,
-    cmd: vk::CommandBuffer,
-    family: u32,
-    image: &ImageInner,
-    layout: vk::ImageLayout,
-) {
-    if image.external {
-        unsafe {
-            barrier(
-                d,
-                cmd,
-                image.image,
-                layout,
-                vk::ImageLayout::GENERAL,
-                family,
-                vk::QUEUE_FAMILY_FOREIGN_EXT,
-            )
-        };
-    }
-}
-
-/// Whether reading `from` as `to` needs red and blue swapped.
-fn needs_swizzle(from: Fourcc, to: Fourcc) -> Result<bool, Error> {
-    let bgr = |f: Fourcc| match f {
-        Fourcc::Argb8888 | Fourcc::Xrgb8888 => Ok(true),
-        Fourcc::Abgr8888 | Fourcc::Xbgr8888 => Ok(false),
-        f => Err(Error::UnsupportedFormat(f)),
-    };
-    Ok(bgr(from)? != bgr(to)?)
-}
-
-impl RendererSuper for VulkanRenderer {
-    type Error = Error;
-    type TextureId = VulkanTexture;
-    type Framebuffer<'buffer> = VulkanTarget<'buffer>;
-    type Frame<'frame, 'buffer>
-        = VulkanFrame<'frame, 'buffer>
-    where
-        'buffer: 'frame,
-        Self: 'frame;
-}
-
-impl Renderer for VulkanRenderer {
-    fn context_id(&self) -> ContextId<VulkanTexture> {
-        self.context.clone()
-    }
-
-    fn downscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {
-        self.min_filter = filter;
-        Ok(())
-    }
-
-    fn upscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {
-        self.mag_filter = filter;
-        Ok(())
-    }
-
-    fn set_debug_flags(&mut self, flags: DebugFlags) {
-        self.debug = flags;
-    }
-
-    fn debug_flags(&self) -> DebugFlags {
-        self.debug
-    }
-
-    fn render<'frame, 'buffer>(
-        &'frame mut self,
-        framebuffer: &'frame mut VulkanTarget<'buffer>,
-        output_size: Size<i32, Physical>,
-        dst_transform: Transform,
-    ) -> Result<VulkanFrame<'frame, 'buffer>, Error>
-    where
-        'buffer: 'frame,
-    {
-        self.own(&framebuffer.0)?;
-        self.reap();
-        Ok(VulkanFrame::new(
-            self,
-            framebuffer,
-            output_size,
-            dst_transform,
-        ))
-    }
-
-    fn wait(&mut self, sync: &SyncPoint) -> Result<(), Error> {
-        sync.wait().map_err(|_| Error::Interrupted)
-    }
-
-    fn cleanup_texture_cache(&mut self) -> Result<(), Error> {
-        self.reap();
-        Ok(())
-    }
-
-    fn invalidate_caches(&mut self) -> Result<(), Error> {
-        self.reap();
-        self.dmabuf_textures.clear();
-        self.dmabuf_targets.clear();
-        Ok(())
-    }
-}
-
-impl Bind<VulkanImage> for VulkanRenderer {
-    fn bind<'a>(&mut self, target: &'a mut VulkanImage) -> Result<VulkanTarget<'a>, Error> {
-        self.own(&target.0)?;
-        Ok(VulkanTarget(target.0.clone(), PhantomData))
-    }
-}
-
-impl Bind<Dmabuf> for VulkanRenderer {
-    #[profiling::function]
-    fn bind<'a>(&mut self, target: &'a mut Dmabuf) -> Result<VulkanTarget<'a>, Error> {
-        let key = target.weak();
-        let image = match self.dmabuf_targets.get(&key) {
-            Some(image) => image.clone(),
-            None => {
-                let image = dmabuf::import(&self.shared, &self.caps, target, RENDER_USAGE)?;
-                self.dmabuf_targets.insert(key, image.clone());
-                image
-            }
-        };
-        Ok(VulkanTarget(image, PhantomData))
-    }
-
-    fn supported_formats(&self) -> Option<FormatSet> {
-        Some(self.caps.render.clone())
-    }
-}
-
-impl Offscreen<VulkanImage> for VulkanRenderer {
-    fn create_buffer(
-        &mut self,
-        format: Fourcc,
-        size: Size<i32, Buffer>,
-    ) -> Result<VulkanImage, Error> {
-        if size.w <= 0 || size.h <= 0 {
-            return Err(Error::InvalidSize(size.w, size.h));
-        }
-        let usage = vk::ImageUsageFlags::COLOR_ATTACHMENT
-            | vk::ImageUsageFlags::SAMPLED
-            | vk::ImageUsageFlags::TRANSFER_SRC
-            | vk::ImageUsageFlags::TRANSFER_DST;
-        Ok(VulkanImage(ImageInner::create(
-            &self.shared,
-            format,
-            size.w as u32,
-            size.h as u32,
-            usage,
-        )?))
-    }
-}
-
-impl ImportMem for VulkanRenderer {
-    fn import_memory(
-        &mut self,
-        data: &[u8],
-        format: Fourcc,
-        size: Size<i32, Buffer>,
-        flipped: bool,
-    ) -> Result<VulkanTexture, Error> {
-        if size.w <= 0 || size.h <= 0 {
-            return Err(Error::InvalidSize(size.w, size.h));
-        }
-        let usage = vk::ImageUsageFlags::SAMPLED
-            | vk::ImageUsageFlags::TRANSFER_DST
-            | vk::ImageUsageFlags::TRANSFER_SRC;
-        let image = ImageInner::create(&self.shared, format, size.w as u32, size.h as u32, usage)?;
-        self.upload(&image, data, Rectangle::from_size(size), flipped)?;
-        Ok(VulkanTexture(image))
-    }
-
-    fn update_memory(
-        &mut self,
-        texture: &VulkanTexture,
-        data: &[u8],
-        region: Rectangle<i32, Buffer>,
-    ) -> Result<(), Error> {
-        self.own(&texture.0)?;
-        let Some(region) = region.intersection(Rectangle::from_size(texture.size())) else {
-            return Ok(());
-        };
-        self.upload(&texture.0, data, region, false)
-    }
-
-    fn mem_formats(&self) -> Box<dyn Iterator<Item = Fourcc>> {
-        Box::new(SUPPORTED.into_iter())
-    }
-}
-
-impl ImportDma for VulkanRenderer {
-    fn dmabuf_formats(&self) -> FormatSet {
-        self.caps.sample.clone()
-    }
-
-    #[profiling::function]
-    fn import_dmabuf(
-        &mut self,
-        buffer: &Dmabuf,
-        _damage: Option<&[Rectangle<i32, Buffer>]>,
-    ) -> Result<VulkanTexture, Error> {
-        let key = buffer.weak();
-        if let Some(t) = self.dmabuf_textures.get(&key) {
-            return Ok(t.clone());
-        }
-        let texture = VulkanTexture(dmabuf::import(
-            &self.shared,
-            &self.caps,
-            buffer,
-            SAMPLE_USAGE,
-        )?);
-        self.dmabuf_textures.insert(key, texture.clone());
-        Ok(texture)
-    }
-}
-
-impl ImportDmaWl for VulkanRenderer {}
-
-/// Imports dmabufs on another thread. The textures it makes belong to the
-/// renderer it came from, which takes them back with `adopt_dmabuf`.
-#[derive(Clone)]
-pub struct DmabufImporter {
-    shared: Arc<Shared>,
-    caps: Arc<DmabufCaps>,
-}
-
-impl DmabufImporter {
-    pub fn import(&self, buffer: &Dmabuf) -> Result<VulkanTexture, Error> {
-        dmabuf::import(&self.shared, &self.caps, buffer, SAMPLE_USAGE).map(VulkanTexture)
-    }
-}
-
-impl VulkanRenderer {
-    pub fn dmabuf_importer(&self) -> DmabufImporter {
-        DmabufImporter {
-            shared: self.shared.clone(),
-            caps: self.caps.clone(),
-        }
-    }
-
-    pub fn has_dmabuf(&self, buffer: &Dmabuf) -> bool {
-        self.dmabuf_textures.contains_key(&buffer.weak())
-    }
-
-    pub fn adopt_dmabuf(&mut self, buffer: &Dmabuf, texture: VulkanTexture) -> Result<(), Error> {
-        self.own(&texture.0)?;
-        self.dmabuf_textures.insert(buffer.weak(), texture);
-        Ok(())
-    }
-}
-
-impl ExportMem for VulkanRenderer {
-    type TextureMapping = VulkanMapping;
-
-    fn copy_framebuffer(
-        &mut self,
-        target: &VulkanTarget<'_>,
-        region: Rectangle<i32, Buffer>,
-        format: Fourcc,
-    ) -> Result<VulkanMapping, Error> {
-        self.own(&target.0)?;
-        let image = target.0.clone();
-        self.read_back(&image, region, format)
-    }
-
-    fn copy_texture(
-        &mut self,
-        texture: &VulkanTexture,
-        region: Rectangle<i32, Buffer>,
-        format: Fourcc,
-    ) -> Result<VulkanMapping, Error> {
-        self.own(&texture.0)?;
-        self.read_back(&texture.0, region, format)
-    }
-
-    fn can_read_texture(&mut self, texture: &VulkanTexture) -> Result<bool, Error> {
-        Ok(texture.0.external || texture.0.layout() != vk::ImageLayout::UNDEFINED)
-    }
-
-    fn map_texture<'a>(&mut self, mapping: &'a VulkanMapping) -> Result<&'a [u8], Error> {
-        Ok(&mapping.data)
-    }
-}
-
-impl ImportMemWl for VulkanRenderer {
-    /// Keeps one texture per surface and uploads only the damaged rows into
-    /// it, straight from the client's shm pool.
-    fn import_shm_buffer(
-        &mut self,
-        buffer: &WlBuffer,
-        surface: Option<&SurfaceData>,
-        damage: &[Rectangle<i32, Buffer>],
-    ) -> Result<VulkanTexture, Error> {
-        self.staged.retain(|_, (b, _)| b.is_alive());
-        let staged = self.staged.remove(&buffer.id()).map(|(_, s)| s);
-        let cache = surface.map(|s| {
-            s.data_map
-                .insert_if_missing_threadsafe(|| ShmCache(Mutex::new(None)));
-            s.data_map.get::<ShmCache>().expect("just inserted")
-        });
-        with_buffer_contents(buffer, |ptr, len, data| {
-            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
-            let (w, h, stride, offset) = (
-                data.width as usize,
-                data.height as usize,
-                data.stride as usize,
-                data.offset as usize,
-            );
-            let line = w * BYTES_PER_PIXEL;
-            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
-                return Err(Error::ShmAccess);
-            }
-            let size = Size::from((data.width, data.height));
-            let full = Rectangle::from_size(size);
-            let reused = cache
-                .and_then(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
-                .filter(|t| {
-                    t.0.fourcc == fourcc
-                        && t.size() == size
-                        && Arc::ptr_eq(&t.0.shared, &self.shared)
-                });
-            let (texture, region) = match reused {
-                Some(t) => {
-                    let dirty = damage
-                        .iter()
-                        .filter_map(|d| d.intersection(full))
-                        .reduce(|a, b| a.merge(b));
-                    (t, if damage.is_empty() { Some(full) } else { dirty })
-                }
-                None => {
-                    let usage = vk::ImageUsageFlags::SAMPLED
-                        | vk::ImageUsageFlags::TRANSFER_DST
-                        | vk::ImageUsageFlags::TRANSFER_SRC;
-                    let image =
-                        ImageInner::create(&self.shared, fourcc, w as u32, h as u32, usage)?;
-                    (VulkanTexture(image), Some(full))
-                }
-            };
-            let staged = staged.filter(|s| {
-                s.fourcc == fourcc
-                    && s.size == size
-                    && region.is_some_and(|r| s.region.contains_rect(r))
-            });
-            if let Some(s) = staged {
-                tracing::trace!(region = ?s.region, "uploading a staged shm copy");
-                self.copy_staged(&texture.0, s.region, s.staging)?;
-            } else if let Some(region) = region {
-                let x = region.loc.x as usize * BYTES_PER_PIXEL;
-                let rw = region.size.w as usize * BYTES_PER_PIXEL;
-                self.upload_with(&texture.0, region, |y| unsafe {
-                    std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
-                })?;
-            }
-            if let Some(c) = cache {
-                *c.0.lock().unwrap_or_else(|e| e.into_inner()) = Some(texture.clone());
-            }
-            Ok(texture)
-        })
-        .map_err(|_| Error::ShmAccess)?
-    }
-}
-
-/// The texture last imported for a surface's shm buffers.
-struct ShmCache(Mutex<Option<VulkanTexture>>);
-
-/// Copies `region` of a full-image `row` source into new staging memory.
-fn stage_rows<'a>(
-    shared: &Arc<Shared>,
-    region: Rectangle<i32, Buffer>,
-    row: impl Fn(usize) -> &'a [u8],
-) -> Result<Staging, Error> {
-    let (w, h) = (region.size.w as usize, region.size.h as usize);
-    let line = w * BYTES_PER_PIXEL;
-    let mut staging = Staging::new(
-        shared,
-        line * h,
-        vk::BufferUsageFlags::TRANSFER_SRC,
-        MemoryLocation::CpuToGpu,
-    )?;
-    let dst = staging.bytes_mut();
-    for i in 0..h {
-        dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));
-    }
-    Ok(staging)
-}
-
-/// Shm pixels copied off the main thread, waiting for the import of the
-/// commit that shows them.
-pub struct StagedShm {
-    staging: Staging,
-    region: Rectangle<i32, Buffer>,
-    fourcc: Fourcc,
-    size: Size<i32, Buffer>,
-}
-
-/// Copies shm buffers into staging memory on another thread. The renderer
-/// it came from takes the result back with `adopt_staged`.
-#[derive(Clone)]
-pub struct ShmStager {
-    shared: Arc<Shared>,
-}
-
-impl ShmStager {
-    /// Stages `region` of `buffer`, all of it when the region is `None`.
-    pub fn stage(
-        &self,
-        buffer: &WlBuffer,
-        region: Option<Rectangle<i32, Buffer>>,
-    ) -> Result<StagedShm, Error> {
-        with_buffer_contents(buffer, |ptr, len, data| {
-            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
-            let (w, h, stride, offset) = (
-                data.width as usize,
-                data.height as usize,
-                data.stride as usize,
-                data.offset as usize,
-            );
-            let line = w * BYTES_PER_PIXEL;
-            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
-                return Err(Error::ShmAccess);
-            }
-            let size = Size::from((data.width, data.height));
-            let full = Rectangle::from_size(size);
-            let region = region.and_then(|r| r.intersection(full)).unwrap_or(full);
-            let x = region.loc.x as usize * BYTES_PER_PIXEL;
-            let rw = region.size.w as usize * BYTES_PER_PIXEL;
-            // SAFETY: the bounds check above keeps every row inside the
-            // `len` bytes smithay mapped at `ptr`.
-            let staging = stage_rows(&self.shared, region, |y| unsafe {
-                std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
-            })?;
-            Ok(StagedShm {
-                staging,
-                region,
-                fourcc,
-                size,
-            })
-        })
-        .map_err(|_| Error::ShmAccess)?
-    }
-}
-
-impl VulkanRenderer {
-    pub fn shm_stager(&self) -> ShmStager {
-        ShmStager {
-            shared: self.shared.clone(),
-        }
-    }
-
-    /// Hands back pixels a stager copied, used by the next import of `buffer`.
-    pub fn adopt_staged(&mut self, buffer: &WlBuffer, staged: StagedShm) {
-        if Arc::ptr_eq(&staged.staging.shared, &self.shared) {
-            self.staged.insert(buffer.id(), (buffer.clone(), staged));
-        }
-    }
-}

Added file: crates/render-vk/src/renderer/mod.rs+890 additions@@ -0,0 +1,890 @@
+mod shm;
+pub use shm::{ShmStager, StagedShm};
+mod stall;
+use shm::stage_rows;
+use stall::{STALL, StallPhase};
+
+use crate::Error;
+use crate::barrier::{acquire, release};
+use crate::device::Shared;
+use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};
+use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
+use crate::frame::{Op, VulkanFrame};
+use crate::image::{ImageInner, Staging, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};
+use crate::pipeline::Pipelines;
+use crate::sync::{FenceInner, VkFence};
+use ash::vk;
+use gpu_allocator::MemoryLocation;
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
+use smithay::backend::allocator::format::FormatSet;
+use smithay::backend::renderer::sync::SyncPoint;
+use smithay::backend::renderer::{
+    Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,
+    RendererSuper, Texture, TextureFilter,
+};
+use smithay::reexports::wayland_server::backend::ObjectId;
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};
+use std::cell::Cell;
+use std::collections::HashMap;
+use std::fmt;
+use std::marker::PhantomData;
+use std::sync::Arc;
+use std::time::Instant;
+
+struct Pending {
+    fence: Arc<FenceInner>,
+    cmd: vk::CommandBuffer,
+    _keep: Vec<Arc<ImageInner>>,
+    _staging: Option<Staging>,
+}
+
+pub struct VulkanRenderer {
+    pending: Vec<Pending>,
+    dmabuf_textures: HashMap<WeakDmabuf, VulkanTexture>,
+    dmabuf_targets: HashMap<WeakDmabuf, Arc<ImageInner>>,
+    pipelines: Pipelines,
+    pool: vk::CommandPool,
+    /// Command buffers whose work finished, reset and reused by `begin`.
+    spare_cmds: Vec<vk::CommandBuffer>,
+    samplers: [vk::Sampler; 4],
+    min_filter: TextureFilter,
+    mag_filter: TextureFilter,
+    debug: DebugFlags,
+    context: ContextId<VulkanTexture>,
+    caps: Arc<DmabufCaps>,
+    shared: Arc<Shared>,
+    submissions: Cell<u64>,
+    /// Shm uploads staged off the main thread, by buffer.
+    staged: HashMap<ObjectId, (WlBuffer, StagedShm)>,
+    stall: Cell<StallPhase>,
+}
+
+impl fmt::Debug for VulkanRenderer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("VulkanRenderer")
+            .field("device", &self.shared.device.name)
+            .finish()
+    }
+}
+
+impl VulkanRenderer {
+    pub fn new() -> Result<Self, Error> {
+        Self::with_node(None)
+    }
+
+    /// A renderer on the GPU behind DRM device number `node`, so it can
+    /// render into buffers that GPU scans out.
+    pub fn for_node(node: u64) -> Result<Self, Error> {
+        Self::with_node(Some(node))
+    }
+
+    fn with_node(node: Option<u64>) -> Result<Self, Error> {
+        let shared = Arc::new(Shared::new(node)?);
+        let d = &shared.device.device;
+        let pool = unsafe {
+            d.create_command_pool(
+                &vk::CommandPoolCreateInfo::default()
+                    .queue_family_index(shared.device.queue_family)
+                    .flags(
+                        vk::CommandPoolCreateFlags::TRANSIENT
+                            | vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER,
+                    ),
+                None,
+            )?
+        };
+        let filter = |f: TextureFilter| match f {
+            TextureFilter::Linear => vk::Filter::LINEAR,
+            TextureFilter::Nearest => vk::Filter::NEAREST,
+        };
+        let mut samplers = [vk::Sampler::null(); 4];
+        for (i, s) in samplers.iter_mut().enumerate() {
+            let (min, mag) = (sampler_filter(i >> 1), sampler_filter(i & 1));
+            *s = unsafe {
+                d.create_sampler(
+                    &vk::SamplerCreateInfo::default()
+                        .min_filter(filter(min))
+                        .mag_filter(filter(mag))
+                        .address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
+                        .address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
+                        .address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE),
+                    None,
+                )?
+            };
+        }
+        Ok(Self {
+            pending: Vec::new(),
+            dmabuf_textures: HashMap::new(),
+            dmabuf_targets: HashMap::new(),
+            pipelines: Pipelines::new(&shared)?,
+            pool,
+            spare_cmds: Vec::new(),
+            submissions: Cell::new(0),
+            staged: HashMap::new(),
+            stall: Cell::new(StallPhase::for_device(&shared.device.name)),
+            samplers,
+            min_filter: TextureFilter::Linear,
+            mag_filter: TextureFilter::Linear,
+            debug: DebugFlags::empty(),
+            context: ContextId::new(),
+            caps: Arc::new(DmabufCaps::query(&shared)),
+            shared,
+        })
+    }
+
+    /// Name of the physical device in use.
+    pub fn device_name(&self) -> &str {
+        &self.shared.device.name
+    }
+
+    /// Whether dmabufs can be imported, rendered into and allocated.
+    pub fn supports_dmabuf(&self) -> bool {
+        self.caps.render.iter().next().is_some()
+    }
+
+    /// Formats and modifiers this renderer can render into as dmabufs.
+    pub fn render_formats(&self) -> FormatSet {
+        self.caps.render.clone()
+    }
+
+    /// An allocator for render-capable dmabufs on this device.
+    pub fn allocator(&self) -> VulkanAllocator {
+        VulkanAllocator {
+            shared: self.shared.clone(),
+            caps: self.caps.clone(),
+        }
+    }
+
+    pub(crate) fn shared(&self) -> &Arc<Shared> {
+        &self.shared
+    }
+
+    pub(crate) fn context_id_ref(&self) -> &ContextId<VulkanTexture> {
+        &self.context
+    }
+
+    fn sampler(&self) -> vk::Sampler {
+        let idx = |f: TextureFilter| usize::from(f == TextureFilter::Nearest);
+        self.samplers[(idx(self.min_filter) << 1) | idx(self.mag_filter)]
+    }
+
+    fn reap(&mut self) {
+        let spare = &mut self.spare_cmds;
+        self.pending.retain(|p| {
+            if !p.fence.signaled() {
+                return true;
+            }
+            spare.push(p.cmd);
+            false
+        });
+        self.dmabuf_textures.retain(|k, _| !k.is_gone());
+        self.dmabuf_targets.retain(|k, _| !k.is_gone());
+    }
+
+    fn begin(&mut self) -> Result<vk::CommandBuffer, Error> {
+        let d = &self.shared.device.device;
+        let cmd = match self.spare_cmds.pop() {
+            Some(cmd) => {
+                unsafe { d.reset_command_buffer(cmd, vk::CommandBufferResetFlags::empty())? };
+                cmd
+            }
+            None => unsafe {
+                d.allocate_command_buffers(
+                    &vk::CommandBufferAllocateInfo::default()
+                        .command_pool(self.pool)
+                        .level(vk::CommandBufferLevel::PRIMARY)
+                        .command_buffer_count(1),
+                )?[0]
+            },
+        };
+        unsafe {
+            d.begin_command_buffer(
+                cmd,
+                &vk::CommandBufferBeginInfo::default()
+                    .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT),
+            )?
+        };
+        Ok(cmd)
+    }
+
+    #[profiling::function]
+    fn end_and_submit(&self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {
+        let d = &self.shared.device.device;
+        {
+            profiling::scope!("end_command_buffer");
+            unsafe { d.end_command_buffer(cmd)? };
+        }
+        let fence = {
+            profiling::scope!("create_fence");
+            FenceInner::new(&self.shared)?
+        };
+        let cmds = [vk::CommandBufferSubmitInfo::default().command_buffer(cmd)];
+        let submit = vk::SubmitInfo2::default().command_buffer_infos(&cmds);
+        let queue = self
+            .shared
+            .device
+            .queue
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        let began = Instant::now();
+        {
+            profiling::scope!("queue_submit");
+            unsafe { d.queue_submit2(*queue, &[submit], fence.fence())? };
+        }
+        let n = self.submissions.get();
+        self.submissions.set(n + 1);
+        if began.elapsed() > STALL {
+            self.stall.set(self.stall.get().saw(n % 1024));
+        }
+        Ok(fence)
+    }
+
+    /// Records, submits and waits for a short command buffer.
+    fn one_shot(
+        &mut self,
+        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),
+    ) -> Result<(), Error> {
+        let cmd = self.begin()?;
+        record(
+            &self.shared.device.device,
+            cmd,
+            self.shared.device.queue_family,
+        );
+        let fence = self.end_and_submit(cmd)?;
+        let res = fence.wait();
+        self.spare_cmds.push(cmd);
+        Ok(res?)
+    }
+
+    #[profiling::function]
+    pub(crate) fn submit(
+        &mut self,
+        target: &mut VulkanTarget<'_>,
+        ops: Vec<Op>,
+    ) -> Result<SyncPoint, Error> {
+        self.reap();
+        let image = target.0.clone();
+        let mut sampled: Vec<Arc<ImageInner>> = Vec::new();
+        for op in &ops {
+            if let Op::Draw {
+                texture: Some(t), ..
+            } = op
+                && !sampled.iter().any(|s| Arc::ptr_eq(s, &t.0))
+            {
+                sampled.push(t.0.clone());
+            }
+        }
+        let mut pipelines = Vec::with_capacity(ops.len());
+        for op in &ops {
+            pipelines.push(match op {
+                Op::Draw { kind, .. } => Some(self.pipelines.get(image.format, *kind)?),
+                Op::Clear { .. } => None,
+            });
+        }
+        let cmd = self.begin()?;
+        let d = &self.shared.device.device;
+        let family = self.shared.device.queue_family;
+        let push = &self.shared.device.push_descriptor;
+        let (w, h) = (image.width, image.height);
+        let sampler = self.sampler();
+        unsafe {
+            for t in &sampled {
+                acquire(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
+            }
+            acquire(
+                d,
+                cmd,
+                family,
+                &image,
+                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
+            );
+            let attachments = [vk::RenderingAttachmentInfo::default()
+                .image_view(image.view)
+                .image_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)
+                .load_op(vk::AttachmentLoadOp::LOAD)
+                .store_op(vk::AttachmentStoreOp::STORE)];
+            let area = vk::Rect2D {
+                offset: vk::Offset2D::default(),
+                extent: vk::Extent2D {
+                    width: w,
+                    height: h,
+                },
+            };
+            d.cmd_begin_rendering(
+                cmd,
+                &vk::RenderingInfo::default()
+                    .render_area(area)
+                    .layer_count(1)
+                    .color_attachments(&attachments),
+            );
+            d.cmd_set_viewport(
+                cmd,
+                0,
+                &[vk::Viewport {
+                    x: 0.0,
+                    y: 0.0,
+                    width: w as f32,
+                    height: h as f32,
+                    min_depth: 0.0,
+                    max_depth: 1.0,
+                }],
+            );
+            let mut bound = vk::Pipeline::null();
+            for (op, pipeline) in ops.iter().zip(pipelines) {
+                match op {
+                    Op::Clear { color, rects } => {
+                        let clear = [vk::ClearAttachment {
+                            aspect_mask: vk::ImageAspectFlags::COLOR,
+                            color_attachment: 0,
+                            clear_value: vk::ClearValue {
+                                color: vk::ClearColorValue { float32: *color },
+                            },
+                        }];
+                        let rects: Vec<_> = rects
+                            .iter()
+                            .map(|&rect| vk::ClearRect {
+                                rect,
+                                base_array_layer: 0,
+                                layer_count: 1,
+                            })
+                            .collect();
+                        d.cmd_clear_attachments(cmd, &clear, &rects);
+                    }
+                    Op::Draw {
+                        texture,
+                        push: constants,
+                        scissors,
+                        ..
+                    } => {
+                        let pipeline = pipeline.unwrap_or_default();
+                        if pipeline != bound {
+                            d.cmd_bind_pipeline(cmd, vk::PipelineBindPoint::GRAPHICS, pipeline);
+                            bound = pipeline;
+                        }
+                        if let Some(t) = texture {
+                            let info = [vk::DescriptorImageInfo::default()
+                                .image_view(t.0.view)
+                                .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
+                                .sampler(sampler)];
+                            let write = vk::WriteDescriptorSet::default()
+                                .dst_binding(0)
+                                .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
+                                .image_info(&info);
+                            push.cmd_push_descriptor_set(
+                                cmd,
+                                vk::PipelineBindPoint::GRAPHICS,
+                                self.pipelines.layout,
+                                0,
+                                &[write],
+                            );
+                        }
+                        d.cmd_push_constants(
+                            cmd,
+                            self.pipelines.layout,
+                            vk::ShaderStageFlags::VERTEX | vk::ShaderStageFlags::FRAGMENT,
+                            0,
+                            constants.bytes(),
+                        );
+                        for s in scissors {
+                            d.cmd_set_scissor(cmd, 0, &[*s]);
+                            d.cmd_draw(cmd, 4, 1, 0, 0);
+                        }
+                    }
+                }
+            }
+            d.cmd_end_rendering(cmd);
+            release(
+                d,
+                cmd,
+                family,
+                &image,
+                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
+            );
+            for t in &sampled {
+                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,
+        });
+        Ok(SyncPoint::from(VkFence(fence)))
+    }
+
+    /// Copies `region` of a full-image `data` into `image`, rows top-down or
+    /// flipped.
+    fn upload(
+        &mut self,
+        image: &Arc<ImageInner>,
+        data: &[u8],
+        region: Rectangle<i32, Buffer>,
+        flipped: bool,
+    ) -> Result<(), Error> {
+        let width = image.width as usize;
+        let rows = image.height as usize;
+        let needed = width * rows * BYTES_PER_PIXEL;
+        if data.len() < needed {
+            return Err(Error::BufferTooSmall {
+                needed,
+                got: data.len(),
+            });
+        }
+        let stride = width * BYTES_PER_PIXEL;
+        self.upload_with(image, region, |y| {
+            let from = if flipped { rows - 1 - y } else { y };
+            let start = from * stride + region.loc.x as usize * BYTES_PER_PIXEL;
+            &data[start..start + region.size.w as usize * BYTES_PER_PIXEL]
+        })
+    }
+
+    /// 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.
+    #[profiling::function]
+    fn upload_with<'a>(
+        &mut self,
+        image: &Arc<ImageInner>,
+        region: Rectangle<i32, Buffer>,
+        row: impl Fn(usize) -> &'a [u8],
+    ) -> Result<(), Error> {
+        if image.external {
+            return Err(Error::ForeignTexture);
+        }
+        self.reap();
+        if region.size.w <= 0 || region.size.h <= 0 {
+            return Ok(());
+        }
+        let staging = stage_rows(&self.shared, region, row)?;
+        self.copy_staged(image, region, staging)
+    }
+
+    /// Copies staged pixels into `region` of `image` on the GPU.
+    fn copy_staged(
+        &mut self,
+        image: &Arc<ImageInner>,
+        region: Rectangle<i32, Buffer>,
+        staging: Staging,
+    ) -> Result<(), Error> {
+        let (w, h) = (region.size.w as usize, region.size.h as usize);
+        let copy = vk::BufferImageCopy::default()
+            .buffer_row_length(w as u32)
+            .image_subresource(
+                vk::ImageSubresourceLayers::default()
+                    .aspect_mask(vk::ImageAspectFlags::COLOR)
+                    .layer_count(1),
+            )
+            .image_offset(vk::Offset3D {
+                x: region.loc.x,
+                y: region.loc.y,
+                z: 0,
+            })
+            .image_extent(vk::Extent3D {
+                width: w as u32,
+                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),
+        });
+        Ok(())
+    }
+
+    fn read_back(
+        &mut self,
+        image: &Arc<ImageInner>,
+        region: Rectangle<i32, Buffer>,
+        fourcc: Fourcc,
+    ) -> Result<VulkanMapping, Error> {
+        let region = region
+            .intersection(Rectangle::from_size(
+                (image.width as i32, image.height as i32).into(),
+            ))
+            .unwrap_or_default();
+        let (w, h) = (region.size.w.max(0) as u32, region.size.h.max(0) as u32);
+        let swap = needs_swizzle(image.fourcc, fourcc)?;
+        let len = (w as usize * h as usize * BYTES_PER_PIXEL).max(BYTES_PER_PIXEL);
+        let staging = Staging::new(
+            &self.shared,
+            len,
+            vk::BufferUsageFlags::TRANSFER_DST,
+            MemoryLocation::GpuToCpu,
+        )?;
+        if w > 0 && h > 0 {
+            let copy = vk::BufferImageCopy::default()
+                .image_subresource(
+                    vk::ImageSubresourceLayers::default()
+                        .aspect_mask(vk::ImageAspectFlags::COLOR)
+                        .layer_count(1),
+                )
+                .image_offset(vk::Offset3D {
+                    x: region.loc.x,
+                    y: region.loc.y,
+                    z: 0,
+                })
+                .image_extent(vk::Extent3D {
+                    width: w,
+                    height: h,
+                    depth: 1,
+                });
+            let buffer = staging.buffer;
+            let source = image.clone();
+            self.one_shot(|d, cmd, family| unsafe {
+                acquire(
+                    d,
+                    cmd,
+                    family,
+                    &source,
+                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                );
+                d.cmd_copy_image_to_buffer(
+                    cmd,
+                    source.image,
+                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                    buffer,
+                    &[copy],
+                );
+                release(
+                    d,
+                    cmd,
+                    family,
+                    &source,
+                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                );
+            })?;
+        }
+        let mut data = staging.bytes()[..w as usize * h as usize * BYTES_PER_PIXEL].to_vec();
+        if swap {
+            for px in data.as_chunks_mut::<BYTES_PER_PIXEL>().0 {
+                px.swap(0, 2);
+            }
+        }
+        Ok(VulkanMapping {
+            data,
+            width: w,
+            height: h,
+            fourcc,
+        })
+    }
+
+    fn own(&self, image: &Arc<ImageInner>) -> Result<(), Error> {
+        if Arc::ptr_eq(&image.shared, &self.shared) {
+            Ok(())
+        } else {
+            Err(Error::ForeignTexture)
+        }
+    }
+}
+
+impl Drop for VulkanRenderer {
+    fn drop(&mut self) {
+        let d = &self.shared.device.device;
+        unsafe {
+            let _ = d.device_wait_idle();
+            for p in self.pending.drain(..) {
+                d.free_command_buffers(self.pool, &[p.cmd]);
+            }
+            for s in self.samplers {
+                d.destroy_sampler(s, None);
+            }
+            d.destroy_command_pool(self.pool, None);
+        }
+    }
+}
+
+fn sampler_filter(bit: usize) -> TextureFilter {
+    if bit == 0 {
+        TextureFilter::Linear
+    } else {
+        TextureFilter::Nearest
+    }
+}
+
+/// Whether reading `from` as `to` needs red and blue swapped.
+fn needs_swizzle(from: Fourcc, to: Fourcc) -> Result<bool, Error> {
+    let bgr = |f: Fourcc| match f {
+        Fourcc::Argb8888 | Fourcc::Xrgb8888 => Ok(true),
+        Fourcc::Abgr8888 | Fourcc::Xbgr8888 => Ok(false),
+        f => Err(Error::UnsupportedFormat(f)),
+    };
+    Ok(bgr(from)? != bgr(to)?)
+}
+
+impl RendererSuper for VulkanRenderer {
+    type Error = Error;
+    type TextureId = VulkanTexture;
+    type Framebuffer<'buffer> = VulkanTarget<'buffer>;
+    type Frame<'frame, 'buffer>
+        = VulkanFrame<'frame, 'buffer>
+    where
+        'buffer: 'frame,
+        Self: 'frame;
+}
+
+impl Renderer for VulkanRenderer {
+    fn context_id(&self) -> ContextId<VulkanTexture> {
+        self.context.clone()
+    }
+
+    fn downscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {
+        self.min_filter = filter;
+        Ok(())
+    }
+
+    fn upscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {
+        self.mag_filter = filter;
+        Ok(())
+    }
+
+    fn set_debug_flags(&mut self, flags: DebugFlags) {
+        self.debug = flags;
+    }
+
+    fn debug_flags(&self) -> DebugFlags {
+        self.debug
+    }
+
+    fn render<'frame, 'buffer>(
+        &'frame mut self,
+        framebuffer: &'frame mut VulkanTarget<'buffer>,
+        output_size: Size<i32, Physical>,
+        dst_transform: Transform,
+    ) -> Result<VulkanFrame<'frame, 'buffer>, Error>
+    where
+        'buffer: 'frame,
+    {
+        self.own(&framebuffer.0)?;
+        self.reap();
+        Ok(VulkanFrame::new(
+            self,
+            framebuffer,
+            output_size,
+            dst_transform,
+        ))
+    }
+
+    fn wait(&mut self, sync: &SyncPoint) -> Result<(), Error> {
+        sync.wait().map_err(|_| Error::Interrupted)
+    }
+
+    fn cleanup_texture_cache(&mut self) -> Result<(), Error> {
+        self.reap();
+        Ok(())
+    }
+
+    fn invalidate_caches(&mut self) -> Result<(), Error> {
+        self.reap();
+        self.dmabuf_textures.clear();
+        self.dmabuf_targets.clear();
+        Ok(())
+    }
+}
+
+impl Bind<VulkanImage> for VulkanRenderer {
+    fn bind<'a>(&mut self, target: &'a mut VulkanImage) -> Result<VulkanTarget<'a>, Error> {
+        self.own(&target.0)?;
+        Ok(VulkanTarget(target.0.clone(), PhantomData))
+    }
+}
+
+impl Bind<Dmabuf> for VulkanRenderer {
+    #[profiling::function]
+    fn bind<'a>(&mut self, target: &'a mut Dmabuf) -> Result<VulkanTarget<'a>, Error> {
+        let key = target.weak();
+        let image = match self.dmabuf_targets.get(&key) {
+            Some(image) => image.clone(),
+            None => {
+                let image = dmabuf::import(&self.shared, &self.caps, target, RENDER_USAGE)?;
+                self.dmabuf_targets.insert(key, image.clone());
+                image
+            }
+        };
+        Ok(VulkanTarget(image, PhantomData))
+    }
+
+    fn supported_formats(&self) -> Option<FormatSet> {
+        Some(self.caps.render.clone())
+    }
+}
+
+impl Offscreen<VulkanImage> for VulkanRenderer {
+    fn create_buffer(
+        &mut self,
+        format: Fourcc,
+        size: Size<i32, Buffer>,
+    ) -> Result<VulkanImage, Error> {
+        if size.w <= 0 || size.h <= 0 {
+            return Err(Error::InvalidSize(size.w, size.h));
+        }
+        let usage = vk::ImageUsageFlags::COLOR_ATTACHMENT
+            | vk::ImageUsageFlags::SAMPLED
+            | vk::ImageUsageFlags::TRANSFER_SRC
+            | vk::ImageUsageFlags::TRANSFER_DST;
+        Ok(VulkanImage(ImageInner::create(
+            &self.shared,
+            format,
+            size.w as u32,
+            size.h as u32,
+            usage,
+        )?))
+    }
+}
+
+impl ImportMem for VulkanRenderer {
+    fn import_memory(
+        &mut self,
+        data: &[u8],
+        format: Fourcc,
+        size: Size<i32, Buffer>,
+        flipped: bool,
+    ) -> Result<VulkanTexture, Error> {
+        if size.w <= 0 || size.h <= 0 {
+            return Err(Error::InvalidSize(size.w, size.h));
+        }
+        let usage = vk::ImageUsageFlags::SAMPLED
+            | vk::ImageUsageFlags::TRANSFER_DST
+            | vk::ImageUsageFlags::TRANSFER_SRC;
+        let image = ImageInner::create(&self.shared, format, size.w as u32, size.h as u32, usage)?;
+        self.upload(&image, data, Rectangle::from_size(size), flipped)?;
+        Ok(VulkanTexture(image))
+    }
+
+    fn update_memory(
+        &mut self,
+        texture: &VulkanTexture,
+        data: &[u8],
+        region: Rectangle<i32, Buffer>,
+    ) -> Result<(), Error> {
+        self.own(&texture.0)?;
+        let Some(region) = region.intersection(Rectangle::from_size(texture.size())) else {
+            return Ok(());
+        };
+        self.upload(&texture.0, data, region, false)
+    }
+
+    fn mem_formats(&self) -> Box<dyn Iterator<Item = Fourcc>> {
+        Box::new(SUPPORTED.into_iter())
+    }
+}
+
+impl ImportDma for VulkanRenderer {
+    fn dmabuf_formats(&self) -> FormatSet {
+        self.caps.sample.clone()
+    }
+
+    #[profiling::function]
+    fn import_dmabuf(
+        &mut self,
+        buffer: &Dmabuf,
+        _damage: Option<&[Rectangle<i32, Buffer>]>,
+    ) -> Result<VulkanTexture, Error> {
+        let key = buffer.weak();
+        if let Some(t) = self.dmabuf_textures.get(&key) {
+            return Ok(t.clone());
+        }
+        let texture = VulkanTexture(dmabuf::import(
+            &self.shared,
+            &self.caps,
+            buffer,
+            SAMPLE_USAGE,
+        )?);
+        self.dmabuf_textures.insert(key, texture.clone());
+        Ok(texture)
+    }
+}
+
+impl ImportDmaWl for VulkanRenderer {}
+
+/// Imports dmabufs on another thread. The textures it makes belong to the
+/// renderer it came from, which takes them back with `adopt_dmabuf`.
+#[derive(Clone)]
+pub struct DmabufImporter {
+    shared: Arc<Shared>,
+    caps: Arc<DmabufCaps>,
+}
+
+impl DmabufImporter {
+    pub fn import(&self, buffer: &Dmabuf) -> Result<VulkanTexture, Error> {
+        dmabuf::import(&self.shared, &self.caps, buffer, SAMPLE_USAGE).map(VulkanTexture)
+    }
+}
+
+impl VulkanRenderer {
+    pub fn dmabuf_importer(&self) -> DmabufImporter {
+        DmabufImporter {
+            shared: self.shared.clone(),
+            caps: self.caps.clone(),
+        }
+    }
+
+    pub fn has_dmabuf(&self, buffer: &Dmabuf) -> bool {
+        self.dmabuf_textures.contains_key(&buffer.weak())
+    }
+
+    pub fn adopt_dmabuf(&mut self, buffer: &Dmabuf, texture: VulkanTexture) -> Result<(), Error> {
+        self.own(&texture.0)?;
+        self.dmabuf_textures.insert(buffer.weak(), texture);
+        Ok(())
+    }
+}
+
+impl ExportMem for VulkanRenderer {
+    type TextureMapping = VulkanMapping;
+
+    fn copy_framebuffer(
+        &mut self,
+        target: &VulkanTarget<'_>,
+        region: Rectangle<i32, Buffer>,
+        format: Fourcc,
+    ) -> Result<VulkanMapping, Error> {
+        self.own(&target.0)?;
+        let image = target.0.clone();
+        self.read_back(&image, region, format)
+    }
+
+    fn copy_texture(
+        &mut self,
+        texture: &VulkanTexture,
+        region: Rectangle<i32, Buffer>,
+        format: Fourcc,
+    ) -> Result<VulkanMapping, Error> {
+        self.own(&texture.0)?;
+        self.read_back(&texture.0, region, format)
+    }
+
+    fn can_read_texture(&mut self, texture: &VulkanTexture) -> Result<bool, Error> {
+        Ok(texture.0.external || texture.0.layout() != vk::ImageLayout::UNDEFINED)
+    }
+
+    fn map_texture<'a>(&mut self, mapping: &'a VulkanMapping) -> Result<&'a [u8], Error> {
+        Ok(&mapping.data)
+    }
+}

Added file: crates/render-vk/src/renderer/shm.rs+189 additions@@ -0,0 +1,189 @@
+use super::VulkanRenderer;
+use crate::Error;
+use crate::device::Shared;
+use crate::format::BYTES_PER_PIXEL;
+use crate::image::{ImageInner, Staging, VulkanTexture};
+use ash::vk;
+use gpu_allocator::MemoryLocation;
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::ImportMemWl;
+use smithay::backend::renderer::Texture;
+use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::utils::{Buffer, Rectangle, Size};
+use smithay::wayland::compositor::SurfaceData;
+use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents};
+use std::sync::{Arc, Mutex};
+
+impl ImportMemWl for VulkanRenderer {
+    /// Keeps one texture per surface and uploads only the damaged rows into
+    /// it, straight from the client's shm pool.
+    fn import_shm_buffer(
+        &mut self,
+        buffer: &WlBuffer,
+        surface: Option<&SurfaceData>,
+        damage: &[Rectangle<i32, Buffer>],
+    ) -> Result<VulkanTexture, Error> {
+        self.staged.retain(|_, (b, _)| b.is_alive());
+        let staged = self.staged.remove(&buffer.id()).map(|(_, s)| s);
+        let cache = surface.map(|s| {
+            s.data_map
+                .insert_if_missing_threadsafe(|| ShmCache(Mutex::new(None)));
+            s.data_map.get::<ShmCache>().expect("just inserted")
+        });
+        with_buffer_contents(buffer, |ptr, len, data| {
+            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
+            let (w, h, stride, offset) = (
+                data.width as usize,
+                data.height as usize,
+                data.stride as usize,
+                data.offset as usize,
+            );
+            let line = w * BYTES_PER_PIXEL;
+            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
+                return Err(Error::ShmAccess);
+            }
+            let size = Size::from((data.width, data.height));
+            let full = Rectangle::from_size(size);
+            let reused = cache
+                .and_then(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
+                .filter(|t| {
+                    t.0.fourcc == fourcc
+                        && t.size() == size
+                        && Arc::ptr_eq(&t.0.shared, &self.shared)
+                });
+            let (texture, region) = match reused {
+                Some(t) => {
+                    let dirty = damage
+                        .iter()
+                        .filter_map(|d| d.intersection(full))
+                        .reduce(|a, b| a.merge(b));
+                    (t, if damage.is_empty() { Some(full) } else { dirty })
+                }
+                None => {
+                    let usage = vk::ImageUsageFlags::SAMPLED
+                        | vk::ImageUsageFlags::TRANSFER_DST
+                        | vk::ImageUsageFlags::TRANSFER_SRC;
+                    let image =
+                        ImageInner::create(&self.shared, fourcc, w as u32, h as u32, usage)?;
+                    (VulkanTexture(image), Some(full))
+                }
+            };
+            let staged = staged.filter(|s| {
+                s.fourcc == fourcc
+                    && s.size == size
+                    && region.is_some_and(|r| s.region.contains_rect(r))
+            });
+            if let Some(s) = staged {
+                tracing::trace!(region = ?s.region, "uploading a staged shm copy");
+                self.copy_staged(&texture.0, s.region, s.staging)?;
+            } else if let Some(region) = region {
+                let x = region.loc.x as usize * BYTES_PER_PIXEL;
+                let rw = region.size.w as usize * BYTES_PER_PIXEL;
+                self.upload_with(&texture.0, region, |y| unsafe {
+                    std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
+                })?;
+            }
+            if let Some(c) = cache {
+                *c.0.lock().unwrap_or_else(|e| e.into_inner()) = Some(texture.clone());
+            }
+            Ok(texture)
+        })
+        .map_err(|_| Error::ShmAccess)?
+    }
+}
+
+/// The texture last imported for a surface's shm buffers.
+struct ShmCache(Mutex<Option<VulkanTexture>>);
+
+/// Copies `region` of a full-image `row` source into new staging memory.
+pub(super) fn stage_rows<'a>(
+    shared: &Arc<Shared>,
+    region: Rectangle<i32, Buffer>,
+    row: impl Fn(usize) -> &'a [u8],
+) -> Result<Staging, Error> {
+    let (w, h) = (region.size.w as usize, region.size.h as usize);
+    let line = w * BYTES_PER_PIXEL;
+    let mut staging = Staging::new(
+        shared,
+        line * h,
+        vk::BufferUsageFlags::TRANSFER_SRC,
+        MemoryLocation::CpuToGpu,
+    )?;
+    let dst = staging.bytes_mut();
+    for i in 0..h {
+        dst[i * line..(i + 1) * line].copy_from_slice(row(region.loc.y as usize + i));
+    }
+    Ok(staging)
+}
+
+/// Shm pixels copied off the main thread, waiting for the import of the
+/// commit that shows them.
+pub struct StagedShm {
+    staging: Staging,
+    region: Rectangle<i32, Buffer>,
+    fourcc: Fourcc,
+    size: Size<i32, Buffer>,
+}
+
+/// Copies shm buffers into staging memory on another thread. The renderer
+/// it came from takes the result back with `adopt_staged`.
+#[derive(Clone)]
+pub struct ShmStager {
+    shared: Arc<Shared>,
+}
+
+impl ShmStager {
+    /// Stages `region` of `buffer`, all of it when the region is `None`.
+    pub fn stage(
+        &self,
+        buffer: &WlBuffer,
+        region: Option<Rectangle<i32, Buffer>>,
+    ) -> Result<StagedShm, Error> {
+        with_buffer_contents(buffer, |ptr, len, data| {
+            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
+            let (w, h, stride, offset) = (
+                data.width as usize,
+                data.height as usize,
+                data.stride as usize,
+                data.offset as usize,
+            );
+            let line = w * BYTES_PER_PIXEL;
+            if w == 0 || h == 0 || stride < line || offset + stride * (h - 1) + line > len {
+                return Err(Error::ShmAccess);
+            }
+            let size = Size::from((data.width, data.height));
+            let full = Rectangle::from_size(size);
+            let region = region.and_then(|r| r.intersection(full)).unwrap_or(full);
+            let x = region.loc.x as usize * BYTES_PER_PIXEL;
+            let rw = region.size.w as usize * BYTES_PER_PIXEL;
+            // SAFETY: the bounds check above keeps every row inside the
+            // `len` bytes smithay mapped at `ptr`.
+            let staging = stage_rows(&self.shared, region, |y| unsafe {
+                std::slice::from_raw_parts(ptr.add(offset + y * stride + x), rw)
+            })?;
+            Ok(StagedShm {
+                staging,
+                region,
+                fourcc,
+                size,
+            })
+        })
+        .map_err(|_| Error::ShmAccess)?
+    }
+}
+
+impl VulkanRenderer {
+    pub fn shm_stager(&self) -> ShmStager {
+        ShmStager {
+            shared: self.shared.clone(),
+        }
+    }
+
+    /// Hands back pixels a stager copied, used by the next import of `buffer`.
+    pub fn adopt_staged(&mut self, buffer: &WlBuffer, staged: StagedShm) {
+        if Arc::ptr_eq(&staged.staging.shared, &self.shared) {
+            self.staged.insert(buffer.id(), (buffer.clone(), staged));
+        }
+    }
+}

Added file: crates/render-vk/src/renderer/stall.rs+72 additions@@ -0,0 +1,72 @@
+use super::{Pending, VulkanRenderer};
+use crate::Error;
+use std::time::Duration;
+
+/// Where in every 1024 submissions the driver stalls. A phase is trusted
+/// once two stalls land on it.
+#[derive(Clone, Copy, Default)]
+pub(super) struct StallPhase {
+    phase: Option<u64>,
+    seen: Option<u64>,
+}
+
+impl StallPhase {
+    pub(super) fn for_device(name: &str) -> Self {
+        Self {
+            // Measured on an RTX 3060, see research/nvidia.md.
+            phase: name.contains("NVIDIA").then_some(1015),
+            seen: None,
+        }
+    }
+
+    pub(super) fn saw(self, at: u64) -> Self {
+        if self.seen == Some(at) {
+            if self.phase != Some(at) {
+                tracing::debug!(phase = at, "queue submissions stall periodically");
+            }
+            Self {
+                phase: Some(at),
+                seen: Some(at),
+            }
+        } else {
+            Self {
+                seen: Some(at),
+                ..self
+            }
+        }
+    }
+}
+
+/// A submission this slow is a driver stall rather than work.
+pub(super) const STALL: Duration = Duration::from_micros(1500);
+/// How many submissions early a stall is absorbed. Each empty one costs
+/// tens of microseconds.
+const ABSORB_AHEAD: u64 = 8;
+
+impl VulkanRenderer {
+    /// Spends an upcoming stalling submission on empty command buffers, so
+    /// the stall lands now, in idle time, instead of in a frame. Call it
+    /// right after a flip. NVIDIA stalls for milliseconds on every 1024th
+    /// submission, see research/nvidia.md.
+    pub fn absorb_submit_stall(&mut self) -> Result<(), Error> {
+        self.reap();
+        let Some(phase) = self.stall.get().phase else {
+            return Ok(());
+        };
+        let ahead = (phase + 1024 - self.submissions.get() % 1024) % 1024;
+        if ahead >= ABSORB_AHEAD {
+            return Ok(());
+        }
+        for _ in 0..=ahead {
+            let cmd = self.begin()?;
+            let fence = self.end_and_submit(cmd)?;
+            self.pending.push(Pending {
+                fence,
+                cmd,
+                _keep: Vec::new(),
+                _staging: None,
+            });
+        }
+        Ok(())
+    }
+}

monolith

Commit de1e9f21296c

Commit `de1e9f21296c`