path: root/35445.patch

From e18e166fd3837db8c3b5469864adbcb98040d627 Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Sat, 31 May 2025 09:54:41 +0200
Subject: [PATCH 1/6] radv: Add and use RADV_OFFSET_UNUSED

This deduplicates the logic to figure out what needs to be written.
---
 src/amd/vulkan/radv_acceleration_structure.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/amd/vulkan/radv_acceleration_structure.c b/src/amd/vulkan/radv_acceleration_structure.c
index 4a76a4a15e2f4..d4e5daf3f2cf4 100644
--- a/src/amd/vulkan/radv_acceleration_structure.c
+++ b/src/amd/vulkan/radv_acceleration_structure.c
@@ -48,6 +48,8 @@ static const uint32_t leaf_spv[] = {
 #include "bvh/radv_leaf.spv.h"
 };
 
+#define RADV_OFFSET_UNUSED 0xffffffff
+
 struct acceleration_structure_layout {
    uint32_t geometry_info_offset;
    uint32_t primitive_base_indices_offset;
@@ -124,11 +126,15 @@ radv_get_acceleration_structure_layout(struct radv_device *device,
    if (device->rra_trace.accel_structs) {
       accel_struct->geometry_info_offset = offset;
       offset += sizeof(struct radv_accel_struct_geometry_info) * state->build_info->geometryCount;
+   } else {
+      accel_struct->geometry_info_offset = RADV_OFFSET_UNUSED;
    }
 
    if (device->vk.enabled_features.rayTracingPositionFetch && geometry_type == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
       accel_struct->primitive_base_indices_offset = offset;
       offset += sizeof(uint32_t) * state->build_info->geometryCount;
+   } else {
+      accel_struct->primitive_base_indices_offset = RADV_OFFSET_UNUSED;
    }
 
    /* On GFX12, we need additional space for leaf node offsets since they do not have the same
@@ -670,7 +676,7 @@ radv_init_header(VkCommandBuffer commandBuffer, const struct vk_acceleration_str
    radv_update_memory_cp(cmd_buffer, vk_acceleration_structure_get_va(dst) + base, (const char *)&header + base,
                          sizeof(header) - base);
 
-   if (device->rra_trace.accel_structs) {
+   if (layout.geometry_info_offset != RADV_OFFSET_UNUSED) {
       uint64_t geometry_infos_size = state->build_info->geometryCount * sizeof(struct radv_accel_struct_geometry_info);
 
       struct radv_accel_struct_geometry_info *geometry_infos = malloc(geometry_infos_size);
@@ -691,8 +697,7 @@ radv_init_header(VkCommandBuffer commandBuffer, const struct vk_acceleration_str
       free(geometry_infos);
    }
 
-   VkGeometryTypeKHR geometry_type = vk_get_as_geometry_type(state->build_info);
-   if (device->vk.enabled_features.rayTracingPositionFetch && geometry_type == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+   if (layout.primitive_base_indices_offset != RADV_OFFSET_UNUSED) {
       uint32_t base_indices_size = sizeof(uint32_t) * state->build_info->geometryCount;
       uint32_t *base_indices = malloc(base_indices_size);
       if (!base_indices) {
-- 
GitLab


From 34ce6899bee3c70dbae3f136db7ba0ab732d1c4b Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Sat, 31 May 2025 10:26:58 +0200
Subject: [PATCH 2/6] radv: Only write leaf node offsets when required

They are only used for serialization and position fetch which makes them
unnecessary most of the times.
---
 src/amd/vulkan/bvh/build_interface.h         |  9 ++++---
 src/amd/vulkan/bvh/encode_gfx12.comp         | 12 +++++----
 src/amd/vulkan/radv_acceleration_structure.c | 27 +++++++++++++++++---
 3 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/src/amd/vulkan/bvh/build_interface.h b/src/amd/vulkan/bvh/build_interface.h
index 77149b1cd15a1..d5993b308a0a4 100644
--- a/src/amd/vulkan/bvh/build_interface.h
+++ b/src/amd/vulkan/bvh/build_interface.h
@@ -18,10 +18,11 @@
 #define VOID_REF  uint64_t
 #endif
 
-#define RADV_BUILD_FLAG_COMPACT         (1u << (VK_BUILD_FLAG_COUNT + 0))
-#define RADV_BUILD_FLAG_BVH8            (1u << (VK_BUILD_FLAG_COUNT + 1))
-#define RADV_BUILD_FLAG_UPDATE_IN_PLACE (1u << (VK_BUILD_FLAG_COUNT + 2))
-#define RADV_BUILD_FLAG_NO_INFS         (1u << (VK_BUILD_FLAG_COUNT + 3))
+#define RADV_BUILD_FLAG_COMPACT                 (1u << (VK_BUILD_FLAG_COUNT + 0))
+#define RADV_BUILD_FLAG_BVH8                    (1u << (VK_BUILD_FLAG_COUNT + 1))
+#define RADV_BUILD_FLAG_UPDATE_IN_PLACE         (1u << (VK_BUILD_FLAG_COUNT + 2))
+#define RADV_BUILD_FLAG_NO_INFS                 (1u << (VK_BUILD_FLAG_COUNT + 3))
+#define RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS (1u << (VK_BUILD_FLAG_COUNT + 4))
 
 #define RADV_COPY_MODE_COPY        0
 #define RADV_COPY_MODE_SERIALIZE   1
diff --git a/src/amd/vulkan/bvh/encode_gfx12.comp b/src/amd/vulkan/bvh/encode_gfx12.comp
index 805b662e6fd18..eaf7ff081387f 100644
--- a/src/amd/vulkan/bvh/encode_gfx12.comp
+++ b/src/amd/vulkan/bvh/encode_gfx12.comp
@@ -193,11 +193,13 @@ encode_gfx12(uint32_t ir_leaf_node_size, REF(vk_ir_box_node) intermediate_intern
          if (type == vk_ir_node_internal) {
             encoded_type = 5;
          } else {
-            /* Write leaf node offset. */
-            uint32_t leaf_index = offset / ir_leaf_node_size;
-            REF(uint32_t) child_dst_offset = REF(uint32_t)(args.output_base + args.leaf_node_offsets_offset);
-            child_dst_offset = INDEX(uint32_t, child_dst_offset, leaf_index);
-            DEREF(child_dst_offset) = dst_offset;
+            if (VK_BUILD_FLAG(RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS)) {
+               /* Write leaf node offset. */
+               uint32_t leaf_index = offset / ir_leaf_node_size;
+               REF(uint32_t) child_dst_offset = REF(uint32_t)(args.output_base + args.leaf_node_offsets_offset);
+               child_dst_offset = INDEX(uint32_t, child_dst_offset, leaf_index);
+               DEREF(child_dst_offset) = dst_offset;
+            }
 
             VOID_REF dst_leaf_addr = args.output_base + args.output_bvh_offset + dst_offset;
 
diff --git a/src/amd/vulkan/radv_acceleration_structure.c b/src/amd/vulkan/radv_acceleration_structure.c
index d4e5daf3f2cf4..8a0204bb33c59 100644
--- a/src/amd/vulkan/radv_acceleration_structure.c
+++ b/src/amd/vulkan/radv_acceleration_structure.c
@@ -68,7 +68,8 @@ struct update_scratch_layout {
 };
 
 enum radv_encode_key_bits {
-   RADV_ENCODE_KEY_COMPACT = 1,
+   RADV_ENCODE_KEY_COMPACT = (1 << 0),
+   RADV_ENCODE_KEY_WRITE_LEAF_NODE_OFFSETS = (1 << 1),
 };
 
 static void
@@ -409,9 +410,23 @@ radv_get_build_config(VkDevice _device, struct vk_acceleration_structure_build_s
    struct radv_physical_device *pdev = radv_device_physical(device);
 
    uint32_t encode_key = 0;
-   if (radv_use_bvh8(pdev))
+   if (radv_use_bvh8(pdev)) {
       encode_key |= RADV_ENCODE_KEY_COMPACT;
 
+      /*
+       * Leaf nodes are not written in the order provided by the application when BVH8 encoding is used.
+       * The proper order leaf nodes is used...
+       *    1. When fetching vertex positions for triangles.
+       *    2. When applying/writing BLAS pointers during TLAS deserialization/serialization. The type
+       *       compared to VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR to handle the
+       *       VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR case when the application queries the
+       *       acceleration structure size.
+       */
+      if ((state->build_info->flags & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR) ||
+          state->build_info->type != VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR)
+         encode_key |= RADV_ENCODE_KEY_WRITE_LEAF_NODE_OFFSETS;
+   }
+
    if (state->build_info->flags & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR)
       encode_key |= RADV_ENCODE_KEY_COMPACT;
 
@@ -482,6 +497,8 @@ radv_build_flags(VkCommandBuffer commandBuffer, uint32_t key)
    /* gfx11 box intersection tests can return garbage with infs and non-standard box sorting */
    if (pdev->info.gfx_level == GFX11)
       flags |= RADV_BUILD_FLAG_NO_INFS;
+   if (key & RADV_ENCODE_KEY_WRITE_LEAF_NODE_OFFSETS)
+      flags |= RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS;
 
    return flags;
 }
@@ -500,8 +517,10 @@ static VkResult
 radv_encode_bind_pipeline_gfx12(VkCommandBuffer commandBuffer,
                                 const struct vk_acceleration_structure_build_state *state)
 {
-   radv_bvh_build_bind_pipeline(commandBuffer, RADV_META_OBJECT_KEY_BVH_ENCODE, encode_gfx12_spv,
-                                sizeof(encode_gfx12_spv), sizeof(struct encode_gfx12_args), 0);
+   radv_bvh_build_bind_pipeline(
+      commandBuffer, RADV_META_OBJECT_KEY_BVH_ENCODE, encode_gfx12_spv, sizeof(encode_gfx12_spv),
+      sizeof(struct encode_gfx12_args),
+      radv_build_flags(commandBuffer, state->config->encode_key[0]) & RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS);
 
    return VK_SUCCESS;
 }
-- 
GitLab


From 83da0a824d651b9f8065f0155e7711ef6ae1b3f3 Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Thu, 5 Jun 2025 08:30:36 +0200
Subject: [PATCH 3/6] radv/bvh: Fix flush in bit_writer_skip_to

If temp is not cleared, the next flushed dword will contain data from
the previous one.
---
 src/amd/vulkan/bvh/encode.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/amd/vulkan/bvh/encode.h b/src/amd/vulkan/bvh/encode.h
index 25abeb2ac8d91..80e2f669eac44 100644
--- a/src/amd/vulkan/bvh/encode.h
+++ b/src/amd/vulkan/bvh/encode.h
@@ -103,6 +103,7 @@ bit_writer_skip_to(inout bit_writer writer, uint32_t target)
    if (writer.count > 0) {
       REF(uint32_t) dst = REF(uint32_t)(writer.addr + writer.offset);
       DEREF(dst) = writer.temp;
+      writer.temp = 0;
    }
 
    writer.count = target % 32;
-- 
GitLab


From 43d3fc6e27cc58b35cb151a87ba16c2f673dbd4b Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Thu, 5 Jun 2025 08:32:36 +0200
Subject: [PATCH 4/6] radv/bvh: Use a fixed indices midpoint on GFX12

This saves a vouple of loads inside the update shader.
---
 src/amd/vulkan/bvh/encode.h          | 12 ++++++++----
 src/amd/vulkan/bvh/update_gfx12.comp | 19 ++++---------------
 2 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/src/amd/vulkan/bvh/encode.h b/src/amd/vulkan/bvh/encode.h
index 80e2f669eac44..625525ae07a52 100644
--- a/src/amd/vulkan/bvh/encode.h
+++ b/src/amd/vulkan/bvh/encode.h
@@ -125,6 +125,8 @@ bit_writer_finish(inout bit_writer writer)
    writer.total_count = 0;
 }
 
+#define RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET (align(RADV_GFX12_PRIMITIVE_NODE_HEADER_SIZE, 32) / 8 + 9 * 4)
+
 void
 radv_encode_triangle_gfx12(VOID_REF dst, vk_ir_triangle_node src)
 {
@@ -141,8 +143,7 @@ radv_encode_triangle_gfx12(VOID_REF dst, vk_ir_triangle_node src)
    bit_writer_write(child_writer, 0, 1);  /* vertex_type */
    bit_writer_write(child_writer, 28, 5); /* primitive_index_base_bits */
    bit_writer_write(child_writer, 28, 5); /* primitive_index_bits */
-   /* header + 9 floats + geometry_id */
-   bit_writer_write(child_writer, RADV_GFX12_PRIMITIVE_NODE_HEADER_SIZE + 9 * 32 + 28, 10);
+   bit_writer_write(child_writer, RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET * 8 + 32, 10);
 
    bit_writer_write(child_writer, floatBitsToUint(src.coords[0][0]), 32);
    bit_writer_write(child_writer, floatBitsToUint(src.coords[0][1]), 32);
@@ -154,6 +155,8 @@ radv_encode_triangle_gfx12(VOID_REF dst, vk_ir_triangle_node src)
    bit_writer_write(child_writer, floatBitsToUint(src.coords[2][1]), 32);
    bit_writer_write(child_writer, floatBitsToUint(src.coords[2][2]), 32);
 
+   bit_writer_write(child_writer, 0, 64 - RADV_GFX12_PRIMITIVE_NODE_HEADER_SIZE + 4);
+
    bit_writer_write(child_writer, src.geometry_id_and_flags & 0xfffffff, 28);
    bit_writer_write(child_writer, src.triangle_id, 28);
 
@@ -192,8 +195,7 @@ radv_encode_aabb_gfx12(VOID_REF dst, vk_ir_aabb_node src)
    bit_writer_write(child_writer, 0, 1);  /* vertex_type */
    bit_writer_write(child_writer, 28, 5); /* primitive_index_base_bits */
    bit_writer_write(child_writer, 28, 5); /* primitive_index_bits */
-   /* header + 6 floats + geometry_id */
-   bit_writer_write(child_writer, RADV_GFX12_PRIMITIVE_NODE_HEADER_SIZE + 6 * 32 + 28, 10);
+   bit_writer_write(child_writer, RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET * 8 + 32, 10);
 
    bit_writer_write(child_writer, floatBitsToUint(src.base.aabb.min.x), 32);
    bit_writer_write(child_writer, floatBitsToUint(src.base.aabb.min.y), 32);
@@ -202,6 +204,8 @@ radv_encode_aabb_gfx12(VOID_REF dst, vk_ir_aabb_node src)
    bit_writer_write(child_writer, floatBitsToUint(src.base.aabb.max.y), 32);
    bit_writer_write(child_writer, floatBitsToUint(src.base.aabb.max.z), 32);
 
+   bit_writer_skip_to(child_writer, RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET * 8 + 4);
+
    bit_writer_write(child_writer, src.geometry_id_and_flags & 0xfffffff, 28);
    bit_writer_write(child_writer, src.primitive_id, 28);
 
diff --git a/src/amd/vulkan/bvh/update_gfx12.comp b/src/amd/vulkan/bvh/update_gfx12.comp
index 8cbc930ab4352..32da58fca6890 100644
--- a/src/amd/vulkan/bvh/update_gfx12.comp
+++ b/src/amd/vulkan/bvh/update_gfx12.comp
@@ -33,18 +33,6 @@ layout(push_constant) uniform CONSTS
    update_gfx12_args args;
 };
 
-uint32_t
-read_bits(VOID_REF data, uint32_t start, uint32_t count)
-{
-   uint32_t shift = start % 32;
-   uint32_t lower = DEREF(INDEX(uint32_t, data, start / 32)) >> shift;
-   uint32_t upper = 0;
-   if (shift != 0 && shift + count > 32)
-      upper = DEREF(INDEX(uint32_t, data, start / 32 + 1)) << (32 - shift);
-   uint32_t total = lower | upper;
-   return count != 32 ? total & ((1u << count) - 1u) : total;
-}
-
 void
 main()
 {
@@ -109,9 +97,10 @@ main()
 
       if (is_leaf) {
          VOID_REF src_leaf_node = OFFSET(src_bvh, child_offset);
-         uint32_t indices_midpoint = read_bits(src_leaf_node, 42, 10);
-         uint32_t geometry_index = read_bits(src_leaf_node, indices_midpoint - 28, 28);
-         uint32_t primitive_index = read_bits(src_leaf_node, indices_midpoint, 28);
+         uint32_t geometry_index =
+            DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET)) >> 4;
+         uint32_t primitive_index =
+            DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET + 4)) & 0xfffffff;
 
          vk_bvh_geometry_data geom_data = DEREF(INDEX(vk_bvh_geometry_data, args.geom_data, geometry_index));
 
-- 
GitLab


From deb3659d4cc00c7619112272644d186a8425c2a7 Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Fri, 6 Jun 2025 08:31:38 +0200
Subject: [PATCH 5/6] radv/bvh: Update leaf nodes before refitting

This should reduce latency between refitting nodes and their parent
nodes.
---
 src/amd/vulkan/bvh/update_gfx12.comp | 70 +++++++++++++++-------------
 1 file changed, 38 insertions(+), 32 deletions(-)

diff --git a/src/amd/vulkan/bvh/update_gfx12.comp b/src/amd/vulkan/bvh/update_gfx12.comp
index 32da58fca6890..4c2890b65dcc9 100644
--- a/src/amd/vulkan/bvh/update_gfx12.comp
+++ b/src/amd/vulkan/bvh/update_gfx12.comp
@@ -81,6 +81,27 @@ main()
       child_offset += SIZEOF(radv_gfx12_box_node) * child_index;
    }
 
+   vk_aabb bounds;
+   bounds.min = vec3(INFINITY);
+   bounds.max = vec3(-INFINITY);
+   if (is_leaf) {
+      VOID_REF src_leaf_node = OFFSET(src_bvh, child_offset);
+      uint32_t geometry_index =
+         DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET)) >> 4;
+      uint32_t primitive_index =
+         DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET + 4)) & 0xfffffff;
+
+      vk_bvh_geometry_data geom_data = DEREF(INDEX(vk_bvh_geometry_data, args.geom_data, geometry_index));
+
+      VOID_REF dst_leaf_node = OFFSET(dst_bvh, child_offset);
+      if (geom_data.geometry_type == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+         radv_build_triangle(bounds, dst_leaf_node, geom_data, primitive_index, true);
+      } else {
+         VOID_REF src_ptr = OFFSET(geom_data.data, primitive_index * geom_data.stride);
+         radv_build_aabb(bounds, src_ptr, dst_leaf_node, geometry_index, primitive_index, true);
+      }
+   }
+
    uint32_t child_index = (child_offset - internal_nodes_offset) / SIZEOF(radv_gfx12_box_node);
 
    bool is_ready = is_leaf_or_invalid;
@@ -91,27 +112,7 @@ main()
       if (radv_ballot(cluster, is_ready) != 0xff)
          continue;
 
-      vk_aabb bounds;
-      bounds.min = vec3(INFINITY);
-      bounds.max = vec3(-INFINITY);
-
-      if (is_leaf) {
-         VOID_REF src_leaf_node = OFFSET(src_bvh, child_offset);
-         uint32_t geometry_index =
-            DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET)) >> 4;
-         uint32_t primitive_index =
-            DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET + 4)) & 0xfffffff;
-
-         vk_bvh_geometry_data geom_data = DEREF(INDEX(vk_bvh_geometry_data, args.geom_data, geometry_index));
-
-         VOID_REF dst_leaf_node = OFFSET(dst_bvh, child_offset);
-         if (geom_data.geometry_type == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
-            radv_build_triangle(bounds, dst_leaf_node, geom_data, primitive_index, true);
-         } else {
-            VOID_REF src_ptr = OFFSET(geom_data.data, primitive_index * geom_data.stride);
-            radv_build_aabb(bounds, src_ptr, dst_leaf_node, geometry_index, primitive_index, true);
-         }
-      } else if (is_valid) {
+      if (!is_leaf_or_invalid) {
          bounds = DEREF(INDEX(vk_aabb, args.bounds, child_index));
       }
 
@@ -123,13 +124,20 @@ main()
       total_bounds.max.y = subgroupClusteredMax(bounds.max.y, 8);
       total_bounds.max.z = subgroupClusteredMax(bounds.max.z, 8);
 
-      if (!is_root_node) {
-         DEREF(INDEX(vk_aabb, args.bounds, node_index - 1)) = total_bounds;
+      if (cluster.invocation_index == 0) {
+         if (is_root_node) {
+            DEREF(args.dst).aabb = total_bounds;
+         } else {
+            DEREF(INDEX(vk_aabb, args.bounds, node_index - 1)) = total_bounds;
+
+            memoryBarrier(gl_ScopeDevice, gl_StorageSemanticsBuffer,
+                          gl_SemanticsAcquireRelease | gl_SemanticsMakeAvailable | gl_SemanticsMakeVisible);
 
-         memoryBarrier(gl_ScopeDevice, gl_StorageSemanticsBuffer,
-                       gl_SemanticsAcquireRelease | gl_SemanticsMakeAvailable | gl_SemanticsMakeVisible);
+            DEREF(INDEX(uint32_t, args.internal_ready_count, node_index - 1)) = 1;
 
-         DEREF(INDEX(uint32_t, args.internal_ready_count, node_index - 1)) = 1;
+            memoryBarrier(gl_ScopeDevice, gl_StorageSemanticsBuffer,
+                          gl_SemanticsAcquireRelease | gl_SemanticsMakeAvailable | gl_SemanticsMakeVisible);
+         }
       }
 
       vec3 origin = total_bounds.min;
@@ -139,6 +147,10 @@ main()
       uvec3 extent_exponents = floatBitsToUint(extent) >> 23;
 
       if (cluster.invocation_index == 0) {
+         if (!VK_BUILD_FLAG(RADV_BUILD_FLAG_UPDATE_IN_PLACE)) {
+            DEREF(dst_node).primitive_base_id = src_node.primitive_base_id;
+            DEREF(dst_node).internal_base_id = src_node.internal_base_id;
+         }
          DEREF(dst_node).origin = origin;
          DEREF(dst_node).child_count_exponents = extent_exponents.x | (extent_exponents.y << 8) |
                                                  (extent_exponents.z << 16) | (valid_child_count_minus_one << 28);
@@ -170,12 +182,6 @@ main()
          DEREF(dst_node).children[cluster.invocation_index] = null_child;
       }
 
-      if (is_root_node)
-         DEREF(args.dst).aabb = total_bounds;
-
-      /* Make changes to internal_ready_count available to the other invocations. */
-      memoryBarrier(gl_ScopeDevice, gl_StorageSemanticsBuffer,
-                    gl_SemanticsAcquireRelease | gl_SemanticsMakeAvailable | gl_SemanticsMakeVisible);
       break;
    }
 }
-- 
GitLab


From eff84560b7bbeed913d8e24329ae03193e186888 Mon Sep 17 00:00:00 2001
From: Konstantin Seurer <konstantin.seurer@gmail.com>
Date: Tue, 10 Jun 2025 14:05:22 +0200
Subject: [PATCH 6/6] radv/bvh: Specialize the update shader for
 geometryCount==1

The geometry data can be loaded from push constants in that case.
---
 src/amd/vulkan/bvh/build_interface.h         |  3 +++
 src/amd/vulkan/bvh/update_gfx12.comp         | 13 ++++++++++---
 src/amd/vulkan/radv_acceleration_structure.c | 17 +++++++++++++----
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/amd/vulkan/bvh/build_interface.h b/src/amd/vulkan/bvh/build_interface.h
index d5993b308a0a4..a49476d720392 100644
--- a/src/amd/vulkan/bvh/build_interface.h
+++ b/src/amd/vulkan/bvh/build_interface.h
@@ -23,6 +23,7 @@
 #define RADV_BUILD_FLAG_UPDATE_IN_PLACE         (1u << (VK_BUILD_FLAG_COUNT + 2))
 #define RADV_BUILD_FLAG_NO_INFS                 (1u << (VK_BUILD_FLAG_COUNT + 3))
 #define RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS (1u << (VK_BUILD_FLAG_COUNT + 4))
+#define RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY  (1u << (VK_BUILD_FLAG_COUNT + 5))
 
 #define RADV_COPY_MODE_COPY        0
 #define RADV_COPY_MODE_SERIALIZE   1
@@ -78,6 +79,8 @@ struct update_gfx12_args {
    REF(vk_aabb) bounds;
    REF(uint32_t) internal_ready_count;
    uint32_t leaf_node_count;
+
+   vk_bvh_geometry_data geom_data0;
 };
 
 #endif /* BUILD_INTERFACE_H */
diff --git a/src/amd/vulkan/bvh/update_gfx12.comp b/src/amd/vulkan/bvh/update_gfx12.comp
index 4c2890b65dcc9..72f8358f115b1 100644
--- a/src/amd/vulkan/bvh/update_gfx12.comp
+++ b/src/amd/vulkan/bvh/update_gfx12.comp
@@ -86,12 +86,19 @@ main()
    bounds.max = vec3(-INFINITY);
    if (is_leaf) {
       VOID_REF src_leaf_node = OFFSET(src_bvh, child_offset);
-      uint32_t geometry_index =
-         DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET)) >> 4;
+
+      uint32_t geometry_index = 0;
+      if (!VK_BUILD_FLAG(RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY))
+         geometry_index = DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET)) >> 4;
+
       uint32_t primitive_index =
          DEREF(REF(uint32_t)(src_leaf_node + RADV_GFX12_UPDATABLE_PRIMITIVE_NODE_INDICES_OFFSET + 4)) & 0xfffffff;
 
-      vk_bvh_geometry_data geom_data = DEREF(INDEX(vk_bvh_geometry_data, args.geom_data, geometry_index));
+      vk_bvh_geometry_data geom_data;
+      if (VK_BUILD_FLAG(RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY))
+         geom_data = args.geom_data0;
+      else
+         geom_data = DEREF(INDEX(vk_bvh_geometry_data, args.geom_data, geometry_index));
 
       VOID_REF dst_leaf_node = OFFSET(dst_bvh, child_offset);
       if (geom_data.geometry_type == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
diff --git a/src/amd/vulkan/radv_acceleration_structure.c b/src/amd/vulkan/radv_acceleration_structure.c
index 8a0204bb33c59..5309d6388c533 100644
--- a/src/amd/vulkan/radv_acceleration_structure.c
+++ b/src/amd/vulkan/radv_acceleration_structure.c
@@ -437,6 +437,9 @@ radv_get_build_config(VkDevice _device, struct vk_acceleration_structure_build_s
    if (state->build_info->srcAccelerationStructure == state->build_info->dstAccelerationStructure)
       update_key |= RADV_BUILD_FLAG_UPDATE_IN_PLACE;
 
+   if (state->build_info->geometryCount == 1)
+      update_key |= RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY;
+
    state->config.update_key[0] = update_key;
 }
 
@@ -520,7 +523,7 @@ radv_encode_bind_pipeline_gfx12(VkCommandBuffer commandBuffer,
    radv_bvh_build_bind_pipeline(
       commandBuffer, RADV_META_OBJECT_KEY_BVH_ENCODE, encode_gfx12_spv, sizeof(encode_gfx12_spv),
       sizeof(struct encode_gfx12_args),
-      radv_build_flags(commandBuffer, state->config->encode_key[0]) & RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS);
+      radv_build_flags(commandBuffer, state->config.encode_key[0]) & RADV_BUILD_FLAG_WRITE_LEAF_NODE_OFFSETS);
 
    return VK_SUCCESS;
 }
@@ -753,7 +756,8 @@ radv_init_update_scratch(VkCommandBuffer commandBuffer, const struct vk_accelera
    radv_fill_memory(cmd_buffer, scratch + layout.internal_ready_count_offset,
                     layout.size - layout.internal_ready_count_offset, 0x0, RADV_COPY_FLAGS_DEVICE_LOCAL);
 
-   if (radv_use_bvh8(pdev)) {
+   /* geometryCount == 1 passes the data as push constant. */
+   if (radv_use_bvh8(pdev) && !(state->config.update_key[0] & RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY)) {
       uint32_t data_size = sizeof(struct vk_bvh_geometry_data) * state->build_info->geometryCount;
       struct vk_bvh_geometry_data *data = malloc(data_size);
       if (!data) {
@@ -797,8 +801,7 @@ radv_update_bind_pipeline(VkCommandBuffer commandBuffer, const struct vk_acceler
    if (radv_device_physical(device)->info.cp_sdma_ge_use_system_memory_scope)
       cmd_buffer->state.flush_bits |= RADV_CMD_FLAG_INV_L2;
 
-   bool in_place = state->config.update_key[0] & RADV_BUILD_FLAG_UPDATE_IN_PLACE;
-   uint32_t flags = in_place ? RADV_BUILD_FLAG_UPDATE_IN_PLACE : 0;
+   uint32_t flags = state->config.update_key[0];
 
    if (radv_use_bvh8(pdev)) {
       radv_bvh_build_bind_pipeline(commandBuffer, RADV_META_OBJECT_KEY_BVH_UPDATE, update_gfx12_spv,
@@ -899,6 +902,12 @@ radv_update_as_gfx12(VkCommandBuffer commandBuffer, const struct vk_acceleration
       .leaf_node_count = state->leaf_node_count,
    };
 
+   if (state->config.update_key[0] & RADV_BUILD_FLAG_UPDATE_SINGLE_GEOMETRY) {
+      const VkAccelerationStructureGeometryKHR *geom =
+         state->build_info->pGeometries ? &state->build_info->pGeometries[0] : state->build_info->ppGeometries[0];
+      update_consts.geom_data0 = vk_fill_geometry_data(state->build_info->type, 0, 0, geom, state->build_range_infos);
+   }
+
    radv_bvh_build_set_args(commandBuffer, &update_consts, sizeof(update_consts));
 
    struct radv_dispatch_info dispatch = {
-- 
GitLab