Nvidia Nsight se bloquea al crear BLAS. ¿Cuál podría ser la causa?

Actualmente tengo problemas para configurar una instancia BLAS en mi aplicación de Vulkan, pero tengo problemas para configurar Nsight para poder depurarla adecuadamente.

Las compilaciones funcionan bien y la depuración (normal) también funciona, pero no es suficiente para descubrir por qué no puedo ver ninguna geometría en mi pantalla. Por lo tanto, intenté depurar la estructura de aceleración con Nsight, pero se bloquea.

Sin embargo, no se bloquea al iniciarse, parece que se bloquea exactamente en “CmdBuildAccelerationStructuresKHR”, por lo que estoy seguro de que el problema radica en la creación de la BLAS o quizás en la geometría de ejemplo que utilizo.

Parece que Nsight no puede acceder a una dirección o no tiene los derechos, pero realmente no lo sé.

Código de ejemplo de geometría para la prueba de BLAS:

const float vertices[9] = {
0.25f, 0.25f, 0.0f,
0.75f, 0.25f, 0.0f,
0.50f, 0.75f, 0.0f
};

const float indices[3] = { 0.0f, 1.0f, 2.0f };

BufferResource_t vertex_buffer_resource;
BufferResource_t index_buffer_resource;

VkResult err = buffer_create(&vertex_buffer_resource, sizeof(vertices), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT);
if (err != VK_SUCCESS)
Sys_Error("La creación de búferes falló");

void* mem_vert = buffer_map(&vertex_buffer_resource);
memcpy(mem_vert, vertices, vertex_buffer_resource.size);
buffer_unmap(&vertex_buffer_resource);
mem_vert = NULL;

buffer_create(&index_buffer_resource, sizeof(indices), VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT);

void* mem_ind = buffer_map(&index_buffer_resource);
memcpy(mem_ind, &indices, index_buffer_resource.size);
buffer_unmap(&index_buffer_resource);

VkTransformMatrixKHR transform;
memset(&transform, 0, sizeof(VkTransformMatrixKHR));
transform.matrix[0][0] = 1.0;
transform.matrix[1][1] = 1.0;
transform.matrix[2][2] = 1.0;

BufferResource_t transform_buffer_resource;
buffer_create(&transform_buffer_resource, sizeof(VkTransformMatrixKHR), VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT);

void* mem_transf = buffer_map(&transform_buffer_resource);
memcpy(mem_transf, &transform, transform_buffer_resource.size);
buffer_unmap(&transform_buffer_resource);

Código de BLAS:

VkDeviceOrHostAddressConstKHR vertex_device_or_host_address_const;
memset(&vertex_device_or_host_address_const, 0, sizeof(VkDeviceOrHostAddressConstKHR));
vertex_device_or_host_address_const.deviceAddress = vertex_buffer_resource.address;

VkDeviceOrHostAddressConstKHR index_device_or_host_address_const;
memset(&index_device_or_host_address_const, 0, sizeof(VkDeviceOrHostAddressConstKHR));
index_device_or_host_address_const.deviceAddress = index_buffer_resource.address;

VkDeviceOrHostAddressConstKHR transform_device_or_host_address_const;
memset(&transform_device_or_host_address_const, 0, sizeof(VkDeviceOrHostAddressConstKHR));
transform_device_or_host_address_const.deviceAddress = transform_buffer_resource.address;

VkAccelerationStructureGeometryTrianglesDataKHR geometry_triangles_data;
memset(&geometry_triangles_data, 0, sizeof(VkAccelerationStructureGeometryTrianglesDataKHR));
geometry_triangles_data.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
geometry_triangles_data.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT;
geometry_triangles_data.vertexData = vertex_device_or_host_address_const;
geometry_triangles_data.maxVertex = 9;
geometry_triangles_data.indexType = VK_INDEX_TYPE_UINT32;
geometry_triangles_data.indexData = index_device_or_host_address_const;
geometry_triangles_data.transformData = transform_device_or_host_address_const;

VkAccelerationStructureGeometryKHR geometry;
memset(&geometry, 0, sizeof(VkAccelerationStructureGeometryKHR));
geometry.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
geometry.geometry.triangles = geometry_triangles_data;
geometry.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
geometry.flags = VK_GEOMETRY_OPAQUE_BIT_KHR;

VkAccelerationStructureBuildGeometryInfoKHR buildInfo;
memset(&buildInfo, 0, sizeof(VkAccelerationStructureBuildGeometryInfoKHR));
buildInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
buildInfo.pNext = VK_NULL_HANDLE;
buildInfo.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
buildInfo.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
buildInfo.mode = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR;
buildInfo.srcAccelerationStructure = VK_NULL_HANDLE;
buildInfo.dstAccelerationStructure = VK_NULL_HANDLE;
buildInfo.geometryCount = 1;
buildInfo.pGeometries = &geometry;
buildInfo.ppGeometries = VK_NULL_HANDLE;

const uint32_t max_primitive_count = 3;

VkAccelerationStructureBuildSizesInfoKHR sizeInfo;
memset(&sizeInfo, 0, sizeof(VkAccelerationStructureBuildSizesInfoKHR));
sizeInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR;

fpGetAccelerationStructureBuildSizesKHR(vulkan_globals.device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &max_primitive_count, &sizeInfo);

VkAccelerationStructureCreateInfoKHR createInfo;
memset(&createInfo, 0, sizeof(VkAccelerationStructureCreateInfoKHR));
createInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR;
createInfo.size = sizeInfo.accelerationStructureSize;
createInfo.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;

BufferResource_t scratch_buffer;
buffer_create(&scratch_buffer, sizeInfo.buildScratchSize, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

VkDeviceOrHostAddressKHR scratchDeviceOrHostAddress;
memset(&scratchDeviceOrHostAddress, 0, sizeof(VkDeviceOrHostAddressKHR));
scratchDeviceOrHostAddress.deviceAddress = scratch_buffer.address;

buildInfo.scratchData = scratchDeviceOrHostAddress;

buffer_create(&blas->mem, sizeInfo.accelerationStructureSize, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
createInfo.buffer = blas->mem.buffer;

VkResult err = fpCreateAccelerationStructureKHR(vulkan_globals.device, &createInfo, NULL, &blas->accel);
if (err != VK_SUCCESS)
Sys_Error("La creación de vkCreateAccelerationStructure falló");

buildInfo.dstAccelerationStructure = blas->accel;

VkAccelerationStructureBuildRangeInfoKHR* build_range =
&(VkAccelerationStructureBuildRangeInfoKHR) {