From c9c06f25015aa940317a4183685f1b6c46ee50a0 Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Tue, 27 Oct 2026 15:53:59 +0300 Subject: [PATCH] Render target views of registered textures live as long as their image vk_exec_pass_begin created every attachment view again in each submission and freed them at its fence: 2% of the fight replay on the 7900X, more on drivers with a slower vkCreateImageView. view_of now takes the view from vk_exec_target_view, which keeps it in the sampled-view tables under the texture lock, and vk_exec_image_gone releases it with the image. Images that are not registered textures keep the per-submission views. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_exec.c | 4 ++++ runtime/vk_exec.h | 2 ++ runtime/vk_exec_draw.c | 28 ++++++++++++++++++++++++++++ 3 files changed, 34 insertions(+) diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index 90883676..cdea8a1a 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -264,7 +264,11 @@ static void resolve_rt(VkExec *ex) { ex->pipe.samples = (uint8_t)ex->pass_samples; } +// The attachment view of a target. A registered texture's view lives as long as its image (vk_exec_target_view); any +// other image's view is made for this command buffer and freed at its fence. static VkImageView view_of(VkExec *ex, const VkExecTarget *t) { + if (t->img && t->img->image == t->image) + return vk_exec_target_view(t->img, t->format, t->view_type, t->aspect, t->level, t->base_layer, t->layers, t->blocks); ViewEnt *v = ex->views; for (int i = 0; i < ex->nviews; i++) if (v[i].image == t->image && v[i].format == t->format && v[i].type == t->view_type && v[i].aspect == t->aspect && diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index 28426318..48cbea79 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -166,6 +166,8 @@ void vk_c0_fill(uint8_t bank[VK_C0_BYTES], int stage, const p_bind_buf ssbo[16], void vk_exec_op_draw(VkExec *ex, uint32_t op, const void *payload); // The aspect a sampled view of img reads (vk_exec_draw.c get_view): stencil for a view in STENCIL depth-stencil mode. VkImageAspectFlags vk_exec_view_aspect(const VkTexImage *img, const view_t *v, int hv); +VkImageView vk_exec_target_view(const VkTexImage *img, VkFormat format, VkImageViewType type, uint32_t aspect, + uint32_t level, uint32_t base, uint32_t layers, int blocks); // kept for the image's life // T6c3: OP_COPY_B2B, OP_COPY_B2T, OP_COPY_T2B, OP_COPY_T2T, OP_CLEAR_TEX, OP_SIGNAL_EVENT, OP_REPORT_COUNTER, // OP_RESET_COUNTER, OP_RENDER_ENABLE, OP_RENDER_COND, OP_CLEAR_BUF. void vk_exec_op_xfer(VkExec *ex, uint32_t op, const void *payload); diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 87cc1d14..e5570efa 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -530,6 +530,34 @@ static VkImageView get_view(VkExec *ex, const VkTexImage *img, const view_t *v, return view; } +// An attachment view of a registered texture, kept with its sampled views for the image's lifetime: made per command +// buffer, every render target's views were created again each frame (vkCreateImageView under vk_exec_pass_begin, 2% +// of the fight replay on the 7900X). Attachment keys carry a swizzle word no sampled key has (those hold four NVN +// selectors, each below 8). The texture lock guards the tables, as for get_view; vk_exec_pass_begin may already hold it. +VkImageView vk_exec_target_view(const VkTexImage *img, VkFormat format, VkImageViewType type, uint32_t aspect, + uint32_t level, uint32_t base, uint32_t layers, int blocks) { + ViewKey k = {img->image, format, type, aspect, level, 1, base, layers, blocks ? 0xfffffffeu : 0xffffffffu}; + vk_texture_lock(); + if (!view_of.klen) nvn_hm_init(&view_of, sizeof(ViewKey)), nvn_hm_init(&views_by_image, sizeof(VkImage)); + VkImageView view = (VkImageView)nvn_hm_get(&view_of, &k); + if (!view) { + VkImageViewCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = img->image, + .viewType = type, .format = format, .subresourceRange = {aspect, level, 1, base, layers}}; + VkImageViewUsageCreateInfo use = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT}; + if (blocks) ci.pNext = &use; // not the BC image's sampling and transfer usages + if (vkCreateImageView(vk_ctx()->device, &ci, NULL, &view) != VK_SUCCESS) + rt_fatal("vk: render target view (format %d) could not be created", (int)format); + ViewNode *n = malloc(sizeof *n); + if (!n) rt_fatal("vk: out of memory"); + *n = (ViewNode){nvn_hm_get(&views_by_image, &img->image), k, view}; + nvn_hm_put(&views_by_image, &img->image, n); + nvn_hm_put(&view_of, &k, (void *)view); + } + vk_texture_unlock(); + return view; +} + void vk_exec_image_gone(VkImage image) { if (!views_by_image.klen) return; for (ViewNode *n = nvn_hm_del(&views_by_image, &image), *next; n; n = next) {