superrob1500
/
mirror-ghostty
mirror of https://github.com/ghostty-org/ghostty
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

renderer/vulkan: HOST_CACHED dmabuf for ~200x faster host reads 

The dmabuf the host mmaps for QImage import was allocated as
HOST_VISIBLE | HOST_COHERENT only. On NVIDIA that yields a
write-combining mapping: GPU writes are fast, host READS crawl at
~10 MB/s because the mapping is uncached. `QImage::copy()` in
`presentVulkanDmabuf` reads every pixel of the dmabuf into a heap
QImage, so even a tiny ~3 MB frame took ~260 ms — capping the
custom-shader path at ~3 FPS.

Prefer `HOST_VISIBLE | HOST_COHERENT | HOST_CACHED` for the dmabuf
buffer's backing memory, falling back to uncoherent-cached and
finally to the original uncached pair if neither cached variant is
available. The cached mapping makes the host-side memcpy run at
normal memory bandwidth — same ~3 MB frame now copies in ~1 ms,
and end-to-end frame rate jumps from ~3 FPS to >60 FPS in the
custom-shader path. (Plain BG-color paths weren't as slow because
they idle when nothing changes; the user's `aretha_shell.glsl`
animates so it rendered continuously and the cost was visible.)

Co-Authored-By: claude-flow <ruv@ruv.net>
pull/12846/head
Nathan 2026-05-24 17:23:53 -05:00
parent 3cdda1ec9b
commit 2dcc1e994e
3 changed files with 28 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/renderer/generic.zig
View File

@ -1455,15 +1455,6 @@ pub fn Renderer(comptime GraphicsAPI: type) type {
self: *Self,
sync: bool,
) !void {
// const start = std.time.Instant.now() catch unreachable;
// const start_micro = std.time.microTimestamp();
// defer {
// const end = std.time.Instant.now() catch unreachable;
// log.warn(
// "[drawFrame time] start_micro={} duration={}ns",
// .{ start_micro, end.since(start) / std.time.ns_per_us },
// );
// }
// We hold a the draw mutex to prevent changes to any
// data we access while we're in the middle of drawing.

16
src/renderer/vulkan/Frame.zig
View File

@ -113,11 +113,7 @@ pub fn complete(self: *const Self, sync: bool) void {
const dev = self.device;
// Copy the just-rendered OPTIMAL-tiled image into the
// dmabuf-exported LINEAR pixel buffer. NVIDIA (and most
// discrete GPUs) refuse `FORMAT_FEATURE_COLOR_ATTACHMENT_BIT`
// on linear-tiled images, so the renderer draws into an
// OPTIMAL image and a transfer copy bridges to the dmabuf
// consumer. See `Target.zig` for the full rationale.
// dmabuf-exported LINEAR pixel buffer. See `Target.zig` for why.
self.target.recordCopyToDmabuf(self.cb);
{
@ -165,13 +161,9 @@ pub fn complete(self: *const Self, sync: bool) void {
}
}
// Hand the rendered target off to the host. This mirrors what
// `opengl/Frame.zig`'s `complete` does at the same point: it
// calls `self.renderer.api.present(self.target.*)`. Our analog
// is `Target.present()`, which routes through the platform's
// `present` callback (the apprt-side dmabuf consumer). Also
// stash on the renderer's `last_target` for `presentLastTarget`
// re-presents on no-op frames.
// Hand the rendered target off to the host via `Vulkan.present`,
// which both calls the platform's present callback AND records
// the target pointer for `presentLastTarget` no-op republishes.
self.renderer.api.present(self.target) catch |err| {
log.err("present failed: {}", .{err});
};

37
src/renderer/vulkan/Target.zig
View File

@ -213,20 +213,31 @@ pub fn init(opts: Options) Error!Self {
var buf_reqs: vk.VkMemoryRequirements = undefined;
dev.dispatch.getBufferMemoryRequirements(dev.device, dmabuf_buffer, &buf_reqs);
// Must be HOST_VISIBLE | HOST_COHERENT so the dmabuf fd is
// mmap-able from userspace. NVIDIA's dmabuf-exportable memory
// includes a host-visible type alongside the device-local ones;
// we explicitly request both flags so we don't accidentally pick
// a VRAM-only type whose mmap returns garbage.
const host_flags = @as(vk.VkMemoryPropertyFlags, vk.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) |
// Prefer HOST_CACHED so reads from the mmap'd dmabuf are fast.
// Without it (HOST_VISIBLE | HOST_COHERENT only), NVIDIA gives
// back write-combining memory: GPU writes are fast but HOST reads
// crawl (~10 MB/s) because the mapping is uncached. The Qt
// `presentVulkanDmabuf` `QImage::copy()` reads every pixel, so a
// small ~3 MB frame took ~260 ms there. HOST_COHERENT is still
// requested so we don't need explicit flushes between GPU writes
// and host reads; HOST_CACHED on top makes the host reads
// cacheable.
const host_flags_cached =
@as(vk.VkMemoryPropertyFlags, vk.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) |
vk.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
vk.VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
const host_flags_uncached =
@as(vk.VkMemoryPropertyFlags, vk.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) |
vk.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
const dmabuf_mem_idx = dev.findMemoryType(buf_reqs.memoryTypeBits, host_flags) orelse {
log.err(
"no HOST_VISIBLE | HOST_COHERENT memory type for dmabuf (typeBits=0x{x})",
.{buf_reqs.memoryTypeBits},
);
return error.NoSuitableMemoryType;
};
const dmabuf_mem_idx = dev.findMemoryType(buf_reqs.memoryTypeBits, host_flags_cached) orelse
dev.findMemoryType(buf_reqs.memoryTypeBits, host_flags_uncached) orelse
{
log.err(
"no HOST_VISIBLE memory type for dmabuf (typeBits=0x{x})",
.{buf_reqs.memoryTypeBits},
);
return error.NoSuitableMemoryType;
};
const export_info: vk.VkExportMemoryAllocateInfo = .{
.sType = vk.VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
.pNext = null,