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

panvk: Fix GetPhysicalDeviceProperties2() to report accurate info

Browse source 
Fix GetPhysicalDeviceProperties2 to report accurate information, and
add comment explaining the reasoning behind the new limits.

While at it, stop using the MAX_xxx definitions since some of them
will be per-gen, and this file is not.

Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
Acked-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/28104>
This commit is contained in:
Boris Brezillon 2024-02-01 18:06:43 +01:00
parent 783172add3
commit d5ed77800e
2 changed files with 209 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

300
src/panfrost/vulkan/panvk_device.c
View file

@ -556,137 +556,255 @@ panvk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
{ {
VK_FROM_HANDLE(panvk_physical_device, pdevice, physicalDevice); VK_FROM_HANDLE(panvk_physical_device, pdevice, physicalDevice);
/* HW supports MSAA 4, 8 and 16, but we limit ourselves to MSAA 4 for now. */
VkSampleCountFlags sample_counts = VkSampleCountFlags sample_counts =
VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
/* make sure that the entire descriptor set is addressable with a signed
* 32-bit int. So the sum of all limits scaled by descriptor size has to
* be at most 2 GiB. the combined image & samples object count as one of
* both. This limit is for the pipeline layout, not for the set layout, but
* there is no set limit, so we just set a pipeline limit. I don't think
* any app is going to hit this soon. */
size_t max_descriptor_set_size =
((1ull << 31) - 16 * MAX_DYNAMIC_BUFFERS) /
(32 /* uniform buffer, 32 due to potential space wasted on alignment */ +
32 /* storage buffer, 32 due to potential space wasted on alignment */ +
32 /* sampler, largest when combined with image */ +
64 /* sampled image */ + 64 /* storage image */);
const VkPhysicalDeviceLimits limits = { const VkPhysicalDeviceLimits limits = {
.maxImageDimension1D = (1 << 14), /* Maximum texture dimension is 2^16. */
.maxImageDimension2D = (1 << 14), .maxImageDimension1D = (1 << 16),
.maxImageDimension3D = (1 << 11), .maxImageDimension2D = (1 << 16),
.maxImageDimensionCube = (1 << 14), .maxImageDimension3D = (1 << 16),
.maxImageArrayLayers = (1 << 11), .maxImageDimensionCube = (1 << 16),
.maxTexelBufferElements = 128 * 1024 * 1024, .maxImageArrayLayers = (1 << 16),
.maxUniformBufferRange = UINT32_MAX,
/* Currently limited by the 1D texture size, which is 2^16.
* TODO: If we expose buffer views as 2D textures, we can increase the
* limit.
*/
.maxTexelBufferElements = (1 << 16),
/* Each uniform entry is 16-byte and the number of entries is encoded in a
* 12-bit field, with the minus(1) modifier, which gives 2^20.
*/
.maxUniformBufferRange = 1 << 20,
/* Storage buffer access is lowered to globals, so there's no limit here,
* except for the SW-descriptor we use to encode storage buffer
* descriptors, where the size is a 32-bit field.
*/
.maxStorageBufferRange = UINT32_MAX, .maxStorageBufferRange = UINT32_MAX,
.maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE,
/* 128 bytes of push constants, so we're aligned with the minimum Vulkan
* requirements.
*/
.maxPushConstantsSize = 128,
/* There's no HW limit here. Should we advertize something smaller? */
.maxMemoryAllocationCount = UINT32_MAX, .maxMemoryAllocationCount = UINT32_MAX,
/* Again, no hardware limit, but most drivers seem to advertive 64k. */
.maxSamplerAllocationCount = 64 * 1024, .maxSamplerAllocationCount = 64 * 1024,
.bufferImageGranularity = 64, /* A cache line */
.sparseAddressSpaceSize = 0xffffffffu, /* buffer max size */ /* A cache line. */
.maxBoundDescriptorSets = MAX_SETS, .bufferImageGranularity = 64,
.maxPerStageDescriptorSamplers = max_descriptor_set_size,
.maxPerStageDescriptorUniformBuffers = max_descriptor_set_size, /* Sparse binding not supported yet. */
.maxPerStageDescriptorStorageBuffers = max_descriptor_set_size, .sparseAddressSpaceSize = 0,
.maxPerStageDescriptorSampledImages = max_descriptor_set_size,
.maxPerStageDescriptorStorageImages = max_descriptor_set_size, /* Software limit. Pick the minimum required by Vulkan, because Bifrost
.maxPerStageDescriptorInputAttachments = max_descriptor_set_size, * GPUs don't have unified descriptor tables, which forces us to
.maxPerStageResources = max_descriptor_set_size, * agregatte all descriptors from all sets and dispatch them to per-type
.maxDescriptorSetSamplers = max_descriptor_set_size, * descriptor tables emitted at draw/dispatch time.
.maxDescriptorSetUniformBuffers = max_descriptor_set_size, * The more sets we support the more copies we are likely to have to do
.maxDescriptorSetUniformBuffersDynamic = MAX_DYNAMIC_UNIFORM_BUFFERS, * at draw time.
.maxDescriptorSetStorageBuffers = max_descriptor_set_size, */
.maxDescriptorSetStorageBuffersDynamic = MAX_DYNAMIC_STORAGE_BUFFERS, .maxBoundDescriptorSets = 4,
.maxDescriptorSetSampledImages = max_descriptor_set_size,
.maxDescriptorSetStorageImages = max_descriptor_set_size, /* MALI_RENDERER_STATE::sampler_count is 16-bit. */
.maxDescriptorSetInputAttachments = max_descriptor_set_size, .maxPerStageDescriptorSamplers = UINT16_MAX,
.maxVertexInputAttributes = 32, .maxDescriptorSetSamplers = UINT16_MAX,
.maxVertexInputBindings = 32,
.maxVertexInputAttributeOffset = 2047, /* MALI_RENDERER_STATE::uniform_buffer_count is 8-bit. We reserve 32 slots
.maxVertexInputBindingStride = 2048, * for our internal UBOs.
*/
.maxPerStageDescriptorUniformBuffers = UINT8_MAX - 32,
.maxDescriptorSetUniformBuffers = UINT8_MAX - 32,
/* SSBOs are limited by the size of a uniform buffer which contains our
* panvk_ssbo_desc objects.
* panvk_ssbo_desc is 16-byte, and each uniform entry in the Mali UBO is
* 16-byte too. The number of entries is encoded in a 12-bit field, with
* a minus(1) modifier, which gives a maximum of 2^12 SSBO
* descriptors.
*/
.maxPerStageDescriptorStorageBuffers = 1 << 12,
.maxDescriptorSetStorageBuffers = 1 << 12,
/* MALI_RENDERER_STATE::sampler_count is 16-bit. */
.maxPerStageDescriptorSampledImages = UINT16_MAX,
.maxDescriptorSetSampledImages = UINT16_MAX,
/* MALI_ATTRIBUTE::buffer_index is 9-bit, and each image takes two
* MALI_ATTRIBUTE_BUFFER slots, which gives a maximum of (1 << 8) images.
*/
.maxPerStageDescriptorStorageImages = 1 << 8,
.maxDescriptorSetStorageImages = 1 << 8,
/* A maximum of 8 color render targets, and one depth-stencil render
* target.
*/
.maxPerStageDescriptorInputAttachments = 9,
.maxDescriptorSetInputAttachments = 9,
/* Could be the sum of all maxPerStageXxx values, but we limit ourselves
* to 2^16 to make things simpler.
*/
.maxPerStageResources = 1 << 16,
/* Software limits to keep VkCommandBuffer tracking sane. */
.maxDescriptorSetUniformBuffersDynamic = 16,
.maxDescriptorSetStorageBuffersDynamic = 8,
/* Software limit to keep VkCommandBuffer tracking sane. The HW supports
* up to 2^9 vertex attributes.
*/
.maxVertexInputAttributes = 16,
.maxVertexInputBindings = 16,
/* MALI_ATTRIBUTE::offset is 32-bit. */
.maxVertexInputAttributeOffset = UINT32_MAX,
/* MALI_ATTRIBUTE_BUFFER::stride is 32-bit. */
.maxVertexInputBindingStride = UINT32_MAX,
/* 32 vec4 varyings. */
.maxVertexOutputComponents = 128, .maxVertexOutputComponents = 128,
.maxTessellationGenerationLevel = 64,
.maxTessellationPatchSize = 32, /* Tesselation shaders not supported. */
.maxTessellationControlPerVertexInputComponents = 128, .maxTessellationGenerationLevel = 0,
.maxTessellationControlPerVertexOutputComponents = 128, .maxTessellationPatchSize = 0,
.maxTessellationControlPerPatchOutputComponents = 120, .maxTessellationControlPerVertexInputComponents = 0,
.maxTessellationControlTotalOutputComponents = 4096, .maxTessellationControlPerVertexOutputComponents = 0,
.maxTessellationEvaluationInputComponents = 128, .maxTessellationControlPerPatchOutputComponents = 0,
.maxTessellationEvaluationOutputComponents = 128, .maxTessellationControlTotalOutputComponents = 0,
.maxGeometryShaderInvocations = 127, .maxTessellationEvaluationInputComponents = 0,
.maxGeometryInputComponents = 64, .maxTessellationEvaluationOutputComponents = 0,
.maxGeometryOutputComponents = 128,
.maxGeometryOutputVertices = 256, /* Geometry shaders not supported. */
.maxGeometryTotalOutputComponents = 1024, .maxGeometryShaderInvocations = 0,
.maxGeometryInputComponents = 0,
.maxGeometryOutputComponents = 0,
.maxGeometryOutputVertices = 0,
.maxGeometryTotalOutputComponents = 0,
/* 32 vec4 varyings. */
.maxFragmentInputComponents = 128, .maxFragmentInputComponents = 128,
/* 8 render targets. */
.maxFragmentOutputAttachments = 8, .maxFragmentOutputAttachments = 8,
.maxFragmentDualSrcAttachments = 1,
.maxFragmentCombinedOutputResources = /* We don't support dual source blending yet. */
MAX_RTS + max_descriptor_set_size * 2, .maxFragmentDualSrcAttachments = 0,
/* 8 render targets, 2^12 storage buffers and 2^8 storage images (see
* above).
*/
.maxFragmentCombinedOutputResources = 8 + (1 << 12) + (1 << 8),
/* MALI_LOCAL_STORAGE::wls_size_{base,scale} allows us to have up to
* (7 << 30) bytes of shared memory, but we cap it to 32K as it doesn't
* really make sense to expose this amount of memory, especially since
* it's backed by global memory anyway.
*/
.maxComputeSharedMemorySize = 32768, .maxComputeSharedMemorySize = 32768,
/* Software limit to meet Vulkan 1.0 requirements. We split the
* dispatch in several jobs if it's too big.
*/
.maxComputeWorkGroupCount = {65535, 65535, 65535}, .maxComputeWorkGroupCount = {65535, 65535, 65535},
.maxComputeWorkGroupInvocations = 2048,
.maxComputeWorkGroupSize = {2048, 2048, 2048}, /* We have 10 bits to encode the local-size, and there's a minus(1)
.subPixelPrecisionBits = 4 /* FIXME */, * modifier, so, a size of 1 takes no bit.
.subTexelPrecisionBits = 4 /* FIXME */, */
.mipmapPrecisionBits = 4 /* FIXME */, .maxComputeWorkGroupInvocations = 1 << 10,
.maxComputeWorkGroupSize = {1 << 10, 1 << 10, 1 << 10},
/* 8-bit subpixel precision. */
.subPixelPrecisionBits = 8,
.subTexelPrecisionBits = 8,
.mipmapPrecisionBits = 8,
/* Software limit. */
.maxDrawIndexedIndexValue = UINT32_MAX, .maxDrawIndexedIndexValue = UINT32_MAX,
.maxDrawIndirectCount = UINT32_MAX,
.maxSamplerLodBias = 16, /* Make it one for now. */
.maxDrawIndirectCount = 1,
.maxSamplerLodBias = 255,
.maxSamplerAnisotropy = 16, .maxSamplerAnisotropy = 16,
.maxViewports = MAX_VIEWPORTS, .maxViewports = 1,
/* Same as the framebuffer limit. */
.maxViewportDimensions = {(1 << 14), (1 << 14)}, .maxViewportDimensions = {(1 << 14), (1 << 14)},
/* Encoded in a 16-bit signed integer. */
.viewportBoundsRange = {INT16_MIN, INT16_MAX}, .viewportBoundsRange = {INT16_MIN, INT16_MAX},
.viewportSubPixelBits = 8, .viewportSubPixelBits = 0,
.minMemoryMapAlignment = 4096, /* A page */
/* Align on a page. */
.minMemoryMapAlignment = 4096,
/* Some compressed texture formats require 128-byte alignment. */
.minTexelBufferOffsetAlignment = 64, .minTexelBufferOffsetAlignment = 64,
/* Always aligned on a uniform slot (vec4). */
.minUniformBufferOffsetAlignment = 16, .minUniformBufferOffsetAlignment = 16,
/* Lowered to global accesses, which happen at the 32-bit granularity. */
.minStorageBufferOffsetAlignment = 4, .minStorageBufferOffsetAlignment = 4,
.minTexelOffset = -32,
.maxTexelOffset = 31, /* Signed 4-bit value. */
.minTexelGatherOffset = -32, .minTexelOffset = -8,
.maxTexelGatherOffset = 31, .maxTexelOffset = 7,
.minInterpolationOffset = -2, .minTexelGatherOffset = -8,
.maxInterpolationOffset = 2, .maxTexelGatherOffset = 7,
.minInterpolationOffset = -0.5,
.maxInterpolationOffset = 0.5,
.subPixelInterpolationOffsetBits = 8, .subPixelInterpolationOffsetBits = 8,
.maxFramebufferWidth = (1 << 14), .maxFramebufferWidth = (1 << 14),
.maxFramebufferHeight = (1 << 14), .maxFramebufferHeight = (1 << 14),
.maxFramebufferLayers = (1 << 10), .maxFramebufferLayers = 256,
.framebufferColorSampleCounts = sample_counts, .framebufferColorSampleCounts = sample_counts,
.framebufferDepthSampleCounts = sample_counts, .framebufferDepthSampleCounts = sample_counts,
.framebufferStencilSampleCounts = sample_counts, .framebufferStencilSampleCounts = sample_counts,
.framebufferNoAttachmentsSampleCounts = sample_counts, .framebufferNoAttachmentsSampleCounts = sample_counts,
.maxColorAttachments = MAX_RTS, .maxColorAttachments = 8,
.sampledImageColorSampleCounts = sample_counts, .sampledImageColorSampleCounts = sample_counts,
.sampledImageIntegerSampleCounts = VK_SAMPLE_COUNT_1_BIT, .sampledImageIntegerSampleCounts = VK_SAMPLE_COUNT_1_BIT,
.sampledImageDepthSampleCounts = sample_counts, .sampledImageDepthSampleCounts = sample_counts,
.sampledImageStencilSampleCounts = sample_counts, .sampledImageStencilSampleCounts = sample_counts,
.storageImageSampleCounts = VK_SAMPLE_COUNT_1_BIT, .storageImageSampleCounts = VK_SAMPLE_COUNT_1_BIT,
.maxSampleMaskWords = 1, .maxSampleMaskWords = 1,
.timestampComputeAndGraphics = true, .timestampComputeAndGraphics = false,
.timestampPeriod = 1, .timestampPeriod = 0,
.maxClipDistances = 8, .maxClipDistances = 0,
.maxCullDistances = 8, .maxCullDistances = 0,
.maxCombinedClipAndCullDistances = 8, .maxCombinedClipAndCullDistances = 0,
.discreteQueuePriorities = 1, .discreteQueuePriorities = 1,
.pointSizeRange = {0.125, 4095.9375}, .pointSizeRange = {0.125, 4095.9375},
.lineWidthRange = {0.0, 7.9921875}, .lineWidthRange = {0.0, 7.9921875},
.pointSizeGranularity = (1.0 / 16.0), .pointSizeGranularity = (1.0 / 16.0),
.lineWidthGranularity = (1.0 / 128.0), .lineWidthGranularity = (1.0 / 128.0),
.strictLines = false, /* FINISHME */ .strictLines = false,
.standardSampleLocations = true, .standardSampleLocations = true,
.optimalBufferCopyOffsetAlignment = 128, .optimalBufferCopyOffsetAlignment = 64,
.optimalBufferCopyRowPitchAlignment = 128, .optimalBufferCopyRowPitchAlignment = 64,
.nonCoherentAtomSize = 64, .nonCoherentAtomSize = 64,
}; };
pProperties->properties = (VkPhysicalDeviceProperties){ pProperties->properties = (VkPhysicalDeviceProperties){
.apiVersion = PANVK_API_VERSION, .apiVersion = PANVK_API_VERSION,
.driverVersion = vk_get_driver_version(), .driverVersion = vk_get_driver_version(),
.vendorID = 0, /* TODO */
.deviceID = 0, /* Arm vendor ID. */
.vendorID = 0x13b5,
/* Collect arch_major, arch_minor, arch_rev and product_major,
* as done by the Arm driver.
*/
.deviceID = pdevice->kmod.props.gpu_prod_id << 16,
.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
.limits = limits, .limits = limits,
.sparseProperties = {0}, .sparseProperties = {0},
@ -732,14 +850,14 @@ panvk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
VkPhysicalDevicePushDescriptorPropertiesKHR *properties = VkPhysicalDevicePushDescriptorPropertiesKHR *properties =
(VkPhysicalDevicePushDescriptorPropertiesKHR *)ext; (VkPhysicalDevicePushDescriptorPropertiesKHR *)ext;
properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS; properties->maxPushDescriptors = 0;
break; break;
} }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *properties = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *properties =
(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)ext; (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)ext;
/* We have to restrict this a bit for multiview */ /* We will have to restrict this a bit for multiview */
properties->maxVertexAttribDivisor = UINT32_MAX / (16 * 2048); properties->maxVertexAttribDivisor = UINT32_MAX;
break; break;
} }
default: default:
@ -752,7 +870,7 @@ static const VkQueueFamilyProperties panvk_queue_family_properties = {
.queueFlags = .queueFlags =
VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT,
.queueCount = 1, .queueCount = 1,
.timestampValidBits = 64, .timestampValidBits = 0,
.minImageTransferGranularity = {1, 1, 1}, .minImageTransferGranularity = {1, 1, 1},
}; };

2
src/panfrost/vulkan/panvk_private.h
View file

@ -98,11 +98,9 @@ typedef uint32_t xcb_window_t;
#define MAX_VERTEX_ATTRIBS 16 #define MAX_VERTEX_ATTRIBS 16
#define MAX_RTS 8 #define MAX_RTS 8
#define MAX_VSC_PIPES 32 #define MAX_VSC_PIPES 32
#define MAX_VIEWPORTS 1
#define MAX_SCISSORS 16 #define MAX_SCISSORS 16
#define MAX_DISCARD_RECTANGLES 4 #define MAX_DISCARD_RECTANGLES 4
#define MAX_PUSH_CONSTANTS_SIZE 128 #define MAX_PUSH_CONSTANTS_SIZE 128
#define MAX_PUSH_DESCRIPTORS 32
#define MAX_DYNAMIC_UNIFORM_BUFFERS 16 #define MAX_DYNAMIC_UNIFORM_BUFFERS 16
#define MAX_DYNAMIC_STORAGE_BUFFERS 8 #define MAX_DYNAMIC_STORAGE_BUFFERS 8
#define MAX_DYNAMIC_BUFFERS \ #define MAX_DYNAMIC_BUFFERS \