mirrors
/
mesa
mirror of https://gitlab.freedesktop.org/mesa/mesa
1
0
Fork 0
Code Issues 9 Packages Projects Releases Wiki Activity

venus: Use common physical device properties 

This lets us delegate the GPDP2 entrypoint to common code.
This also lets us delete struct vn_physical_device_properties,
as it is redundant with struct vk_properties present in the runtime.

Move the properties present in vn_physical_device_properties to the
local_devices struct used to query the host device properties, so we can
still get and fill those properties.

Replace accesses to struct vn_physical_device with accesses to
struct vk_properties filled in at device initialization time.

v2: rebase and a few fixups (zzyiwei)
- rely solely on vk props for final props sanitizations
- set vk11 props behind vk 1.2 condition
- set default pci props if forwarded
- set extension props based on extension support

Signed-off-by: Yiwei Zhang <zzyiwei@chromium.org>
Tested-by: Oskar Viljasaar <oskar.viljasaar@gmail.com>
Reviewed-by: Oskar Viljasaar <oskar.viljasaar@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29180>
This commit is contained in:
Oskar Viljasaar 2024-02-21 23:12:18 +02:00 committed by Marge Bot
parent f04bc27fe1
commit 3c152a6e5d
5 changed files with 154 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/virtio/vulkan/vn_buffer.c
View File

@ -62,7 +62,7 @@ vn_buffer_get_max_buffer_size(struct vn_physical_device *physical_dev)
*/
static const uint64_t safe_max_buffer_size = 1ULL << 30;
return physical_dev->base.base.supported_features.maintenance4
? physical_dev->properties.vulkan_1_3.maxBufferSize
? physical_dev->base.base.properties.maxBufferSize
: safe_max_buffer_size;
}

10
src/virtio/vulkan/vn_device.c
View File

@ -409,11 +409,11 @@ vn_device_update_shader_cache_id(struct vn_device *dev)
* and not utilized by venus.
*/
#if !DETECT_OS_ANDROID && defined(ENABLE_SHADER_CACHE)
const VkPhysicalDeviceProperties *vulkan_1_0_props =
&dev->physical_device->properties.vulkan_1_0;
const uint8_t *device_uuid =
dev->physical_device->base.base.properties.pipelineCacheUUID;
char uuid[VK_UUID_SIZE * 2 + 1];
mesa_bytes_to_hex(uuid, vulkan_1_0_props->pipelineCacheUUID, VK_UUID_SIZE);
mesa_bytes_to_hex(uuid, device_uuid, VK_UUID_SIZE);
struct disk_cache *cache = disk_cache_create("venus", uuid, 0);
if (!cache)
@ -568,8 +568,8 @@ vn_CreateDevice(VkPhysicalDevice physicalDevice,
}
if (VN_DEBUG(LOG_CTX_INFO)) {
vn_log(instance, "%s", physical_dev->properties.vulkan_1_0.deviceName);
vn_log(instance, "%s", physical_dev->properties.vulkan_1_2.driverInfo);
vn_log(instance, "%s", physical_dev->base.base.properties.deviceName);
vn_log(instance, "%s", physical_dev->base.base.properties.driverInfo);
}
vn_tls_set_async_pipeline_create();

412
src/virtio/vulkan/vn_physical_device.c
View File

@ -345,43 +345,36 @@ vn_physical_device_init_features(struct vn_physical_device *physical_dev)
static void
vn_physical_device_init_uuids(struct vn_physical_device *physical_dev)
{
struct vn_physical_device_properties *props = &physical_dev->properties;
struct VkPhysicalDeviceProperties *vk10_props = &props->vulkan_1_0;
struct VkPhysicalDeviceVulkan11Properties *vk11_props = &props->vulkan_1_1;
struct VkPhysicalDeviceVulkan12Properties *vk12_props = &props->vulkan_1_2;
struct vk_properties *props = &physical_dev->base.base.properties;
struct mesa_sha1 sha1_ctx;
uint8_t sha1[SHA1_DIGEST_LENGTH];
static_assert(VK_UUID_SIZE <= SHA1_DIGEST_LENGTH, "");
_mesa_sha1_init(&sha1_ctx);
_mesa_sha1_update(&sha1_ctx, &vk10_props->pipelineCacheUUID,
sizeof(vk10_props->pipelineCacheUUID));
_mesa_sha1_update(&sha1_ctx, &props->pipelineCacheUUID,
sizeof(props->pipelineCacheUUID));
_mesa_sha1_final(&sha1_ctx, sha1);
memcpy(vk10_props->pipelineCacheUUID, sha1, VK_UUID_SIZE);
memcpy(props->pipelineCacheUUID, sha1, VK_UUID_SIZE);
_mesa_sha1_init(&sha1_ctx);
_mesa_sha1_update(&sha1_ctx, &vk10_props->vendorID,
sizeof(vk10_props->vendorID));
_mesa_sha1_update(&sha1_ctx, &vk10_props->deviceID,
sizeof(vk10_props->deviceID));
_mesa_sha1_update(&sha1_ctx, &props->vendorID, sizeof(props->vendorID));
_mesa_sha1_update(&sha1_ctx, &props->deviceID, sizeof(props->deviceID));
_mesa_sha1_final(&sha1_ctx, sha1);
memcpy(vk11_props->deviceUUID, sha1, VK_UUID_SIZE);
memcpy(props->deviceUUID, sha1, VK_UUID_SIZE);
_mesa_sha1_init(&sha1_ctx);
_mesa_sha1_update(&sha1_ctx, vk12_props->driverName,
strlen(vk12_props->driverName));
_mesa_sha1_update(&sha1_ctx, vk12_props->driverInfo,
strlen(vk12_props->driverInfo));
_mesa_sha1_update(&sha1_ctx, props->driverName, strlen(props->driverName));
_mesa_sha1_update(&sha1_ctx, props->driverInfo, strlen(props->driverInfo));
_mesa_sha1_final(&sha1_ctx, sha1);
memcpy(vk11_props->driverUUID, sha1, VK_UUID_SIZE);
memcpy(props->driverUUID, sha1, VK_UUID_SIZE);
memset(vk11_props->deviceLUID, 0, VK_LUID_SIZE);
vk11_props->deviceNodeMask = 0;
vk11_props->deviceLUIDValid = false;
memset(props->deviceLUID, 0, VK_LUID_SIZE);
props->deviceNodeMask = 0;
props->deviceLUIDValid = false;
}
static void
@ -390,20 +383,18 @@ vn_physical_device_sanitize_properties(struct vn_physical_device *physical_dev)
struct vn_instance *instance = physical_dev->instance;
const struct vk_device_extension_table *exts =
&physical_dev->renderer_extensions;
struct vn_physical_device_properties *props = &physical_dev->properties;
VkPhysicalDeviceProperties *vk10_props = &props->vulkan_1_0;
VkPhysicalDeviceVulkan12Properties *vk12_props = &props->vulkan_1_2;
struct vk_properties *props = &physical_dev->base.base.properties;
const uint32_t version_override = vk_get_version_override();
if (version_override) {
vk10_props->apiVersion = version_override;
props->apiVersion = version_override;
} else {
/* cap the advertised api version */
uint32_t ver = MIN3(vk10_props->apiVersion, VN_MAX_API_VERSION,
uint32_t ver = MIN3(props->apiVersion, VN_MAX_API_VERSION,
instance->renderer->info.vk_xml_version);
if (VK_VERSION_PATCH(ver) > VK_VERSION_PATCH(vk10_props->apiVersion)) {
ver = ver - VK_VERSION_PATCH(ver) +
VK_VERSION_PATCH(vk10_props->apiVersion);
if (VK_VERSION_PATCH(ver) > VK_VERSION_PATCH(props->apiVersion)) {
ver =
ver - VK_VERSION_PATCH(ver) + VK_VERSION_PATCH(props->apiVersion);
}
/* Clamp to 1.2 if we disabled VK_KHR_synchronization2 since it
@ -413,54 +404,57 @@ vn_physical_device_sanitize_properties(struct vn_physical_device *physical_dev)
if (!physical_dev->base.base.supported_extensions.KHR_synchronization2)
ver = MIN2(VK_API_VERSION_1_2, ver);
vk10_props->apiVersion = ver;
props->apiVersion = ver;
}
/* ANGLE relies on ARM proprietary driver version for workarounds */
const char *engine_name = instance->base.base.app_info.engine_name;
const bool forward_driver_version =
vk12_props->driverID == VK_DRIVER_ID_ARM_PROPRIETARY && engine_name &&
props->driverID == VK_DRIVER_ID_ARM_PROPRIETARY && engine_name &&
strcmp(engine_name, "ANGLE") == 0;
if (!forward_driver_version)
vk10_props->driverVersion = vk_get_driver_version();
props->driverVersion = vk_get_driver_version();
char device_name[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
int device_name_len =
snprintf(device_name, sizeof(device_name), "Virtio-GPU Venus (%s)",
vk10_props->deviceName);
int device_name_len = snprintf(device_name, sizeof(device_name),
"Virtio-GPU Venus (%s)", props->deviceName);
if (device_name_len >= VK_MAX_PHYSICAL_DEVICE_NAME_SIZE) {
memcpy(device_name + VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 5, "...)", 4);
device_name_len = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 1;
}
memcpy(vk10_props->deviceName, device_name, device_name_len + 1);
memcpy(props->deviceName, device_name, device_name_len + 1);
/* store renderer VkDriverId for implementation specific workarounds */
physical_dev->renderer_driver_id = vk12_props->driverID;
VN_SET_CORE_VALUE(vk12_props, driverID, VK_DRIVER_ID_MESA_VENUS);
physical_dev->renderer_driver_id = props->driverID;
VN_SET_CORE_VALUE(props, driverID, VK_DRIVER_ID_MESA_VENUS);
snprintf(vk12_props->driverName, sizeof(vk12_props->driverName), "venus");
snprintf(vk12_props->driverInfo, sizeof(vk12_props->driverInfo),
snprintf(props->driverName, sizeof(props->driverName), "venus");
snprintf(props->driverInfo, sizeof(props->driverInfo),
"Mesa " PACKAGE_VERSION MESA_GIT_SHA1);
VN_SET_CORE_VALUE(vk12_props, conformanceVersion.major, 1);
VN_SET_CORE_VALUE(vk12_props, conformanceVersion.minor, 3);
VN_SET_CORE_VALUE(vk12_props, conformanceVersion.subminor, 0);
VN_SET_CORE_VALUE(vk12_props, conformanceVersion.patch, 0);
VN_SET_CORE_VALUE(props, conformanceVersion.major, 1);
VN_SET_CORE_VALUE(props, conformanceVersion.minor, 3);
VN_SET_CORE_VALUE(props, conformanceVersion.subminor, 0);
VN_SET_CORE_VALUE(props, conformanceVersion.patch, 0);
vn_physical_device_init_uuids(physical_dev);
/* See comment for sparse binding feature disable */
if (physical_dev->sparse_binding_disabled) {
VN_SET_CORE_VALUE(vk10_props, limits.sparseAddressSpaceSize, 0);
VN_SET_CORE_VALUE(vk10_props, sparseProperties,
(VkPhysicalDeviceSparseProperties){ 0 });
VN_SET_CORE_VALUE(props, sparseAddressSpaceSize, 0);
VN_SET_CORE_VALUE(props, sparseResidencyStandard2DBlockShape, 0);
VN_SET_CORE_VALUE(props, sparseResidencyStandard2DMultisampleBlockShape,
0);
VN_SET_CORE_VALUE(props, sparseResidencyStandard3DBlockShape, 0);
VN_SET_CORE_VALUE(props, sparseResidencyAlignedMipSize, 0);
VN_SET_CORE_VALUE(props, sparseResidencyNonResidentStrict, 0);
}
/* Disable unsupported VkPhysicalDeviceFragmentShadingRatePropertiesKHR */
if (exts->KHR_fragment_shading_rate) {
/* TODO: Add support for VK_EXT_sample_locations */
VN_SET_CORE_VALUE(&props->fragment_shading_rate,
fragmentShadingRateWithCustomSampleLocations, false);
VN_SET_CORE_VALUE(props, fragmentShadingRateWithCustomSampleLocations,
false);
}
}
@ -469,7 +463,8 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
{
const uint32_t renderer_version = physical_dev->renderer_version;
struct vn_instance *instance = physical_dev->instance;
struct vn_physical_device_properties *props = &physical_dev->properties;
const struct vn_renderer_info *renderer_info = &instance->renderer->info;
struct vk_properties *props = &physical_dev->base.base.properties;
const struct vk_device_extension_table *exts =
&physical_dev->renderer_extensions;
VkPhysicalDeviceProperties2 props2 = {
@ -477,6 +472,7 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
};
struct {
/* Vulkan 1.1 */
VkPhysicalDeviceVulkan11Properties vulkan_1_1;
VkPhysicalDeviceIDProperties id;
VkPhysicalDeviceSubgroupProperties subgroup;
VkPhysicalDevicePointClippingProperties point_clipping;
@ -485,6 +481,7 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
VkPhysicalDeviceMaintenance3Properties maintenance_3;
/* Vulkan 1.2 */
VkPhysicalDeviceVulkan12Properties vulkan_1_2;
VkPhysicalDeviceDriverProperties driver;
VkPhysicalDeviceFloatControlsProperties float_controls;
VkPhysicalDeviceDescriptorIndexingProperties descriptor_indexing;
@ -493,12 +490,34 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
VkPhysicalDeviceTimelineSemaphoreProperties timeline_semaphore;
/* Vulkan 1.3 */
VkPhysicalDeviceVulkan13Properties vulkan_1_3;
VkPhysicalDeviceInlineUniformBlockProperties inline_uniform_block;
VkPhysicalDeviceMaintenance4Properties maintenance4;
VkPhysicalDeviceShaderIntegerDotProductProperties
shader_integer_dot_product;
VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control;
VkPhysicalDeviceTexelBufferAlignmentProperties texel_buffer_alignment;
/* KHR */
VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor;
VkPhysicalDeviceFragmentShadingRatePropertiesKHR fragment_shading_rate;
/* EXT */
VkPhysicalDeviceConservativeRasterizationPropertiesEXT
conservative_rasterization;
VkPhysicalDeviceCustomBorderColorPropertiesEXT custom_border_color;
VkPhysicalDeviceExtendedDynamicState3PropertiesEXT
extended_dynamic_state_3;
VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
graphics_pipeline_library;
VkPhysicalDeviceLineRasterizationPropertiesEXT line_rasterization;
VkPhysicalDeviceMultiDrawPropertiesEXT multi_draw;
VkPhysicalDevicePCIBusInfoPropertiesEXT pci_bus_info;
VkPhysicalDeviceProvokingVertexPropertiesEXT provoking_vertex;
VkPhysicalDeviceRobustness2PropertiesEXT robustness_2;
VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback;
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
vertex_attribute_divisor;
} local_props;
/* Clear the structs so all unqueried properties will be well-defined. */
@ -508,10 +527,9 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
assert(renderer_version >= VK_API_VERSION_1_1);
/* clang-format off */
if (renderer_version >= VK_API_VERSION_1_2) {
VN_ADD_PNEXT(props2, VULKAN_1_1_PROPERTIES, props->vulkan_1_1);
VN_ADD_PNEXT(props2, VULKAN_1_2_PROPERTIES, props->vulkan_1_2);
VN_ADD_PNEXT(props2, VULKAN_1_1_PROPERTIES, local_props.vulkan_1_1);
VN_ADD_PNEXT(props2, VULKAN_1_2_PROPERTIES, local_props.vulkan_1_2);
} else {
/* Vulkan 1.1 */
VN_ADD_PNEXT(props2, ID_PROPERTIES, local_props.id);
@ -531,7 +549,7 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
}
if (renderer_version >= VK_API_VERSION_1_3) {
VN_ADD_PNEXT(props2, VULKAN_1_3_PROPERTIES, props->vulkan_1_3);
VN_ADD_PNEXT(props2, VULKAN_1_3_PROPERTIES, local_props.vulkan_1_3);
} else {
VN_ADD_PNEXT_EXT(props2, INLINE_UNIFORM_BLOCK_PROPERTIES, local_props.inline_uniform_block, exts->EXT_inline_uniform_block);
VN_ADD_PNEXT_EXT(props2, MAINTENANCE_4_PROPERTIES, local_props.maintenance4, exts->KHR_maintenance4);
@ -541,21 +559,21 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
}
/* KHR */
VN_ADD_PNEXT_EXT(props2, FRAGMENT_SHADING_RATE_PROPERTIES_KHR, props->fragment_shading_rate, exts->KHR_fragment_shading_rate);
VN_ADD_PNEXT_EXT(props2, PUSH_DESCRIPTOR_PROPERTIES_KHR, props->push_descriptor, exts->KHR_push_descriptor);
VN_ADD_PNEXT_EXT(props2, FRAGMENT_SHADING_RATE_PROPERTIES_KHR, local_props.fragment_shading_rate, exts->KHR_fragment_shading_rate);
VN_ADD_PNEXT_EXT(props2, PUSH_DESCRIPTOR_PROPERTIES_KHR, local_props.push_descriptor, exts->KHR_push_descriptor);
/* EXT */
VN_ADD_PNEXT_EXT(props2, CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, props->conservative_rasterization, exts->EXT_conservative_rasterization);
VN_ADD_PNEXT_EXT(props2, CUSTOM_BORDER_COLOR_PROPERTIES_EXT, props->custom_border_color, exts->EXT_custom_border_color);
VN_ADD_PNEXT_EXT(props2, EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, props->extended_dynamic_state_3, exts->EXT_extended_dynamic_state3);
VN_ADD_PNEXT_EXT(props2, GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, props->graphics_pipeline_library, exts->EXT_graphics_pipeline_library);
VN_ADD_PNEXT_EXT(props2, LINE_RASTERIZATION_PROPERTIES_EXT, props->line_rasterization, exts->EXT_line_rasterization);
VN_ADD_PNEXT_EXT(props2, MULTI_DRAW_PROPERTIES_EXT, props->multi_draw, exts->EXT_multi_draw);
VN_ADD_PNEXT_EXT(props2, PCI_BUS_INFO_PROPERTIES_EXT, props->pci_bus_info, exts->EXT_pci_bus_info);
VN_ADD_PNEXT_EXT(props2, PROVOKING_VERTEX_PROPERTIES_EXT, props->provoking_vertex, exts->EXT_provoking_vertex);
VN_ADD_PNEXT_EXT(props2, ROBUSTNESS_2_PROPERTIES_EXT, props->robustness_2, exts->EXT_robustness2);
VN_ADD_PNEXT_EXT(props2, TRANSFORM_FEEDBACK_PROPERTIES_EXT, props->transform_feedback, exts->EXT_transform_feedback);
VN_ADD_PNEXT_EXT(props2, VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, props->vertex_attribute_divisor, exts->EXT_vertex_attribute_divisor);
VN_ADD_PNEXT_EXT(props2, CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, local_props.conservative_rasterization, exts->EXT_conservative_rasterization);
VN_ADD_PNEXT_EXT(props2, CUSTOM_BORDER_COLOR_PROPERTIES_EXT, local_props.custom_border_color, exts->EXT_custom_border_color);
VN_ADD_PNEXT_EXT(props2, EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, local_props.extended_dynamic_state_3, exts->EXT_extended_dynamic_state3);
VN_ADD_PNEXT_EXT(props2, GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, local_props.graphics_pipeline_library, exts->EXT_graphics_pipeline_library);
VN_ADD_PNEXT_EXT(props2, LINE_RASTERIZATION_PROPERTIES_EXT, local_props.line_rasterization, exts->EXT_line_rasterization);
VN_ADD_PNEXT_EXT(props2, MULTI_DRAW_PROPERTIES_EXT, local_props.multi_draw, exts->EXT_multi_draw);
VN_ADD_PNEXT_EXT(props2, PCI_BUS_INFO_PROPERTIES_EXT, local_props.pci_bus_info, exts->EXT_pci_bus_info);
VN_ADD_PNEXT_EXT(props2, PROVOKING_VERTEX_PROPERTIES_EXT, local_props.provoking_vertex, exts->EXT_provoking_vertex);
VN_ADD_PNEXT_EXT(props2, ROBUSTNESS_2_PROPERTIES_EXT, local_props.robustness_2, exts->EXT_robustness2);
VN_ADD_PNEXT_EXT(props2, TRANSFORM_FEEDBACK_PROPERTIES_EXT, local_props.transform_feedback, exts->EXT_transform_feedback);
VN_ADD_PNEXT_EXT(props2, VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, local_props.vertex_attribute_divisor, exts->EXT_vertex_attribute_divisor);
/* clang-format on */
@ -563,181 +581,111 @@ vn_physical_device_init_properties(struct vn_physical_device *physical_dev)
instance->ring.ring, vn_physical_device_to_handle(physical_dev),
&props2);
VkPhysicalDeviceProperties *vk10_props = &props->vulkan_1_0;
VkPhysicalDeviceVulkan11Properties *vk11_props = &props->vulkan_1_1;
VkPhysicalDeviceVulkan12Properties *vk12_props = &props->vulkan_1_2;
VkPhysicalDeviceVulkan13Properties *vk13_props = &props->vulkan_1_3;
*vk10_props = props2.properties;
/* clang-format off */
/* Vulkan 1.0 */
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &props2);
if (renderer_version < VK_API_VERSION_1_2) {
/* Vulkan 1.1 */
VN_SET_CORE_ARRAY(vk11_props, deviceUUID, local_props.id);
VN_SET_CORE_ARRAY(vk11_props, driverUUID, local_props.id);
VN_SET_CORE_ARRAY(vk11_props, deviceLUID, local_props.id);
VN_SET_CORE_FIELD(vk11_props, deviceNodeMask, local_props.id);
VN_SET_CORE_FIELD(vk11_props, deviceLUIDValid, local_props.id);
/* Cannot use macro because names differ. */
vk11_props->subgroupSize = local_props.subgroup.subgroupSize;
vk11_props->subgroupSupportedStages = local_props.subgroup.supportedStages;
vk11_props->subgroupSupportedOperations = local_props.subgroup.supportedOperations;
vk11_props->subgroupQuadOperationsInAllStages = local_props.subgroup.quadOperationsInAllStages;
VN_SET_CORE_FIELD(vk11_props, pointClippingBehavior, local_props.point_clipping);
VN_SET_CORE_FIELD(vk11_props, maxMultiviewViewCount, local_props.multiview);
VN_SET_CORE_FIELD(vk11_props, maxMultiviewInstanceIndex, local_props.multiview);
VN_SET_CORE_FIELD(vk11_props, protectedNoFault, local_props.protected_memory);
VN_SET_CORE_FIELD(vk11_props, maxPerSetDescriptors, local_props.maintenance_3);
VN_SET_CORE_FIELD(vk11_props, maxMemoryAllocationSize, local_props.maintenance_3);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.id);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.subgroup);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.point_clipping);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.multiview);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.protected_memory);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.maintenance_3);
/* Vulkan 1.2 */
if (exts->KHR_driver_properties) {
VN_SET_CORE_FIELD(vk12_props, driverID, local_props.driver);
VN_SET_CORE_ARRAY(vk12_props, driverName, local_props.driver);
VN_SET_CORE_ARRAY(vk12_props, driverInfo, local_props.driver);
VN_SET_CORE_FIELD(vk12_props, conformanceVersion, local_props.driver);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.driver);
}
if (exts->KHR_shader_float_controls) {
VN_SET_CORE_FIELD(vk12_props, denormBehaviorIndependence, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, roundingModeIndependence, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderSignedZeroInfNanPreserveFloat16, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderSignedZeroInfNanPreserveFloat32, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderSignedZeroInfNanPreserveFloat64, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormPreserveFloat16, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormPreserveFloat32, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormPreserveFloat64, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormFlushToZeroFloat16, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormFlushToZeroFloat32, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderDenormFlushToZeroFloat64, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTEFloat16, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTEFloat32, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTEFloat64, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTZFloat16, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTZFloat32, local_props.float_controls);
VN_SET_CORE_FIELD(vk12_props, shaderRoundingModeRTZFloat64, local_props.float_controls);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.float_controls);
}
if (exts->EXT_descriptor_indexing) {
VN_SET_CORE_FIELD(vk12_props, maxUpdateAfterBindDescriptorsInAllPools, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, shaderUniformBufferArrayNonUniformIndexingNative, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, shaderSampledImageArrayNonUniformIndexingNative, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, shaderStorageBufferArrayNonUniformIndexingNative, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, shaderStorageImageArrayNonUniformIndexingNative, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, shaderInputAttachmentArrayNonUniformIndexingNative, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, robustBufferAccessUpdateAfterBind, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, quadDivergentImplicitLod, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindSamplers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindUniformBuffers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindStorageBuffers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindSampledImages, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindStorageImages, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageDescriptorUpdateAfterBindInputAttachments, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxPerStageUpdateAfterBindResources, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindSamplers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindUniformBuffers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindStorageBuffers, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindSampledImages, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindStorageImages, local_props.descriptor_indexing);
VN_SET_CORE_FIELD(vk12_props, maxDescriptorSetUpdateAfterBindInputAttachments, local_props.descriptor_indexing);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.descriptor_indexing);
}
if (exts->KHR_depth_stencil_resolve) {
VN_SET_CORE_FIELD(vk12_props, supportedDepthResolveModes, local_props.depth_stencil_resolve);
VN_SET_CORE_FIELD(vk12_props, supportedStencilResolveModes, local_props.depth_stencil_resolve);
VN_SET_CORE_FIELD(vk12_props, independentResolveNone, local_props.depth_stencil_resolve);
VN_SET_CORE_FIELD(vk12_props, independentResolve, local_props.depth_stencil_resolve);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.depth_stencil_resolve);
}
if (exts->EXT_sampler_filter_minmax) {
VN_SET_CORE_FIELD(vk12_props, filterMinmaxSingleComponentFormats, local_props.sampler_filter_minmax);
VN_SET_CORE_FIELD(vk12_props, filterMinmaxImageComponentMapping, local_props.sampler_filter_minmax);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.sampler_filter_minmax);
}
if (exts->KHR_timeline_semaphore) {
VN_SET_CORE_FIELD(vk12_props, maxTimelineSemaphoreValueDifference, local_props.timeline_semaphore);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.timeline_semaphore);
}
} else {
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.vulkan_1_1);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.vulkan_1_2);
}
/* Vulkan 1.3 */
if (renderer_version < VK_API_VERSION_1_3) {
if (exts->EXT_subgroup_size_control) {
VN_SET_CORE_FIELD(vk13_props, minSubgroupSize, local_props.subgroup_size_control);
VN_SET_CORE_FIELD(vk13_props, maxSubgroupSize, local_props.subgroup_size_control);
VN_SET_CORE_FIELD(vk13_props, maxComputeWorkgroupSubgroups, local_props.subgroup_size_control);
VN_SET_CORE_FIELD(vk13_props, requiredSubgroupSizeStages, local_props.subgroup_size_control);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.subgroup_size_control);
}
if (exts->EXT_inline_uniform_block) {
VN_SET_CORE_FIELD(vk13_props, maxInlineUniformBlockSize, local_props.inline_uniform_block);
VN_SET_CORE_FIELD(vk13_props, maxPerStageDescriptorInlineUniformBlocks, local_props.inline_uniform_block);
VN_SET_CORE_FIELD(vk13_props, maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, local_props.inline_uniform_block);
VN_SET_CORE_FIELD(vk13_props, maxDescriptorSetInlineUniformBlocks, local_props.inline_uniform_block);
VN_SET_CORE_FIELD(vk13_props, maxDescriptorSetUpdateAfterBindInlineUniformBlocks, local_props.inline_uniform_block);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.inline_uniform_block);
}
if (exts->KHR_shader_integer_dot_product) {
VN_SET_CORE_FIELD(vk13_props, integerDotProduct8BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct8BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct8BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct4x8BitPackedUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct4x8BitPackedSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct4x8BitPackedMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct16BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct16BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct16BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct32BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct32BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct32BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct64BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct64BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProduct64BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating8BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating16BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating32BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating64BitSignedAccelerated, local_props.shader_integer_dot_product);
VN_SET_CORE_FIELD(vk13_props, integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, local_props.shader_integer_dot_product);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.shader_integer_dot_product);
}
if (exts->EXT_texel_buffer_alignment) {
VN_SET_CORE_FIELD(vk13_props, storageTexelBufferOffsetAlignmentBytes, local_props.texel_buffer_alignment);
VN_SET_CORE_FIELD(vk13_props, storageTexelBufferOffsetSingleTexelAlignment, local_props.texel_buffer_alignment);
VN_SET_CORE_FIELD(vk13_props, uniformTexelBufferOffsetAlignmentBytes, local_props.texel_buffer_alignment);
VN_SET_CORE_FIELD(vk13_props, uniformTexelBufferOffsetSingleTexelAlignment, local_props.texel_buffer_alignment);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.texel_buffer_alignment);
}
if (exts->KHR_maintenance4) {
VN_SET_CORE_FIELD(vk13_props, maxBufferSize, local_props.maintenance4);
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.maintenance4);
}
} else {
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.vulkan_1_3);
}
/* clang-format on */
/* KHR */
if (exts->KHR_fragment_shading_rate)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.fragment_shading_rate);
if (exts->KHR_push_descriptor)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.push_descriptor);
/* EXT */
if (exts->EXT_conservative_rasterization)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.conservative_rasterization);
if (exts->EXT_custom_border_color)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.custom_border_color);
if (exts->EXT_extended_dynamic_state3)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.extended_dynamic_state_3);
if (exts->EXT_graphics_pipeline_library)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.graphics_pipeline_library);
if (exts->EXT_line_rasterization)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.line_rasterization);
if (exts->EXT_multi_draw)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.multi_draw);
if (exts->EXT_pci_bus_info)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.pci_bus_info);
if (exts->EXT_provoking_vertex)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.provoking_vertex);
if (exts->EXT_robustness2)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.robustness_2);
if (exts->EXT_transform_feedback)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.transform_feedback);
if (exts->EXT_vertex_attribute_divisor)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &local_props.vertex_attribute_divisor);
/* initialize native properties */
const struct vn_renderer_info *info =
&physical_dev->instance->renderer->info;
/* VK_EXT_physical_device_drm */
const VkPhysicalDeviceDrmPropertiesEXT *drm = &info->drm.props;
vk_copy_struct_guts((VkBaseOutStructure *)&props->drm,
(VkBaseInStructure *)drm, sizeof(*drm));
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &renderer_info->drm.props);
/* VK_EXT_pci_bus_info */
if (info->pci.has_bus_info) {
/* this is used by WSI */
const VkPhysicalDevicePCIBusInfoPropertiesEXT *pci = &info->pci.props;
vk_copy_struct_guts((VkBaseOutStructure *)&props->pci_bus_info,
(VkBaseInStructure *)pci, sizeof(*pci));
}
if (renderer_info->pci.has_bus_info)
vk_set_physical_device_properties_struct(props, (VkBaseInStructure *) &renderer_info->pci.props);
#if DETECT_OS_ANDROID
/* VK_ANDROID_native_buffer */
if (vn_android_gralloc_get_shared_present_usage())
VN_SET_CORE_VALUE(&props->presentation, sharedImage, VK_TRUE);
props->sharedImage = true;
#endif
/* clang-format on */
vn_physical_device_sanitize_properties(physical_dev);
}
@ -1822,72 +1770,6 @@ vn_physical_device_add_format_properties(
simple_mtx_unlock(&physical_dev->format_update_mutex);
}
void
vn_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2 *pProperties)
{
struct vn_physical_device *physical_dev =
vn_physical_device_from_handle(physicalDevice);
const struct vn_physical_device_properties *in_props =
&physical_dev->properties;
pProperties->properties = in_props->vulkan_1_0;
vk_foreach_struct(out, pProperties->pNext) {
if (vk_get_physical_device_core_1_1_property_ext(out,
&in_props->vulkan_1_1))
continue;
if (vk_get_physical_device_core_1_2_property_ext(out,
&in_props->vulkan_1_2))
continue;
if (vk_get_physical_device_core_1_3_property_ext(out,
&in_props->vulkan_1_3))
continue;
/* Cast to avoid warnings for values outside VkStructureType. */
switch ((int32_t)out->sType) {
#define CASE(stype, member) \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_##stype: \
vk_copy_struct_guts(out, (VkBaseInStructure *)&in_props->member, \
sizeof(in_props->member)); \
break
/* clang-format off */
/* KHR */
CASE(FRAGMENT_SHADING_RATE_PROPERTIES_KHR, fragment_shading_rate);
CASE(PUSH_DESCRIPTOR_PROPERTIES_KHR, push_descriptor);
/* EXT */
CASE(CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, conservative_rasterization);
CASE(CUSTOM_BORDER_COLOR_PROPERTIES_EXT, custom_border_color);
CASE(DRM_PROPERTIES_EXT, drm);
CASE(EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, extended_dynamic_state_3);
CASE(GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, graphics_pipeline_library);
CASE(LINE_RASTERIZATION_PROPERTIES_EXT, line_rasterization);
CASE(MULTI_DRAW_PROPERTIES_EXT, multi_draw);
CASE(PCI_BUS_INFO_PROPERTIES_EXT, pci_bus_info);
CASE(PROVOKING_VERTEX_PROPERTIES_EXT, provoking_vertex);
CASE(ROBUSTNESS_2_PROPERTIES_EXT, robustness_2);
CASE(TRANSFORM_FEEDBACK_PROPERTIES_EXT, transform_feedback);
CASE(VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, vertex_attribute_divisor);
/* ANDROID */
CASE(PRESENTATION_PROPERTIES_ANDROID, presentation);
default:
break;
/* clang-format on */
#undef CASE
}
}
}
void
vn_GetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice,

30
src/virtio/vulkan/vn_physical_device.h
View File

@ -17,35 +17,6 @@
#include "vn_wsi.h"
struct vn_physical_device_properties {
VkPhysicalDeviceProperties vulkan_1_0;
VkPhysicalDeviceVulkan11Properties vulkan_1_1;
VkPhysicalDeviceVulkan12Properties vulkan_1_2;
VkPhysicalDeviceVulkan13Properties vulkan_1_3;
/* KHR */
VkPhysicalDeviceFragmentShadingRatePropertiesKHR fragment_shading_rate;
VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor;
/* EXT */
VkPhysicalDeviceConservativeRasterizationPropertiesEXT
conservative_rasterization;
VkPhysicalDeviceCustomBorderColorPropertiesEXT custom_border_color;
VkPhysicalDeviceDrmPropertiesEXT drm;
VkPhysicalDeviceExtendedDynamicState3PropertiesEXT extended_dynamic_state_3;
VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
graphics_pipeline_library;
VkPhysicalDeviceLineRasterizationPropertiesEXT line_rasterization;
VkPhysicalDeviceMultiDrawPropertiesEXT multi_draw;
VkPhysicalDevicePCIBusInfoPropertiesEXT pci_bus_info;
VkPhysicalDevicePresentationPropertiesANDROID presentation;
VkPhysicalDeviceProvokingVertexPropertiesEXT provoking_vertex;
VkPhysicalDeviceRobustness2PropertiesEXT robustness_2;
VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback;
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
vertex_attribute_divisor;
};
struct vn_format_properties_entry {
atomic_bool valid;
VkFormatProperties properties;
@ -102,7 +73,6 @@ struct vn_physical_device {
struct vk_device_extension_table renderer_extensions;
uint32_t *extension_spec_versions;
struct vn_physical_device_properties properties;
enum VkDriverId renderer_driver_id;
VkQueueFamilyProperties2 *queue_family_properties;

3
src/virtio/vulkan/vn_pipeline.c
View File

@ -496,8 +496,7 @@ vn_GetPipelineCacheData(VkDevice device,
return VK_INCOMPLETE;
}
const VkPhysicalDeviceProperties *props =
&physical_dev->properties.vulkan_1_0;
const struct vk_properties *props = &physical_dev->base.base.properties;
header->header_size = sizeof(*header);
header->header_version = VK_PIPELINE_CACHE_HEADER_VERSION_ONE;
header->vendor_id = props->vendorID;