fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 20:28:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

hasvk: remove acceleration structure code

Browse source 
Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Acked-by: Jason Ekstrand <jason.ekstrand@collabora.com>
Acked-by: Jason Ekstrand <jason@jlekstrand.net>
Acked-by: Jason Ekstrand <jason.ekstrand@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18208>
This commit is contained in:
Lionel Landwerlin 2022-08-22 09:54:24 +03:00 • committed by Marge Bot
parent 00eefdcd03
commit 4488253570
7 changed files with 2 additions and 394 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

251
src/intel/vulkan_hasvk/anv_acceleration_structure.c
View file

@ -1,251 +0,0 @@
/*
* Copyright © 2020 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "anv_private.h"
void
anv_GetAccelerationStructureBuildSizesKHR(
VkDevice device,
VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
const uint32_t* pMaxPrimitiveCounts,
VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
{
assert(pSizeInfo->sType ==
VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR);
pSizeInfo->accelerationStructureSize = 0; /* TODO */
uint64_t cpu_build_scratch_size = 0; /* TODO */
uint64_t cpu_update_scratch_size = cpu_build_scratch_size;
uint64_t gpu_build_scratch_size = 0; /* TODO */
uint64_t gpu_update_scratch_size = gpu_build_scratch_size;
switch (buildType) {
case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR:
pSizeInfo->buildScratchSize = cpu_build_scratch_size;
pSizeInfo->updateScratchSize = cpu_update_scratch_size;
break;
case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR:
pSizeInfo->buildScratchSize = gpu_build_scratch_size;
pSizeInfo->updateScratchSize = gpu_update_scratch_size;
break;
case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR:
pSizeInfo->buildScratchSize = MAX2(cpu_build_scratch_size,
gpu_build_scratch_size);
pSizeInfo->updateScratchSize = MAX2(cpu_update_scratch_size,
gpu_update_scratch_size);
break;
default:
unreachable("Invalid acceleration structure build type");
}
}
VkResult
anv_CreateAccelerationStructureKHR(
VkDevice _device,
const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkAccelerationStructureKHR* pAccelerationStructure)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer);
struct anv_acceleration_structure *accel;
accel = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*accel), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (accel == NULL)
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &accel->base,
VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR);
accel->size = pCreateInfo->size;
accel->address = anv_address_add(buffer->address, pCreateInfo->offset);
*pAccelerationStructure = anv_acceleration_structure_to_handle(accel);
return VK_SUCCESS;
}
void
anv_DestroyAccelerationStructureKHR(
VkDevice _device,
VkAccelerationStructureKHR accelerationStructure,
const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_acceleration_structure, accel, accelerationStructure);
if (!accel)
return;
vk_object_base_finish(&accel->base);
vk_free2(&device->vk.alloc, pAllocator, accel);
}
VkDeviceAddress
anv_GetAccelerationStructureDeviceAddressKHR(
VkDevice device,
const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
{
ANV_FROM_HANDLE(anv_acceleration_structure, accel,
pInfo->accelerationStructure);
assert(!anv_address_is_null(accel->address));
assert(anv_bo_is_pinned(accel->address.bo));
return anv_address_physical(accel->address);
}
void
anv_GetDeviceAccelerationStructureCompatibilityKHR(
VkDevice device,
const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
unreachable("Unimplemented");
}
VkResult
anv_BuildAccelerationStructuresKHR(
VkDevice _device,
VkDeferredOperationKHR deferredOperation,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
ANV_FROM_HANDLE(anv_device, device, _device);
unreachable("Unimplemented");
return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
}
VkResult
anv_CopyAccelerationStructureKHR(
VkDevice _device,
VkDeferredOperationKHR deferredOperation,
const VkCopyAccelerationStructureInfoKHR* pInfo)
{
ANV_FROM_HANDLE(anv_device, device, _device);
unreachable("Unimplemented");
return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
}
VkResult
anv_CopyAccelerationStructureToMemoryKHR(
VkDevice _device,
VkDeferredOperationKHR deferredOperation,
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
ANV_FROM_HANDLE(anv_device, device, _device);
unreachable("Unimplemented");
return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
}
VkResult
anv_CopyMemoryToAccelerationStructureKHR(
VkDevice _device,
VkDeferredOperationKHR deferredOperation,
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
ANV_FROM_HANDLE(anv_device, device, _device);
unreachable("Unimplemented");
return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
}
VkResult
anv_WriteAccelerationStructuresPropertiesKHR(
VkDevice _device,
uint32_t accelerationStructureCount,
const VkAccelerationStructureKHR* pAccelerationStructures,
VkQueryType queryType,
size_t dataSize,
void* pData,
size_t stride)
{
ANV_FROM_HANDLE(anv_device, device, _device);
unreachable("Unimplemented");
return vk_error(device, VK_ERROR_FEATURE_NOT_PRESENT);
}
void
anv_CmdBuildAccelerationStructuresKHR(
VkCommandBuffer commandBuffer,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
unreachable("Unimplemented");
}
void
anv_CmdBuildAccelerationStructuresIndirectKHR(
VkCommandBuffer commandBuffer,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
const VkDeviceAddress* pIndirectDeviceAddresses,
const uint32_t* pIndirectStrides,
const uint32_t* const* ppMaxPrimitiveCounts)
{
unreachable("Unimplemented");
}
void
anv_CmdCopyAccelerationStructureKHR(
VkCommandBuffer commandBuffer,
const VkCopyAccelerationStructureInfoKHR* pInfo)
{
unreachable("Unimplemented");
}
void
anv_CmdCopyAccelerationStructureToMemoryKHR(
VkCommandBuffer commandBuffer,
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
unreachable("Unimplemented");
}
void
anv_CmdCopyMemoryToAccelerationStructureKHR(
VkCommandBuffer commandBuffer,
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
unreachable("Unimplemented");
}
void
anv_CmdWriteAccelerationStructuresPropertiesKHR(
VkCommandBuffer commandBuffer,
uint32_t accelerationStructureCount,
const VkAccelerationStructureKHR* pAccelerationStructures,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery)
{
unreachable("Unimplemented");
}

16
src/intel/vulkan_hasvk/anv_cmd_buffer.c
View file

@ -997,22 +997,6 @@ void anv_CmdPushDescriptorSetKHR(
}
break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: {
const VkWriteDescriptorSetAccelerationStructureKHR *accel_write =
vk_find_struct_const(write, WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR);
assert(accel_write->accelerationStructureCount ==
write->descriptorCount);
for (uint32_t j = 0; j < write->descriptorCount; j++) {
ANV_FROM_HANDLE(anv_acceleration_structure, accel,
accel_write->pAccelerationStructures[j]);
anv_descriptor_set_write_acceleration_structure(cmd_buffer->device,
set, accel,
write->dstBinding,
write->dstArrayElement + j);
}
break;
}
default:
break;
}

80
src/intel/vulkan_hasvk/anv_descriptor_set.c
View file

@ -91,10 +91,6 @@ anv_descriptor_data_for_type(const struct anv_physical_device *device,
data = ANV_DESCRIPTOR_INLINE_UNIFORM;
break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
data = ANV_DESCRIPTOR_ADDRESS_RANGE;
break;
default:
unreachable("Unsupported descriptor type");
}
@ -142,9 +138,6 @@ anv_descriptor_data_for_mutable_type(const struct anv_physical_device *device,
desc_data |= anv_descriptor_data_for_type(device, i);
}
desc_data |= anv_descriptor_data_for_type(
device, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
return desc_data;
}
@ -234,10 +227,6 @@ anv_descriptor_size_for_mutable_type(const struct anv_physical_device *device,
size = MAX2(size, anv_descriptor_data_size(desc_data));
}
enum anv_descriptor_data desc_data = anv_descriptor_data_for_type(
device, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
size = MAX2(size, anv_descriptor_data_size(desc_data));
return size;
}
@ -1674,39 +1663,6 @@ anv_descriptor_set_write_inline_uniform_data(struct anv_device *device,
memcpy(desc_map + offset, data, size);
}
void
anv_descriptor_set_write_acceleration_structure(struct anv_device *device,
struct anv_descriptor_set *set,
struct anv_acceleration_structure *accel,
uint32_t binding,
uint32_t element)
{
const struct anv_descriptor_set_binding_layout *bind_layout =
&set->layout->binding[binding];
struct anv_descriptor *desc =
&set->descriptors[bind_layout->descriptor_index + element];
assert(bind_layout->data & ANV_DESCRIPTOR_ADDRESS_RANGE);
*desc = (struct anv_descriptor) {
.type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
.accel_struct = accel,
};
if (set->pool && set->pool->host_only)
return;
struct anv_address_range_descriptor desc_data = { };
if (accel != NULL) {
desc_data.address = anv_address_physical(accel->address);
desc_data.range = accel->size;
}
assert(sizeof(desc_data) <= bind_layout->descriptor_stride);
void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
element * bind_layout->descriptor_stride;
memcpy(desc_map, &desc_data, sizeof(desc_data));
}
void anv_UpdateDescriptorSets(
VkDevice _device,
uint32_t descriptorWriteCount,
@ -1780,21 +1736,6 @@ void anv_UpdateDescriptorSets(
break;
}
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: {
const VkWriteDescriptorSetAccelerationStructureKHR *accel_write =
vk_find_struct_const(write, WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR);
assert(accel_write->accelerationStructureCount ==
write->descriptorCount);
for (uint32_t j = 0; j < write->descriptorCount; j++) {
ANV_FROM_HANDLE(anv_acceleration_structure, accel,
accel_write->pAccelerationStructures[j]);
anv_descriptor_set_write_acceleration_structure(device, set, accel,
write->dstBinding,
write->dstArrayElement + j);
}
break;
}
default:
break;
}
@ -1867,14 +1808,6 @@ void anv_UpdateDescriptorSets(
break;
}
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: {
anv_descriptor_set_write_acceleration_structure(device, dst,
src_desc[j].accel_struct,
copy->dstBinding,
copy->dstArrayElement + j);
break;
}
default:
break;
}
@ -1955,19 +1888,6 @@ anv_descriptor_set_write_template(struct anv_device *device,
entry->array_count);
break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
for (uint32_t j = 0; j < entry->array_count; j++) {
VkAccelerationStructureKHR *accel_obj =
(VkAccelerationStructureKHR *)(data + entry->offset + j * entry->stride);
ANV_FROM_HANDLE(anv_acceleration_structure, accel, *accel_obj);
anv_descriptor_set_write_acceleration_structure(device, set,
accel,
entry->binding,
entry->array_element + j);
}
break;
default:
break;
}

27
src/intel/vulkan_hasvk/anv_device.c
View file

@ -1386,16 +1386,6 @@ void anv_GetPhysicalDeviceFeatures2(
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
VkPhysicalDeviceAccelerationStructureFeaturesKHR *features = (void *)ext;
features->accelerationStructure = false;
features->accelerationStructureCaptureReplay = false;
features->accelerationStructureIndirectBuild = false;
features->accelerationStructureHostCommands = false;
features->descriptorBindingAccelerationStructureUpdateAfterBind = true;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *features = (void *)ext;
features->bufferDeviceAddress = pdevice->has_a64_buffer_access;
@ -2234,19 +2224,6 @@ void anv_GetPhysicalDeviceProperties2(
continue;
switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
VkPhysicalDeviceAccelerationStructurePropertiesKHR *props = (void *)ext;
props->maxGeometryCount = (1u << 24) - 1;
props->maxInstanceCount = (1u << 24) - 1;
props->maxPrimitiveCount = (1u << 29) - 1;
props->maxPerStageDescriptorAccelerationStructures = UINT16_MAX;
props->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = UINT16_MAX;
props->maxDescriptorSetAccelerationStructures = UINT16_MAX;
props->maxDescriptorSetUpdateAfterBindAccelerationStructures = UINT16_MAX;
props->minAccelerationStructureScratchOffsetAlignment = 64;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
/* TODO: Real limits */
VkPhysicalDeviceConservativeRasterizationPropertiesEXT *properties =
@ -4754,9 +4731,9 @@ vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion)
*
* - Loader interface v4 differs from v3 in:
* - The ICD must implement vk_icdGetPhysicalDeviceProcAddr().
*
*
* - Loader interface v5 differs from v4 in:
* - The ICD must support Vulkan API version 1.1 and must not return
* - The ICD must support Vulkan API version 1.1 and must not return
* VK_ERROR_INCOMPATIBLE_DRIVER from vkCreateInstance() unless a
* Vulkan Loader with interface v4 or smaller is being used and the
* application provides an API version that is greater than 1.0.

20
src/intel/vulkan_hasvk/anv_private.h
View file

@ -96,7 +96,6 @@ struct anv_batch;
struct anv_buffer;
struct anv_buffer_view;
struct anv_image_view;
struct anv_acceleration_structure;
struct anv_instance;
struct intel_aux_map_context;
@ -1924,8 +1923,6 @@ struct anv_descriptor {
};
struct anv_buffer_view *buffer_view;
struct anv_acceleration_structure *accel_struct;
};
};
@ -2101,13 +2098,6 @@ anv_descriptor_set_write_buffer(struct anv_device *device,
VkDeviceSize offset,
VkDeviceSize range);
void
anv_descriptor_set_write_acceleration_structure(struct anv_device *device,
struct anv_descriptor_set *set,
struct anv_acceleration_structure *accel,
uint32_t binding,
uint32_t element);
void
anv_descriptor_set_write_inline_uniform_data(struct anv_device *device,
struct anv_descriptor_set *set,
@ -4095,13 +4085,6 @@ static inline uint32_t khr_perf_query_preamble_offset(const struct anv_query_poo
return pool->pass_size * pass + 8;
}
struct anv_acceleration_structure {
struct vk_object_base base;
VkDeviceSize size;
struct anv_address address;
};
void
anv_dump_pipe_bits(enum anv_pipe_bits bits);
@ -4205,9 +4188,6 @@ VK_DEFINE_HANDLE_CASTS(anv_physical_device, vk.base, VkPhysicalDevice,
VK_OBJECT_TYPE_PHYSICAL_DEVICE)
VK_DEFINE_HANDLE_CASTS(anv_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEUE)
VK_DEFINE_NONDISP_HANDLE_CASTS(anv_acceleration_structure, base,
VkAccelerationStructureKHR,
VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR)
VK_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer, vk.base, VkBuffer,
VK_OBJECT_TYPE_BUFFER)
VK_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer_view, base, VkBufferView,

1
src/intel/vulkan_hasvk/genX_cmd_buffer.c
View file

@ -2680,7 +2680,6 @@ emit_binding_table(struct anv_cmd_buffer *cmd_buffer,
const struct anv_descriptor *desc = &set->descriptors[binding->index];
switch (desc->type) {
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
case VK_DESCRIPTOR_TYPE_SAMPLER:
/* Nothing for us to do here */
continue;

1
src/intel/vulkan_hasvk/meson.build
View file

@ -98,7 +98,6 @@ foreach g : [['70', ['gfx7_cmd_buffer.c']],
endforeach
libanv_files = files(
'anv_acceleration_structure.c',
'anv_allocator.c',
'anv_android.h',
'anv_batch_chain.c',