tests: Test heap buffer usage

ziga-lunarg · ziga-lunarg · commit 64127f57b80f · 2026-03-24T14:59:39.000+02:00
diff --git a/layers/gpuav/instrumentation/post_process_descriptor_heap.cpp b/layers/gpuav/instrumentation/post_process_descriptor_heap.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2025 LunarG, Inc.
+/* Copyright (c) 2025-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -69,8 +69,6 @@ void RegisterPostProcessingDescriptorHeap(Validator& gpuav, CommandBufferSubStat
             pp_cb_state.post_process_variables =
                 cb.gpu_resources_manager.GetHostCoherentBufferRange(sizeof(Slot) * kDebugMaxDescSetAndBindings);
 
-            out_update.buffer = pp_cb_state.post_process_variables.buffer;
-            out_update.offset = pp_cb_state.post_process_variables.offset;
             out_update.range = pp_cb_state.post_process_variables.size;
             out_update.address = pp_cb_state.post_process_variables.offset_address;
             out_update.binding = glsl::kBindingInstDescriptorHeapPostProcess;
@@ -123,7 +121,8 @@ void RegisterPostProcessingDescriptorHeap(Validator& gpuav, CommandBufferSubStat
                     ASSERT_AND_CONTINUE(shader_object_state->stage.entrypoint);
                     mappings = vku::FindStructInPNextChain<VkShaderDescriptorSetAndBindingMappingInfoEXT>(
                         shader_object_state->create_info.pNext);
-                    auto variable_it = shader_object_state->stage.entrypoint->resource_interface_variable_map.find(slot.variable_id);
+                    auto variable_it =
+                        shader_object_state->stage.entrypoint->resource_interface_variable_map.find(slot.variable_id);
                     if (variable_it != shader_object_state->stage.entrypoint->resource_interface_variable_map.end()) {
                         resource_variable = variable_it->second;
                         stage = shader_object_state->create_info.stage;
@@ -293,7 +292,8 @@ void RegisterPostProcessingDescriptorHeap(Validator& gpuav, CommandBufferSubStat
                     ASSERT_AND_CONTINUE(shader_object_state->stage.entrypoint);
                     mappings = vku::FindStructInPNextChain<VkShaderDescriptorSetAndBindingMappingInfoEXT>(
                         shader_object_state->create_info.pNext);
-                    auto variable_it = shader_object_state->stage.entrypoint->resource_interface_variable_map.find(slot.variable_id);
+                    auto variable_it =
+                        shader_object_state->stage.entrypoint->resource_interface_variable_map.find(slot.variable_id);
                     if (variable_it != shader_object_state->stage.entrypoint->resource_interface_variable_map.end()) {
                         resource_variable = variable_it->second;
                     }
diff --git a/layers/gpuav/instrumentation/post_process_descriptor_heap.h b/layers/gpuav/instrumentation/post_process_descriptor_heap.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2025 LunarG, Inc.
+/* Copyright (c) 2025-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/layers/gpuav/spirv/descriptor_heap_pass.cpp b/layers/gpuav/spirv/descriptor_heap_pass.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2024-2025 LunarG, Inc.
+/* Copyright (c) 2024-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53,8 +53,10 @@ void DescriptorHeapPass::CreateFunctionCall(BasicBlock& block, InstructionIt* in
         const uint32_t void_type = module_.type_manager_.GetTypeVoid().Id();
 
         const uint32_t zero = module_.type_manager_.CreateConstantUInt32(0).Id();
-        const uint32_t descriptor_offset_id = meta.access_chain_insts.empty() ? zero : 
-            GetLastByte(*meta.descriptor_type, meta.access_chain_insts, meta.coop_mat_access, block, inst_it);
+        const uint32_t descriptor_offset_id =
+            meta.access_chain_insts.empty()
+                ? zero
+                : GetLastByte(*meta.descriptor_type, meta.access_chain_insts, meta.coop_mat_access, block, inst_it);
 
         const Constant& slot_index = type_manager_.CreateConstantUInt32(slot_index_++);
         if (slot_index_ > glsl::kDebugMaxDescSetAndBindings) {
@@ -70,10 +72,7 @@ void DescriptorHeapPass::CreateFunctionCall(BasicBlock& block, InstructionIt* in
     module_.need_log_error_ = true;
 }
 
-bool DescriptorHeapPass::HeapPointerRequiresInstrumentation(const Function& function, const Instruction& inst,
-                                                            InstructionMeta& meta) {
-    return false;
-}
+bool DescriptorHeapPass::HeapPointerRequiresInstrumentation(const Function&, const Instruction&, InstructionMeta&) { return false; }
 
 bool DescriptorHeapPass::RequiresInstrumentation(const Function& function, const Instruction& inst, InstructionMeta& meta) {
     const uint32_t opcode = inst.Opcode();
@@ -191,4 +190,4 @@ bool DescriptorHeapPass::Instrument() {
 }
 
 }  // namespace spirv
-}  // namespace gpuav
+}  // namespace gpuav
diff --git a/layers/gpuav/spirv/descriptor_heap_pass.h b/layers/gpuav/spirv/descriptor_heap_pass.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2025 LunarG, Inc.
+/* Copyright (c) 2025-2026 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/unit/gpu_av_descriptor_heap.cpp b/tests/unit/gpu_av_descriptor_heap.cpp
@@ -924,4 +924,126 @@ TEST_F(NegativeGpuAVDescriptorHeap, ShaderObjects) {
 
     m_default_queue->SubmitAndWait(m_command_buffer);
     m_errorMonitor->VerifyFound();
-}
+}
+
+TEST_F(NegativeGpuAVDescriptorHeap, PushAddressUniformBufferUsage) {
+    AddRequiredFeature(vkt::Feature::bufferDeviceAddress);
+    AddRequiredFeature(vkt::Feature::vertexPipelineStoresAndAtomics);
+    RETURN_IF_SKIP(InitGpuAVDescriptorHeap());
+    InitRenderTarget();
+
+    vkt::Buffer read_buffer(*m_device, sizeof(uint32_t) * 4, VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR, vkt::device_address);
+    uint32_t* read_data = static_cast<uint32_t*>(read_buffer.Memory().Map());
+    for (uint32_t i = 0; i < 4; ++i) {
+        read_data[i] = i + 1;
+    }
+    vkt::Buffer write_buffer(*m_device, sizeof(uint32_t) * 4, VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR, vkt::device_address);
+
+    const uint32_t read_offset = 48u;
+    const VkDeviceSize write_offset =
+        Align(read_offset + heap_props.bufferDescriptorAlignment * 7u, heap_props.bufferDescriptorAlignment);
+    const VkDeviceSize resource_stride = heap_props.bufferDescriptorSize;
+    const VkDeviceSize descriptor_size = AlignResource(write_offset + resource_stride);
+    const VkDeviceSize heap_size = descriptor_size + heap_props.minResourceHeapReservedRange;
+
+    vkt::Buffer heap(*m_device, heap_size, VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT, vkt::device_address);
+    uint8_t* heap_data = static_cast<uint8_t*>(heap.Memory().Map());
+
+    VkHostAddressRangeEXT descriptor_host;
+    descriptor_host.address = heap_data + write_offset;
+    descriptor_host.size = resource_stride;
+
+    VkDeviceAddressRangeEXT device_range;
+    device_range.address = write_buffer.Address();
+    device_range.size = write_buffer.CreateInfo().size;
+
+    VkResourceDescriptorInfoEXT descriptor_info;
+    descriptor_info = vku::InitStructHelper();
+    descriptor_info.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    descriptor_info.data.pAddressRange = &device_range;
+
+    vk::WriteResourceDescriptorsEXT(*m_device, 1u, &descriptor_info, &descriptor_host);
+
+    VkDescriptorSetAndBindingMappingEXT mappings[2];
+    mappings[0] = vku::InitStructHelper();
+    mappings[0].descriptorSet = 2u;
+    mappings[0].firstBinding = 3u;
+    mappings[0].bindingCount = 1u;
+    mappings[0].resourceMask = VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT;
+    mappings[0].source = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT;
+    mappings[0].sourceData.pushAddressOffset = static_cast<uint32_t>(read_offset);
+    mappings[1] = vku::InitStructHelper();
+    mappings[1].descriptorSet = 1u;
+    mappings[1].firstBinding = 0u;
+    mappings[1].bindingCount = 1u;
+    mappings[1].resourceMask = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT;
+    mappings[1].source = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT;
+    mappings[1].sourceData.constantOffset.heapOffset = static_cast<uint32_t>(write_offset);
+    mappings[1].sourceData.constantOffset.heapArrayStride = 0u;
+
+    VkShaderDescriptorSetAndBindingMappingInfoEXT mapping_info = vku::InitStructHelper();
+    mapping_info.mappingCount = 2u;
+    mapping_info.pMappings = mappings;
+
+    char const* vert_source = R"glsl(
+        #version 450
+        layout(set = 2, binding = 3) uniform ReadData {
+            uvec4 read_data;
+        };
+        layout(set = 1, binding = 0) buffer WriteData {
+            uvec4 write_data;
+        };
+        void main() {
+            if (gl_VertexIndex == 0) {
+                write_data[0] = read_data[3];
+            }
+            gl_Position = vec4(1.0f);
+            gl_PointSize = 1.0f;
+        }
+    )glsl";
+
+    VkShaderObj vert_module = VkShaderObj(*m_device, vert_source, VK_SHADER_STAGE_VERTEX_BIT);
+    VkShaderObj frag_module = VkShaderObj(*m_device, kFragmentMinimalGlsl, VK_SHADER_STAGE_FRAGMENT_BIT);
+
+    VkPipelineCreateFlags2CreateInfoKHR pipeline_create_flags_2_create_info = vku::InitStructHelper();
+    pipeline_create_flags_2_create_info.flags = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT;
+
+    VkPipelineShaderStageCreateInfo stages[2];
+    stages[0] = vert_module.GetStageCreateInfo();
+    stages[0].pNext = &mapping_info;
+    stages[1] = frag_module.GetStageCreateInfo();
+
+    CreatePipelineHelper descriptor_heap_pipe(*this, &pipeline_create_flags_2_create_info);
+    descriptor_heap_pipe.gp_ci_.layout = VK_NULL_HANDLE;
+    descriptor_heap_pipe.gp_ci_.stageCount = 2u;
+    descriptor_heap_pipe.gp_ci_.pStages = stages;
+    descriptor_heap_pipe.CreateGraphicsPipeline(false);
+
+    VkDeviceAddress read_address = read_buffer.Address();
+
+    VkPushDataInfoEXT push_data = vku::InitStructHelper();
+    push_data.offset = read_offset;
+    push_data.data.address = &read_address;
+    push_data.data.size = sizeof(read_address);
+
+    m_command_buffer.Begin();
+    m_command_buffer.BeginRenderPass(m_renderPassBeginInfo);
+
+    vk::CmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, descriptor_heap_pipe);
+
+    VkBindHeapInfoEXT bind_resource_info = vku::InitStructHelper();
+    bind_resource_info.heapRange.address = heap.Address();
+    bind_resource_info.heapRange.size = heap_size;
+    bind_resource_info.reservedRangeOffset = descriptor_size;
+    bind_resource_info.reservedRangeSize = heap_props.minResourceHeapReservedRange;
+    vk::CmdBindResourceHeapEXT(m_command_buffer, &bind_resource_info);
+
+    vk::CmdPushDataEXT(m_command_buffer, &push_data);
+    vk::CmdDraw(m_command_buffer, 3u, 1u, 0u, 0u);
+
+    m_command_buffer.EndRenderPass();
+    m_command_buffer.End();
+    m_errorMonitor->SetDesiredError("VUID-vkCmdDraw-None-11438");
+    m_default_queue->SubmitAndWait(m_command_buffer);
+    m_errorMonitor->VerifyFound();
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-/* Copyright (c) 2025 LunarG, Inc.`
	`1`	`+/* Copyright (c) 2025-2026 LunarG, Inc.`
`2`	`2`	`*`
`3`	`3`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`4`	`4`	`* you may not use this file except in compliance with the License.`