Add acceleration structure meta-commands

framework/decode/api_decoder.h

@@ -186,19 +186,25 @@ class ApiDecoder
  std::vector<format::InitDx12AccelerationStructureGeometryDesc>& geometry_descs,
  const uint8_t* build_inputs_data) = 0;
 
- virtual void DispatchGetDxgiAdapterInfo(const format::DxgiAdapterInfoCommandHeader& adapter_info_header){};
+ virtual void DispatchGetDxgiAdapterInfo(const format::DxgiAdapterInfoCommandHeader& adapter_info_header) {};
 
- virtual void DispatchGetDx12RuntimeInfo(const format::Dx12RuntimeInfoCommandHeader& runtime_info_header){};
+ virtual void DispatchGetDx12RuntimeInfo(const format::Dx12RuntimeInfoCommandHeader& runtime_info_header) {};
 
- virtual void SetCurrentBlockIndex(uint64_t block_index){};
+ virtual void SetCurrentBlockIndex(uint64_t block_index) {};
 
- virtual void SetCurrentApiCallId(format::ApiCallId api_call_id){};
+ virtual void SetCurrentApiCallId(format::ApiCallId api_call_id) {};
 
  virtual void DispatchSetTlasToBlasDependencyCommand(format::HandleId tlas,
- const std::vector<format::HandleId>& blases){};
+ const std::vector<format::HandleId>& blases) {};
 
  virtual void DispatchSetEnvironmentVariablesCommand(format::SetEnvironmentVariablesCommand& header,
- const char* env_string){};
+ const char* env_string) {};
+
+ virtual void DispatchVulkanAccelerationStructuresBuildMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size) {};
+
+ virtual void DispatchVulkanAccelerationStructuresCopyMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size) {};
 };
 
 GFXRECON_END_NAMESPACE(decode)

framework/decode/metadata_consumer_base.h

@@ -26,6 +26,7 @@
 
 #include "util/defines.h"
 #include "format/format.h"
+#include "generated/generated_vulkan_struct_decoders.h"
 
 GFXRECON_BEGIN_NAMESPACE(gfxrecon)
 GFXRECON_BEGIN_NAMESPACE(decode)
@@ -107,8 +108,24 @@ class MetadataConsumerBase
 
  virtual void SetCurrentBlockIndex(uint64_t block_index) {}
 
+ virtual void ProcessBuildVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device_id,
+ uint32_t info_count,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildGeometryInfoKHR>* geometry_infos,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildRangeInfoKHR*>* range_infos,
+ std::vector<std::vector<VkAccelerationStructureInstanceKHR>>& instance_buffers_data)
+ {}
+
+ virtual void ProcessCopyVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device_id, StructPointerDecoder<Decoded_VkCopyAccelerationStructureInfoKHR>* copy_infos)
+ {}
+
+ virtual void ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand(
+ format::HandleId device_id, VkQueryType query_type, format::HandleId acceleration_structure_id)
+ {}
+
  protected:
- uint64_t block_index_;
+ uint64_t block_index_ = 0;
 };
 
 GFXRECON_END_NAMESPACE(decode)

framework/decode/vulkan_decoder_base.cpp

@@ -568,5 +568,81 @@ void VulkanDecoderBase::SetCurrentBlockIndex(uint64_t block_index)
  }
 }
 
+void VulkanDecoderBase::DispatchVulkanAccelerationStructuresBuildMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size)
+{
+
+ format::HandleId device_id;
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildGeometryInfoKHR> pInfos;
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildRangeInfoKHR*> ppRangeInfos;
+
+ std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, buffer_size, &device_id);
+ bytes_read += pInfos.Decode(parameter_buffer + bytes_read, buffer_size - bytes_read);
+ bytes_read += ppRangeInfos.Decode(parameter_buffer + bytes_read, buffer_size - bytes_read);
+
+ std::vector<std::vector<VkAccelerationStructureInstanceKHR>> instance_buffers;
+ if (bytes_read < buffer_size)
+ {
+ for (uint32_t i = 0; i < pInfos.GetLength(); ++i)
+ {
+ if (pInfos.GetPointer()[i].type != VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR)
+ {
+ continue;
+ }
+
+ uint32_t geometry_count = pInfos.GetPointer()[i].geometryCount;
+ for (uint32_t g = 0; g < geometry_count; ++g)
+ {
+ instance_buffers.emplace_back(ppRangeInfos.GetPointer()[g]->primitiveCount);
+ util::platform::MemoryCopy(instance_buffers.back().data(),
+ instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR),
+ parameter_buffer + bytes_read,
+ instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR));
+ bytes_read += instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR);
+ }
+ }
+ }
+
+ for (auto consumer : consumers_)
+ {
+ consumer->ProcessBuildVulkanAccelerationStructuresMetaCommand(
+ device_id, pInfos.GetLength(), &pInfos, &ppRangeInfos, instance_buffers);
+ }
+}
+
+void VulkanDecoderBase::DispatchVulkanAccelerationStructuresCopyMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size)
+{
+ format::HandleId device_id;
+ StructPointerDecoder<Decoded_VkCopyAccelerationStructureInfoKHR> pInfos;
+
+ std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, buffer_size, &device_id);
+ pInfos.Decode(parameter_buffer + bytes_read, buffer_size - bytes_read);
+
+ for (auto consumer : consumers_)
+ {
+ consumer->ProcessCopyVulkanAccelerationStructuresMetaCommand(device_id, &pInfos);
+ }
+}
+
+//void VulkanDecoderBase::DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand(const uint8_t* parameter_buffer,
+// size_t buffer_size)
+//{
+// format::HandleId device_id;
+// VkQueryType query_type;
+// format::HandleId acceleration_structure_id;
+//
+// std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, sizeof(format::HandleId), &device_id);
+// bytes_read += ValueDecoder::DecodeEnumValue(parameter_buffer + bytes_read, sizeof(VkQueryType), &query_type);
+// bytes_read += ValueDecoder::DecodeHandleIdValue(
+// parameter_buffer + bytes_read, sizeof(format::HandleId), &acceleration_structure_id);
+//
+// for (auto consumer : consumers_)
+// {
+// consumer->ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand(
+// device_id, query_type, acceleration_structure_id);
+// }
+//}
+
 GFXRECON_END_NAMESPACE(decode)
 GFXRECON_END_NAMESPACE(gfxrecon)

framework/decode/vulkan_decoder_base.h

@@ -200,6 +200,12 @@ class VulkanDecoderBase : public ApiDecoder
 
  virtual void SetCurrentBlockIndex(uint64_t block_index) override;
 
+ void DispatchVulkanAccelerationStructuresBuildMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size) override;
+
+ void DispatchVulkanAccelerationStructuresCopyMetaCommand(const uint8_t* parameter_buffer,
+ size_t buffer_size) override;
+
  protected:
  const std::vector<VulkanConsumer*>& GetConsumers() const { return consumers_; }
 

framework/decode/vulkan_replay_consumer_base.cpp

@@ -9363,6 +9363,75 @@ void VulkanReplayConsumerBase::Process_vkCreateRayTracingPipelinesKHR(
  }
 }
 
+void VulkanReplayConsumerBase::ProcessCopyVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device, StructPointerDecoder<Decoded_VkCopyAccelerationStructureInfoKHR>* copy_infos)
+{
+ DeviceInfo* device_info = GetObjectInfoTable().GetDeviceInfo(device);
+ GFXRECON_ASSERT(device_info != nullptr);
+
+ auto allocator = device_info->allocator.get();
+ GFXRECON_ASSERT(allocator != nullptr);
+
+ if (allocator->SupportsOpaqueDeviceAddresses() || !loading_trim_state_)
+ {
+ return;
+ }
+
+ MapStructArrayHandles(copy_infos->GetMetaStructPointer(), copy_infos->GetLength(), GetObjectInfoTable());
+
+ // TODO: implement
+ // acceleration_structure_builders_[device]->ProcessCopyVulkanAccelerationStructuresMetaCommand(
+ // copy_infos->GetLength(), copy_infos->GetPointer());
+}
+
+void VulkanReplayConsumerBase::ProcessBuildVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device,
+ uint32_t info_count,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildGeometryInfoKHR>* pInfos,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildRangeInfoKHR*>* ppRangeInfos,
+ std::vector<std::vector<VkAccelerationStructureInstanceKHR>>& instance_buffers_data)
+{
+ DeviceInfo* device_info = GetObjectInfoTable().GetDeviceInfo(device);
+ GFXRECON_ASSERT(device_info != nullptr);
+
+ auto allocator = device_info->allocator.get();
+ GFXRECON_ASSERT(allocator != nullptr);
+
+ // TODO: really questioning "SupportsOpaqueDeviceAddresses" condition
+ if (allocator->SupportsOpaqueDeviceAddresses() || !loading_trim_state_)
+ {
+ return;
+ }
+
+ MapStructArrayHandles(pInfos->GetMetaStructPointer(), pInfos->GetLength(), GetObjectInfoTable());
+
+ // TODO: implement
+ // acceleration_structure_builders_[device]->ProcessBuildVulkanAccelerationStructuresMetaCommand(
+ // info_count, pInfos->GetPointer(), ppRangeInfos->GetPointer(), instance_buffers_data);
+}
+
+void VulkanReplayConsumerBase::ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand(
+ format::HandleId device_id, VkQueryType query_type, format::HandleId acceleration_structure_id)
+{
+ DeviceInfo* device_info = GetObjectInfoTable().GetDeviceInfo(device_id);
+ GFXRECON_ASSERT(device_info != nullptr);
+
+ auto allocator = device_info->allocator.get();
+ GFXRECON_ASSERT(allocator != nullptr);
+
+ if (allocator->SupportsOpaqueDeviceAddresses() || !loading_trim_state_)
+ {
+ return;
+ }
+
+ VkAccelerationStructureKHR acceleration_structure = MapHandle<AccelerationStructureKHRInfo>(
+ acceleration_structure_id, &VulkanObjectInfoTable::GetAccelerationStructureKHRInfo);
+
+ // TODO: implement
+ // acceleration_structure_builders_[device_id]->ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand(
+ // query_type, acceleration_structure);
+}
+
 void VulkanReplayConsumerBase::OverrideUpdateDescriptorSets(
  PFN_vkUpdateDescriptorSets func,
  const DeviceInfo* device_info,

framework/decode/vulkan_replay_consumer_base.h

@@ -189,16 +189,29 @@ class VulkanReplayConsumerBase : public VulkanConsumer
  format::HandleId commandBuffer,
  StructPointerDecoder<Decoded_VkPushDescriptorSetWithTemplateInfoKHR>*
  pPushDescriptorSetWithTemplateInfo) override;
- virtual void Process_vkCreateRayTracingPipelinesKHR(
- const ApiCallInfo& call_info,
- VkResult returnValue,
- format::HandleId device,
- format::HandleId deferredOperation,
- format::HandleId pipelineCache,
- uint32_t createInfoCount,
- StructPointerDecoder<Decoded_VkRayTracingPipelineCreateInfoKHR>* pCreateInfos,
- StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator,
- HandlePointerDecoder<VkPipeline>* pPipelines) override;
+ void Process_vkCreateRayTracingPipelinesKHR(
+ const ApiCallInfo& call_info,
+ VkResult returnValue,
+ format::HandleId device,
+ format::HandleId deferredOperation,
+ format::HandleId pipelineCache,
+ uint32_t createInfoCount,
+ StructPointerDecoder<Decoded_VkRayTracingPipelineCreateInfoKHR>* pCreateInfos,
+ StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator,
+ HandlePointerDecoder<VkPipeline>* pPipelines) override;
+
+ void ProcessBuildVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device,
+ uint32_t info_count,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildGeometryInfoKHR>* pInfos,
+ StructPointerDecoder<Decoded_VkAccelerationStructureBuildRangeInfoKHR*>* ppRangeInfos,
+ std::vector<std::vector<VkAccelerationStructureInstanceKHR>>& instance_buffers_data) override;
+
+ void ProcessCopyVulkanAccelerationStructuresMetaCommand(
+ format::HandleId device, StructPointerDecoder<Decoded_VkCopyAccelerationStructureInfoKHR>* copy_infos) override;
+
+ void ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand(
+ format::HandleId device_id, VkQueryType query_type, format::HandleId acceleration_structure_id) override;
 
  template <typename T>
  void AllowCompileDuringPipelineCreation(uint32_t create_info_count, const T* create_infos)