gpuav: Support desc heaps in buffer validation

- Create a descriptor heap variant of every
validation compute pipeline, picked from the command buffer's last used
descriptor mode, binding resources, push constants and
error logging buffers as push data addresses instead of descriptor sets
- Stop skipping validation commands in heap mode,
only skip descriptor buffer mode
- Force device address usage on all buffers and allocations,
adding a manual chassis vkAllocateMemory so GPU-AV can modify VkMemoryAllocateInfo
- Store the error buffer dword size in the buffer itself
instead of querying the runtime array length, and move its offsets into gpuav_shaders_constants.h
Done because buffer descriptors are now managed through buffer
addresses in push data, so cannot access their metadata anymore
- Tidy ComputePipeline: hide handles behind Valid()/Bind* methods,
make SharedResourcesCache re-entrant
- Add descriptor heap tests for index buffer OOB,
invalid BLAS reference and vertex attribute fetch OOB

Author: arno-lunarg

BUILD.gn

@@ -188,7 +188,6 @@ vvl_sources = [
   "layers/gpuav/validation_cmd/gpuav_ray_tracing.h",
   "layers/gpuav/core/gpuav_settings.h",
   "layers/gpuav/core/gpuav.h",
-  "layers/gpuav/core/gpuav_constants.h",
   "layers/gpuav/core/gpuav_record.cpp",
   "layers/gpuav/core/gpuav_settings.cpp",
   "layers/gpuav/core/gpuav_settings.h",

layers/CMakeLists.txt

@@ -314,7 +314,6 @@ target_sources(vvl PRIVATE
     ${API_TYPE}/generated/extended_flags_helper_generator.h
     ${API_TYPE}/generated/extended_flags_helper_generator.cpp
     gpuav/core/gpuav.h
-    gpuav/core/gpuav_constants.h
     gpuav/core/gpuav_features.cpp
     gpuav/core/gpuav_record.cpp
     gpuav/core/gpuav_setup.cpp

layers/chassis/chassis.h

@@ -74,6 +74,8 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkD
                                                       VkDescriptorSet* pDescriptorSets);
 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                              const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
 VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
 VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,

layers/chassis/chassis_manual.cpp

@@ -1160,6 +1160,62 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreat
     return result;
 }
 
+// This API needs the ability to modify a down-chain parameter
+VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                              const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    VVL_ZoneScoped;
+
+    auto device_dispatch = vvl::GetDispatchDevice(device);
+    bool skip = false;
+    ErrorObject error_obj(vvl::Func::vkAllocateMemory, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
+
+    {
+        VVL_ZoneScopedN("PreCallValidate_AllocateMemory");
+        for (const auto& vo : device_dispatch->intercept_vectors[InterceptIdPreCallValidateAllocateMemory]) {
+            if (!vo) {
+                continue;
+            }
+            auto lock = vo->ReadLock();
+            skip |= vo->PreCallValidateAllocateMemory(device, pAllocateInfo, pAllocator, pMemory, error_obj);
+            if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+        }
+    }
+
+    chassis::AllocateMemory chassis_state{};
+    chassis_state.allocate_info_copy = pAllocateInfo;
+
+    RecordObject record_obj(vvl::Func::vkAllocateMemory);
+    {
+        VVL_ZoneScopedN("PreCallRecord_AllocateMemory");
+        for (auto& vo : device_dispatch->object_dispatch) {
+            if (!vo) {
+                continue;
+            }
+            auto lock = vo->WriteLock();
+            vo->PreCallRecordAllocateMemory(device, pAllocateInfo, pAllocator, pMemory, record_obj, chassis_state);
+        }
+    }
+
+    VkResult result;
+    {
+        VVL_ZoneScopedN("Dispatch_AllocateMemory");
+        result = device_dispatch->AllocateMemory(device, chassis_state.allocate_info_copy, pAllocator, pMemory);
+    }
+    record_obj.result = result;
+
+    {
+        VVL_ZoneScopedN("PostCallRecord_AllocateMemory");
+        for (auto& vo : device_dispatch->intercept_vectors[InterceptIdPostCallRecordAllocateMemory]) {
+            if (!vo) {
+                continue;
+            }
+            auto lock = vo->WriteLock();
+            vo->PostCallRecordAllocateMemory(device, pAllocateInfo, pAllocator, pMemory, record_obj);
+        }
+    }
+    return result;
+}
+
 // This API needs to ensure that per-swapchain VkResult results are available
 VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
     VVL_ZoneScoped;

layers/chassis/chassis_modification_state.h

@@ -167,4 +167,11 @@ struct CreateBuffer {
     vku::safe_VkBufferCreateInfo modified_create_info;
 };
 
+struct AllocateMemory {
+    // To not waste time for CoreChecks we just copy the pointer, but if GPU-AV want to modifiy it, it will update pointer to be a
+    // pointer of the Safe Struct
+    const VkMemoryAllocateInfo* allocate_info_copy;
+    vku::safe_VkMemoryAllocateInfo modified_allocate_info;
+};
+
 }  // namespace chassis

layers/chassis/validation_object.h

@@ -58,6 +58,7 @@ struct ShaderBinaryData;
 struct CreatePipelineLayout;
 struct CreateBuffer;
 struct CmdBindDescriptorBuffers;
+struct AllocateMemory;
 }  // namespace chassis
 
 namespace vvl {
@@ -462,6 +463,13 @@ class BaseDevice : public Logger {
         PreCallRecordCmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos, record_obj);
     }
 
+    // Modify a parameter to AllocateMemory
+    virtual void PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                             const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory,
+                                             const RecordObject& record_obj, chassis::AllocateMemory& chassis_state) {
+        PreCallRecordAllocateMemory(device, pAllocateInfo, pAllocator, pMemory, record_obj);
+    }
+
 #include "generated/validation_object_device_methods.h"
 };
 

layers/gpuav/core/gpuav.h

@@ -102,6 +102,9 @@ class Validator : public GpuShaderInstrumentor {
                                     VkBuffer* pBuffer, const RecordObject& record_obj) final;
     void PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator,
                                     const RecordObject& record_obj) final;
+    void PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                     const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory,
+                                     const RecordObject& record_obj, chassis::AllocateMemory& chassis_state) final;
     void PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator,
                                  const RecordObject& record_obj) final;
     void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset,

layers/gpuav/core/gpuav_constants.h

@@ -50,6 +50,10 @@ void Validator::PreCallRecordCreateBuffer(VkDevice device, const VkBufferCreateI
 
     VkBufferUsageFlags2 extra_usage = 0;
 
+    if (!enabled_features.descriptorHeap) {
+        extra_usage |= VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
+    }
+
     // Ray tracing acceleration structure instance buffers also need the storage buffer usage as
     // acceleration structure build validation will find and replace invalid acceleration structure
     // handles inside of a compute shader.
@@ -103,6 +107,27 @@ void Validator::PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, con
     descriptor_buffer.resource_handles_.erase(buffer);
 }
 
+void Validator::PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                            const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory,
+                                            const RecordObject& record_obj, chassis::AllocateMemory& chassis_state) {
+    if (!enabled_features.descriptorHeap) {
+        return;
+    }
+
+    chassis_state.modified_allocate_info.initialize(pAllocateInfo);
+
+    if (auto* alloc_flags_info = const_cast<VkMemoryAllocateFlagsInfo*>(
+            vku::FindStructInPNextChain<VkMemoryAllocateFlagsInfo>(chassis_state.modified_allocate_info.pNext))) {
+        alloc_flags_info->flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
+    } else {
+        VkMemoryAllocateFlagsInfo new_alloc_flags_info = vku::InitStructHelper();
+        new_alloc_flags_info.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
+        vku::AddToPnext(chassis_state.modified_allocate_info, new_alloc_flags_info);
+    }
+
+    chassis_state.allocate_info_copy = chassis_state.modified_allocate_info.ptr();
+}
+
 void Validator::PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator,
                                         const RecordObject& record_obj) {
     if (descriptor_buffer.resource_memory_handles_.find(memory) != descriptor_buffer.resource_memory_handles_.end()) {

layers/gpuav/core/gpuav_record.cpp

@@ -23,7 +23,6 @@
 #endif
 #include "chassis/dispatch_object.h"
 #include "gpuav/core/gpuav.h"
-#include "gpuav/core/gpuav_constants.h"
 #include "gpuav/instrumentation/descriptor_checks_classic.h"
 #include "gpuav/resources/gpuav_state_trackers.h"
 #include "gpuav/shaders/gpuav_error_header.h"