1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2015 Google Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Api Feature Query tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktApiFeatureInfo.hpp"
25
26 #include "vktTestCaseUtil.hpp"
27 #include "vktTestGroupUtil.hpp"
28 #include "vktCustomInstancesDevices.hpp"
29
30 #include "vkPlatform.hpp"
31 #include "vkStrUtil.hpp"
32 #include "vkRef.hpp"
33 #include "vkRefUtil.hpp"
34 #include "vkDeviceUtil.hpp"
35 #include "vkQueryUtil.hpp"
36 #include "vkImageUtil.hpp"
37 #include "vkApiVersion.hpp"
38
39 #include "tcuTestLog.hpp"
40 #include "tcuFormatUtil.hpp"
41 #include "tcuTextureUtil.hpp"
42 #include "tcuResultCollector.hpp"
43 #include "tcuCommandLine.hpp"
44
45 #include "deUniquePtr.hpp"
46 #include "deString.h"
47 #include "deStringUtil.hpp"
48 #include "deSTLUtil.hpp"
49 #include "deMemory.h"
50 #include "deMath.h"
51
52 #include <vector>
53 #include <set>
54 #include <string>
55 #include <limits>
56
57 namespace vkt
58 {
59 namespace api
60 {
61 namespace
62 {
63
64 #include "vkApiExtensionDependencyInfo.inl"
65
66 using namespace vk;
67 using std::vector;
68 using std::set;
69 using std::string;
70 using tcu::TestLog;
71 using tcu::ScopedLogSection;
72
73 const deUint32 DEUINT32_MAX = std::numeric_limits<deUint32>::max();
74
75 enum
76 {
77 GUARD_SIZE = 0x20, //!< Number of bytes to check
78 GUARD_VALUE = 0xcd, //!< Data pattern
79 };
80
81 static const VkDeviceSize MINIMUM_REQUIRED_IMAGE_RESOURCE_SIZE = (1LLU<<31); //!< Minimum value for VkImageFormatProperties::maxResourceSize (2GiB)
82
83 enum LimitFormat
84 {
85 LIMIT_FORMAT_SIGNED_INT,
86 LIMIT_FORMAT_UNSIGNED_INT,
87 LIMIT_FORMAT_FLOAT,
88 LIMIT_FORMAT_DEVICE_SIZE,
89 LIMIT_FORMAT_BITMASK,
90
91 LIMIT_FORMAT_LAST
92 };
93
94 enum LimitType
95 {
96 LIMIT_TYPE_MIN,
97 LIMIT_TYPE_MAX,
98 LIMIT_TYPE_NONE,
99
100 LIMIT_TYPE_LAST
101 };
102
103 #define LIMIT(_X_) DE_OFFSET_OF(VkPhysicalDeviceLimits, _X_), (const char*)(#_X_)
104 #define FEATURE(_X_) DE_OFFSET_OF(VkPhysicalDeviceFeatures, _X_)
105
validateFeatureLimits(VkPhysicalDeviceProperties * properties,VkPhysicalDeviceFeatures * features,TestLog & log)106 bool validateFeatureLimits(VkPhysicalDeviceProperties* properties, VkPhysicalDeviceFeatures* features, TestLog& log)
107 {
108 bool limitsOk = true;
109 VkPhysicalDeviceLimits* limits = &properties->limits;
110 deUint32 shaderStages = 3;
111 deUint32 maxPerStageResourcesMin = deMin32(128, limits->maxPerStageDescriptorUniformBuffers +
112 limits->maxPerStageDescriptorStorageBuffers +
113 limits->maxPerStageDescriptorSampledImages +
114 limits->maxPerStageDescriptorStorageImages +
115 limits->maxPerStageDescriptorInputAttachments +
116 limits->maxColorAttachments);
117
118 if (features->tessellationShader)
119 {
120 shaderStages += 2;
121 }
122
123 if (features->geometryShader)
124 {
125 shaderStages++;
126 }
127
128 struct FeatureLimitTable
129 {
130 deUint32 offset;
131 const char* name;
132 deUint32 uintVal; //!< Format is UNSIGNED_INT
133 deInt32 intVal; //!< Format is SIGNED_INT
134 deUint64 deviceSizeVal; //!< Format is DEVICE_SIZE
135 float floatVal; //!< Format is FLOAT
136 LimitFormat format;
137 LimitType type;
138 deInt32 unsuppTableNdx;
139 deBool pot;
140 } featureLimitTable[] = //!< Based on 1.0.28 Vulkan spec
141 {
142 { LIMIT(maxImageDimension1D), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
143 { LIMIT(maxImageDimension2D), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
144 { LIMIT(maxImageDimension3D), 256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
145 { LIMIT(maxImageDimensionCube), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
146 { LIMIT(maxImageArrayLayers), 256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
147 { LIMIT(maxTexelBufferElements), 65536, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
148 { LIMIT(maxUniformBufferRange), 16384, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
149 { LIMIT(maxStorageBufferRange), 134217728, 0, 0, 0, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
150 { LIMIT(maxPushConstantsSize), 128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
151 { LIMIT(maxMemoryAllocationCount), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
152 { LIMIT(maxSamplerAllocationCount), 4000, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
153 { LIMIT(bufferImageGranularity), 0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, false },
154 { LIMIT(bufferImageGranularity), 0, 0, 131072, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, false },
155 { LIMIT(sparseAddressSpaceSize), 0, 0, 2UL*1024*1024*1024, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, false },
156 { LIMIT(maxBoundDescriptorSets), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
157 { LIMIT(maxPerStageDescriptorSamplers), 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
158 { LIMIT(maxPerStageDescriptorUniformBuffers), 12, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
159 { LIMIT(maxPerStageDescriptorStorageBuffers), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
160 { LIMIT(maxPerStageDescriptorSampledImages), 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
161 { LIMIT(maxPerStageDescriptorStorageImages), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
162 { LIMIT(maxPerStageDescriptorInputAttachments), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
163 { LIMIT(maxPerStageResources), maxPerStageResourcesMin, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
164 { LIMIT(maxDescriptorSetSamplers), shaderStages * 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
165 { LIMIT(maxDescriptorSetUniformBuffers), shaderStages * 12, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
166 { LIMIT(maxDescriptorSetUniformBuffersDynamic), 8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
167 { LIMIT(maxDescriptorSetStorageBuffers), shaderStages * 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
168 { LIMIT(maxDescriptorSetStorageBuffersDynamic), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
169 { LIMIT(maxDescriptorSetSampledImages), shaderStages * 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
170 { LIMIT(maxDescriptorSetStorageImages), shaderStages * 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
171 { LIMIT(maxDescriptorSetInputAttachments), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
172 { LIMIT(maxVertexInputAttributes), 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
173 { LIMIT(maxVertexInputBindings), 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
174 { LIMIT(maxVertexInputAttributeOffset), 2047, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
175 { LIMIT(maxVertexInputBindingStride), 2048, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
176 { LIMIT(maxVertexOutputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
177 { LIMIT(maxTessellationGenerationLevel), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
178 { LIMIT(maxTessellationPatchSize), 32, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
179 { LIMIT(maxTessellationControlPerVertexInputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
180 { LIMIT(maxTessellationControlPerVertexOutputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
181 { LIMIT(maxTessellationControlPerPatchOutputComponents), 120, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
182 { LIMIT(maxTessellationControlTotalOutputComponents), 2048, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
183 { LIMIT(maxTessellationEvaluationInputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
184 { LIMIT(maxTessellationEvaluationOutputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
185 { LIMIT(maxGeometryShaderInvocations), 32, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
186 { LIMIT(maxGeometryInputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
187 { LIMIT(maxGeometryOutputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
188 { LIMIT(maxGeometryOutputVertices), 256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
189 { LIMIT(maxGeometryTotalOutputComponents), 1024, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
190 { LIMIT(maxFragmentInputComponents), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
191 { LIMIT(maxFragmentOutputAttachments), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
192 { LIMIT(maxFragmentDualSrcAttachments), 1, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
193 { LIMIT(maxFragmentCombinedOutputResources), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
194 { LIMIT(maxComputeSharedMemorySize), 16384, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
195 { LIMIT(maxComputeWorkGroupCount[0]), 65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
196 { LIMIT(maxComputeWorkGroupCount[1]), 65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
197 { LIMIT(maxComputeWorkGroupCount[2]), 65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
198 { LIMIT(maxComputeWorkGroupInvocations), 128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
199 { LIMIT(maxComputeWorkGroupSize[0]), 128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
200 { LIMIT(maxComputeWorkGroupSize[1]), 128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
201 { LIMIT(maxComputeWorkGroupSize[2]), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
202 { LIMIT(subPixelPrecisionBits), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
203 { LIMIT(subTexelPrecisionBits), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
204 { LIMIT(mipmapPrecisionBits), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
205 { LIMIT(maxDrawIndexedIndexValue), (deUint32)~0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
206 { LIMIT(maxDrawIndirectCount), 65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
207 { LIMIT(maxSamplerLodBias), 0, 0, 0, 2.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
208 { LIMIT(maxSamplerAnisotropy), 0, 0, 0, 16.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
209 { LIMIT(maxViewports), 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
210 { LIMIT(maxViewportDimensions[0]), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
211 { LIMIT(maxViewportDimensions[1]), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
212 { LIMIT(viewportBoundsRange[0]), 0, 0, 0, -8192.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
213 { LIMIT(viewportBoundsRange[1]), 0, 0, 0, 8191.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
214 { LIMIT(viewportSubPixelBits), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
215 { LIMIT(minMemoryMapAlignment), 64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
216 { LIMIT(minTexelBufferOffsetAlignment), 0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
217 { LIMIT(minTexelBufferOffsetAlignment), 0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
218 { LIMIT(minUniformBufferOffsetAlignment), 0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
219 { LIMIT(minUniformBufferOffsetAlignment), 0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
220 { LIMIT(minStorageBufferOffsetAlignment), 0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
221 { LIMIT(minStorageBufferOffsetAlignment), 0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
222 { LIMIT(minTexelOffset), 0, -8, 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MAX, -1, false },
223 { LIMIT(maxTexelOffset), 7, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
224 { LIMIT(minTexelGatherOffset), 0, -8, 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MAX, -1, false },
225 { LIMIT(maxTexelGatherOffset), 7, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
226 { LIMIT(minInterpolationOffset), 0, 0, 0, -0.5f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
227 { LIMIT(maxInterpolationOffset), 0, 0, 0, 0.5f - (1.0f/deFloatPow(2.0f, (float)limits->subPixelInterpolationOffsetBits)), LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
228 { LIMIT(subPixelInterpolationOffsetBits), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
229 { LIMIT(maxFramebufferWidth), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
230 { LIMIT(maxFramebufferHeight), 4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
231 { LIMIT(maxFramebufferLayers), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
232 { LIMIT(framebufferColorSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
233 { LIMIT(framebufferDepthSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
234 { LIMIT(framebufferStencilSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
235 { LIMIT(framebufferNoAttachmentsSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
236 { LIMIT(maxColorAttachments), 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
237 { LIMIT(sampledImageColorSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
238 { LIMIT(sampledImageIntegerSampleCounts), VK_SAMPLE_COUNT_1_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
239 { LIMIT(sampledImageDepthSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
240 { LIMIT(sampledImageStencilSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
241 { LIMIT(storageImageSampleCounts), VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
242 { LIMIT(maxSampleMaskWords), 1, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
243 { LIMIT(timestampComputeAndGraphics), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
244 { LIMIT(timestampPeriod), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
245 { LIMIT(maxClipDistances), 8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
246 { LIMIT(maxCullDistances), 8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
247 { LIMIT(maxCombinedClipAndCullDistances), 8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
248 { LIMIT(discreteQueuePriorities), 2, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
249 { LIMIT(pointSizeRange[0]), 0, 0, 0, 0.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
250 { LIMIT(pointSizeRange[0]), 0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
251 { LIMIT(pointSizeRange[1]), 0, 0, 0, 64.0f - limits->pointSizeGranularity , LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
252 { LIMIT(lineWidthRange[0]), 0, 0, 0, 0.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
253 { LIMIT(lineWidthRange[0]), 0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
254 { LIMIT(lineWidthRange[1]), 0, 0, 0, 8.0f - limits->lineWidthGranularity, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
255 { LIMIT(pointSizeGranularity), 0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
256 { LIMIT(lineWidthGranularity), 0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
257 { LIMIT(strictLines), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
258 { LIMIT(standardSampleLocations), 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
259 { LIMIT(optimalBufferCopyOffsetAlignment), 0, 0, 0, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_NONE, -1, true },
260 { LIMIT(optimalBufferCopyRowPitchAlignment), 0, 0, 0, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_NONE, -1, true },
261 { LIMIT(nonCoherentAtomSize), 0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
262 { LIMIT(nonCoherentAtomSize), 0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
263 };
264
265 const struct UnsupportedFeatureLimitTable
266 {
267 deUint32 limitOffset;
268 const char* name;
269 deUint32 featureOffset;
270 deUint32 uintVal; //!< Format is UNSIGNED_INT
271 deInt32 intVal; //!< Format is SIGNED_INT
272 deUint64 deviceSizeVal; //!< Format is DEVICE_SIZE
273 float floatVal; //!< Format is FLOAT
274 } unsupportedFeatureTable[] =
275 {
276 { LIMIT(sparseAddressSpaceSize), FEATURE(sparseBinding), 0, 0, 0, 0.0f },
277 { LIMIT(maxTessellationGenerationLevel), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
278 { LIMIT(maxTessellationPatchSize), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
279 { LIMIT(maxTessellationControlPerVertexInputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
280 { LIMIT(maxTessellationControlPerVertexOutputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
281 { LIMIT(maxTessellationControlPerPatchOutputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
282 { LIMIT(maxTessellationControlTotalOutputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
283 { LIMIT(maxTessellationEvaluationInputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
284 { LIMIT(maxTessellationEvaluationOutputComponents), FEATURE(tessellationShader), 0, 0, 0, 0.0f },
285 { LIMIT(maxGeometryShaderInvocations), FEATURE(geometryShader), 0, 0, 0, 0.0f },
286 { LIMIT(maxGeometryInputComponents), FEATURE(geometryShader), 0, 0, 0, 0.0f },
287 { LIMIT(maxGeometryOutputComponents), FEATURE(geometryShader), 0, 0, 0, 0.0f },
288 { LIMIT(maxGeometryOutputVertices), FEATURE(geometryShader), 0, 0, 0, 0.0f },
289 { LIMIT(maxGeometryTotalOutputComponents), FEATURE(geometryShader), 0, 0, 0, 0.0f },
290 { LIMIT(maxFragmentDualSrcAttachments), FEATURE(dualSrcBlend), 0, 0, 0, 0.0f },
291 { LIMIT(maxDrawIndexedIndexValue), FEATURE(fullDrawIndexUint32), (1<<24)-1, 0, 0, 0.0f },
292 { LIMIT(maxDrawIndirectCount), FEATURE(multiDrawIndirect), 1, 0, 0, 0.0f },
293 { LIMIT(maxSamplerAnisotropy), FEATURE(samplerAnisotropy), 1, 0, 0, 0.0f },
294 { LIMIT(maxViewports), FEATURE(multiViewport), 1, 0, 0, 0.0f },
295 { LIMIT(minTexelGatherOffset), FEATURE(shaderImageGatherExtended), 0, 0, 0, 0.0f },
296 { LIMIT(maxTexelGatherOffset), FEATURE(shaderImageGatherExtended), 0, 0, 0, 0.0f },
297 { LIMIT(minInterpolationOffset), FEATURE(sampleRateShading), 0, 0, 0, 0.0f },
298 { LIMIT(maxInterpolationOffset), FEATURE(sampleRateShading), 0, 0, 0, 0.0f },
299 { LIMIT(subPixelInterpolationOffsetBits), FEATURE(sampleRateShading), 0, 0, 0, 0.0f },
300 { LIMIT(storageImageSampleCounts), FEATURE(shaderStorageImageMultisample), VK_SAMPLE_COUNT_1_BIT, 0, 0, 0.0f },
301 { LIMIT(maxClipDistances), FEATURE(shaderClipDistance), 0, 0, 0, 0.0f },
302 { LIMIT(maxCullDistances), FEATURE(shaderCullDistance), 0, 0, 0, 0.0f },
303 { LIMIT(maxCombinedClipAndCullDistances), FEATURE(shaderClipDistance), 0, 0, 0, 0.0f },
304 { LIMIT(pointSizeRange[0]), FEATURE(largePoints), 0, 0, 0, 1.0f },
305 { LIMIT(pointSizeRange[1]), FEATURE(largePoints), 0, 0, 0, 1.0f },
306 { LIMIT(lineWidthRange[0]), FEATURE(wideLines), 0, 0, 0, 1.0f },
307 { LIMIT(lineWidthRange[1]), FEATURE(wideLines), 0, 0, 0, 1.0f },
308 { LIMIT(pointSizeGranularity), FEATURE(largePoints), 0, 0, 0, 0.0f },
309 { LIMIT(lineWidthGranularity), FEATURE(wideLines), 0, 0, 0, 0.0f }
310 };
311
312 log << TestLog::Message << *limits << TestLog::EndMessage;
313
314 //!< First build a map from limit to unsupported table index
315 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
316 {
317 for (deUint32 unsuppNdx = 0; unsuppNdx < DE_LENGTH_OF_ARRAY(unsupportedFeatureTable); unsuppNdx++)
318 {
319 if (unsupportedFeatureTable[unsuppNdx].limitOffset == featureLimitTable[ndx].offset)
320 {
321 featureLimitTable[ndx].unsuppTableNdx = unsuppNdx;
322 break;
323 }
324 }
325 }
326
327 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
328 {
329 switch (featureLimitTable[ndx].format)
330 {
331 case LIMIT_FORMAT_UNSIGNED_INT:
332 {
333 deUint32 limitToCheck = featureLimitTable[ndx].uintVal;
334 if (featureLimitTable[ndx].unsuppTableNdx != -1)
335 {
336 if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
337 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].uintVal;
338 }
339
340 if (featureLimitTable[ndx].pot)
341 {
342 if (!deIntIsPow2(*((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset))))
343 {
344 log << TestLog::Message << "limit Validation failed " << featureLimitTable[ndx].name
345 << " is not a power of two." << TestLog::EndMessage;
346 limitsOk = false;
347 }
348 }
349
350 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
351 {
352 if (*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
353 {
354 log << TestLog::Message << "limit Validation failed " << featureLimitTable[ndx].name
355 << " not valid-limit type MIN - actual is "
356 << *((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
357 limitsOk = false;
358 }
359 }
360 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
361 {
362 if (*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
363 {
364 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
365 << " not valid-limit type MAX - actual is "
366 << *((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
367 limitsOk = false;
368 }
369 }
370 break;
371 }
372
373 case LIMIT_FORMAT_FLOAT:
374 {
375 float limitToCheck = featureLimitTable[ndx].floatVal;
376 if (featureLimitTable[ndx].unsuppTableNdx != -1)
377 {
378 if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
379 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].floatVal;
380 }
381
382 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
383 {
384 if (*((float*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
385 {
386 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
387 << " not valid-limit type MIN - actual is "
388 << *((float*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
389 limitsOk = false;
390 }
391 }
392 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
393 {
394 if (*((float*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
395 {
396 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
397 << " not valid-limit type MAX actual is "
398 << *((float*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
399 limitsOk = false;
400 }
401 }
402 break;
403 }
404
405 case LIMIT_FORMAT_SIGNED_INT:
406 {
407 deInt32 limitToCheck = featureLimitTable[ndx].intVal;
408 if (featureLimitTable[ndx].unsuppTableNdx != -1)
409 {
410 if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
411 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].intVal;
412 }
413 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
414 {
415 if (*((deInt32*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
416 {
417 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
418 << " not valid-limit type MIN actual is "
419 << *((deInt32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
420 limitsOk = false;
421 }
422 }
423 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
424 {
425 if (*((deInt32*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
426 {
427 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
428 << " not valid-limit type MAX actual is "
429 << *((deInt32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
430 limitsOk = false;
431 }
432 }
433 break;
434 }
435
436 case LIMIT_FORMAT_DEVICE_SIZE:
437 {
438 deUint64 limitToCheck = featureLimitTable[ndx].deviceSizeVal;
439 if (featureLimitTable[ndx].unsuppTableNdx != -1)
440 {
441 if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
442 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].deviceSizeVal;
443 }
444
445 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
446 {
447 if (*((deUint64*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
448 {
449 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
450 << " not valid-limit type MIN actual is "
451 << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
452 limitsOk = false;
453 }
454 }
455 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
456 {
457 if (*((deUint64*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
458 {
459 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
460 << " not valid-limit type MAX actual is "
461 << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
462 limitsOk = false;
463 }
464 }
465 break;
466 }
467
468 case LIMIT_FORMAT_BITMASK:
469 {
470 deUint32 limitToCheck = featureLimitTable[ndx].uintVal;
471 if (featureLimitTable[ndx].unsuppTableNdx != -1)
472 {
473 if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
474 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].uintVal;
475 }
476
477 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
478 {
479 if ((*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) & limitToCheck) != limitToCheck)
480 {
481 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
482 << " not valid-limit type bitmask actual is "
483 << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
484 limitsOk = false;
485 }
486 }
487 break;
488 }
489
490 default:
491 DE_ASSERT(0);
492 limitsOk = false;
493 }
494 }
495
496 if (limits->maxFramebufferWidth > limits->maxViewportDimensions[0] ||
497 limits->maxFramebufferHeight > limits->maxViewportDimensions[1])
498 {
499 log << TestLog::Message << "limit validation failed, maxFramebufferDimension of "
500 << "[" << limits->maxFramebufferWidth << ", " << limits->maxFramebufferHeight << "] "
501 << "is larger than maxViewportDimension of "
502 << "[" << limits->maxViewportDimensions[0] << ", " << limits->maxViewportDimensions[1] << "]" << TestLog::EndMessage;
503 limitsOk = false;
504 }
505
506 if (limits->viewportBoundsRange[0] > float(-2 * limits->maxViewportDimensions[0]))
507 {
508 log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits->viewportBoundsRange[0]
509 << "is larger than -2*maxViewportDimension[0] of " << -2*limits->maxViewportDimensions[0] << TestLog::EndMessage;
510 limitsOk = false;
511 }
512
513 if (limits->viewportBoundsRange[1] < float(2 * limits->maxViewportDimensions[1] - 1))
514 {
515 log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits->viewportBoundsRange[1]
516 << "is less than 2*maxViewportDimension[1] of " << 2*limits->maxViewportDimensions[1] << TestLog::EndMessage;
517 limitsOk = false;
518 }
519
520 return limitsOk;
521 }
522
523 template<deUint32 MAJOR, deUint32 MINOR>
checkApiVersionSupport(Context & context)524 void checkApiVersionSupport(Context& context)
525 {
526 if (!context.contextSupports(vk::ApiVersion(MAJOR, MINOR, 0)))
527 TCU_THROW(NotSupportedError, std::string("At least Vulkan ") + std::to_string(MAJOR) + "." + std::to_string(MINOR) + " required to run test");
528 }
529
530 typedef struct FeatureLimitTableItem_
531 {
532 const void* cond;
533 const char* condName;
534 const void* ptr;
535 const char* name;
536 deUint32 uintVal; //!< Format is UNSIGNED_INT
537 deInt32 intVal; //!< Format is SIGNED_INT
538 deUint64 deviceSizeVal; //!< Format is DEVICE_SIZE
539 float floatVal; //!< Format is FLOAT
540 LimitFormat format;
541 LimitType type;
542 } FeatureLimitTableItem;
543
544 template<typename T>
validateNumericLimit(const T limitToCheck,const T reportedValue,const LimitType limitType,const char * limitName,TestLog & log)545 bool validateNumericLimit (const T limitToCheck, const T reportedValue, const LimitType limitType, const char* limitName, TestLog& log)
546 {
547 if (limitType == LIMIT_TYPE_MIN)
548 {
549 if (reportedValue < limitToCheck)
550 {
551 log << TestLog::Message << "Limit validation failed " << limitName
552 << " reported value is " << reportedValue
553 << " expected MIN " << limitToCheck
554 << TestLog::EndMessage;
555
556 return false;
557 }
558
559 log << TestLog::Message << limitName
560 << "=" << reportedValue
561 << " (>=" << limitToCheck << ")"
562 << TestLog::EndMessage;
563 }
564 else if (limitType == LIMIT_TYPE_MAX)
565 {
566 if (reportedValue > limitToCheck)
567 {
568 log << TestLog::Message << "Limit validation failed " << limitName
569 << " reported value is " << reportedValue
570 << " expected MAX " << limitToCheck
571 << TestLog::EndMessage;
572
573 return false;
574 }
575
576 log << TestLog::Message << limitName
577 << "=" << reportedValue
578 << " (<=" << limitToCheck << ")"
579 << TestLog::EndMessage;
580 }
581
582 return true;
583 }
584
585 template<typename T>
validateBitmaskLimit(const T limitToCheck,const T reportedValue,const LimitType limitType,const char * limitName,TestLog & log)586 bool validateBitmaskLimit (const T limitToCheck, const T reportedValue, const LimitType limitType, const char* limitName, TestLog& log)
587 {
588 if (limitType == LIMIT_TYPE_MIN)
589 {
590 if ((reportedValue & limitToCheck) != limitToCheck)
591 {
592 log << TestLog::Message << "Limit validation failed " << limitName
593 << " reported value is " << reportedValue
594 << " expected MIN " << limitToCheck
595 << TestLog::EndMessage;
596
597 return false;
598 }
599
600 log << TestLog::Message << limitName
601 << "=" << tcu::toHex(reportedValue)
602 << " (contains " << tcu::toHex(limitToCheck) << ")"
603 << TestLog::EndMessage;
604 }
605
606 return true;
607 }
608
validateLimit(FeatureLimitTableItem limit,TestLog & log)609 bool validateLimit (FeatureLimitTableItem limit, TestLog& log)
610 {
611 if (*((VkBool32*)limit.cond) == DE_FALSE)
612 {
613 log << TestLog::Message
614 << "Limit validation skipped '" << limit.name << "' due to "
615 << limit.condName << " == false'"
616 << TestLog::EndMessage;
617
618 return true;
619 }
620
621 switch (limit.format)
622 {
623 case LIMIT_FORMAT_UNSIGNED_INT:
624 {
625 const deUint32 limitToCheck = limit.uintVal;
626 const deUint32 reportedValue = *(deUint32*)limit.ptr;
627
628 return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
629 }
630
631 case LIMIT_FORMAT_FLOAT:
632 {
633 const float limitToCheck = limit.floatVal;
634 const float reportedValue = *(float*)limit.ptr;
635
636 return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
637 }
638
639 case LIMIT_FORMAT_SIGNED_INT:
640 {
641 const deInt32 limitToCheck = limit.intVal;
642 const deInt32 reportedValue = *(deInt32*)limit.ptr;
643
644 return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
645 }
646
647 case LIMIT_FORMAT_DEVICE_SIZE:
648 {
649 const deUint64 limitToCheck = limit.deviceSizeVal;
650 const deUint64 reportedValue = *(deUint64*)limit.ptr;
651
652 return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
653 }
654
655 case LIMIT_FORMAT_BITMASK:
656 {
657 const deUint32 limitToCheck = limit.uintVal;
658 const deUint32 reportedValue = *(deUint32*)limit.ptr;
659
660 return validateBitmaskLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
661 }
662
663 default:
664 TCU_THROW(InternalError, "Unknown LimitFormat specified");
665 }
666 }
667
668 #ifdef PN
669 #error PN defined
670 #else
671 #define PN(_X_) &(_X_), (const char*)(#_X_)
672 #endif
673
674 #define LIM_MIN_UINT32(X) deUint32(X), 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN
675 #define LIM_MAX_UINT32(X) deUint32(X), 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MAX
676 #define LIM_NONE_UINT32 0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE
677 #define LIM_MIN_INT32(X) 0, deInt32(X), 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MIN
678 #define LIM_MAX_INT32(X) 0, deInt32(X), 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MAX
679 #define LIM_NONE_INT32 0, 0, 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_NONE
680 #define LIM_MIN_DEVSIZE(X) 0, 0, VkDeviceSize(X), 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN
681 #define LIM_MAX_DEVSIZE(X) 0, 0, VkDeviceSize(X), 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX
682 #define LIM_NONE_DEVSIZE 0, 0, 0, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_NONE
683 #define LIM_MIN_FLOAT(X) 0, 0, 0, float(X), LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN
684 #define LIM_MAX_FLOAT(X) 0, 0, 0, float(X), LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX
685 #define LIM_NONE_FLOAT 0, 0, 0, 0.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_NONE
686 #define LIM_MIN_BITI32(X) deUint32(X), 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN
687 #define LIM_MAX_BITI32(X) deUint32(X), 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MAX
688 #define LIM_NONE_BITI32 0, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_NONE
689
validateLimits12(Context & context)690 tcu::TestStatus validateLimits12 (Context& context)
691 {
692 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
693 const InstanceInterface& vki = context.getInstanceInterface();
694 TestLog& log = context.getTestContext().getLog();
695 bool limitsOk = true;
696
697 const VkPhysicalDeviceFeatures2& features2 = context.getDeviceFeatures2();
698 const VkPhysicalDeviceFeatures& features = features2.features;
699 const VkPhysicalDeviceVulkan12Features features12 = getPhysicalDeviceVulkan12Features(vki, physicalDevice);
700
701 const VkPhysicalDeviceProperties2& properties2 = context.getDeviceProperties2();
702 const VkPhysicalDeviceVulkan12Properties vulkan12Properties = getPhysicalDeviceVulkan12Properties(vki, physicalDevice);
703 const VkPhysicalDeviceVulkan11Properties vulkan11Properties = getPhysicalDeviceVulkan11Properties(vki, physicalDevice);
704 const VkPhysicalDeviceLimits& limits = properties2.properties.limits;
705
706 const VkBool32 checkAlways = VK_TRUE;
707 const VkBool32 checkVulkan12Limit = VK_TRUE;
708
709 deUint32 shaderStages = 3;
710 deUint32 maxPerStageResourcesMin = deMin32(128, limits.maxPerStageDescriptorUniformBuffers +
711 limits.maxPerStageDescriptorStorageBuffers +
712 limits.maxPerStageDescriptorSampledImages +
713 limits.maxPerStageDescriptorStorageImages +
714 limits.maxPerStageDescriptorInputAttachments +
715 limits.maxColorAttachments);
716
717 if (features.tessellationShader)
718 {
719 shaderStages += 2;
720 }
721
722 if (features.geometryShader)
723 {
724 shaderStages++;
725 }
726
727 FeatureLimitTableItem featureLimitTable[] =
728 {
729 { PN(checkAlways), PN(limits.maxImageDimension1D), LIM_MIN_UINT32(4096) },
730 { PN(checkAlways), PN(limits.maxImageDimension2D), LIM_MIN_UINT32(4096) },
731 { PN(checkAlways), PN(limits.maxImageDimension3D), LIM_MIN_UINT32(256) },
732 { PN(checkAlways), PN(limits.maxImageDimensionCube), LIM_MIN_UINT32(4096) },
733 { PN(checkAlways), PN(limits.maxImageArrayLayers), LIM_MIN_UINT32(256) },
734 { PN(checkAlways), PN(limits.maxTexelBufferElements), LIM_MIN_UINT32(65536) },
735 { PN(checkAlways), PN(limits.maxUniformBufferRange), LIM_MIN_UINT32(16384) },
736 { PN(checkAlways), PN(limits.maxStorageBufferRange), LIM_MIN_UINT32((1<<27)) },
737 { PN(checkAlways), PN(limits.maxPushConstantsSize), LIM_MIN_UINT32(128) },
738 { PN(checkAlways), PN(limits.maxMemoryAllocationCount), LIM_MIN_UINT32(4096) },
739 { PN(checkAlways), PN(limits.maxSamplerAllocationCount), LIM_MIN_UINT32(4000) },
740 { PN(checkAlways), PN(limits.bufferImageGranularity), LIM_MIN_DEVSIZE(1) },
741 { PN(checkAlways), PN(limits.bufferImageGranularity), LIM_MAX_DEVSIZE(131072) },
742 { PN(features.sparseBinding), PN(limits.sparseAddressSpaceSize), LIM_MIN_DEVSIZE((1ull<<31)) },
743 { PN(checkAlways), PN(limits.maxBoundDescriptorSets), LIM_MIN_UINT32(4) },
744 { PN(checkAlways), PN(limits.maxPerStageDescriptorSamplers), LIM_MIN_UINT32(16) },
745 { PN(checkAlways), PN(limits.maxPerStageDescriptorUniformBuffers), LIM_MIN_UINT32(12) },
746 { PN(checkAlways), PN(limits.maxPerStageDescriptorStorageBuffers), LIM_MIN_UINT32(4) },
747 { PN(checkAlways), PN(limits.maxPerStageDescriptorSampledImages), LIM_MIN_UINT32(16) },
748 { PN(checkAlways), PN(limits.maxPerStageDescriptorStorageImages), LIM_MIN_UINT32(4) },
749 { PN(checkAlways), PN(limits.maxPerStageDescriptorInputAttachments), LIM_MIN_UINT32(4) },
750 { PN(checkAlways), PN(limits.maxPerStageResources), LIM_MIN_UINT32(maxPerStageResourcesMin) },
751 { PN(checkAlways), PN(limits.maxDescriptorSetSamplers), LIM_MIN_UINT32(shaderStages * 16) },
752 { PN(checkAlways), PN(limits.maxDescriptorSetUniformBuffers), LIM_MIN_UINT32(shaderStages * 12) },
753 { PN(checkAlways), PN(limits.maxDescriptorSetUniformBuffersDynamic), LIM_MIN_UINT32(8) },
754 { PN(checkAlways), PN(limits.maxDescriptorSetStorageBuffers), LIM_MIN_UINT32(shaderStages * 4) },
755 { PN(checkAlways), PN(limits.maxDescriptorSetStorageBuffersDynamic), LIM_MIN_UINT32(4) },
756 { PN(checkAlways), PN(limits.maxDescriptorSetSampledImages), LIM_MIN_UINT32(shaderStages * 16) },
757 { PN(checkAlways), PN(limits.maxDescriptorSetStorageImages), LIM_MIN_UINT32(shaderStages * 4) },
758 { PN(checkAlways), PN(limits.maxDescriptorSetInputAttachments), LIM_MIN_UINT32(4) },
759 { PN(checkAlways), PN(limits.maxVertexInputAttributes), LIM_MIN_UINT32(16) },
760 { PN(checkAlways), PN(limits.maxVertexInputBindings), LIM_MIN_UINT32(16) },
761 { PN(checkAlways), PN(limits.maxVertexInputAttributeOffset), LIM_MIN_UINT32(2047) },
762 { PN(checkAlways), PN(limits.maxVertexInputBindingStride), LIM_MIN_UINT32(2048) },
763 { PN(checkAlways), PN(limits.maxVertexOutputComponents), LIM_MIN_UINT32(64) },
764 { PN(features.tessellationShader), PN(limits.maxTessellationGenerationLevel), LIM_MIN_UINT32(64) },
765 { PN(features.tessellationShader), PN(limits.maxTessellationPatchSize), LIM_MIN_UINT32(32) },
766 { PN(features.tessellationShader), PN(limits.maxTessellationControlPerVertexInputComponents), LIM_MIN_UINT32(64) },
767 { PN(features.tessellationShader), PN(limits.maxTessellationControlPerVertexOutputComponents), LIM_MIN_UINT32(64) },
768 { PN(features.tessellationShader), PN(limits.maxTessellationControlPerPatchOutputComponents), LIM_MIN_UINT32(120) },
769 { PN(features.tessellationShader), PN(limits.maxTessellationControlTotalOutputComponents), LIM_MIN_UINT32(2048) },
770 { PN(features.tessellationShader), PN(limits.maxTessellationEvaluationInputComponents), LIM_MIN_UINT32(64) },
771 { PN(features.tessellationShader), PN(limits.maxTessellationEvaluationOutputComponents), LIM_MIN_UINT32(64) },
772 { PN(features.geometryShader), PN(limits.maxGeometryShaderInvocations), LIM_MIN_UINT32(32) },
773 { PN(features.geometryShader), PN(limits.maxGeometryInputComponents), LIM_MIN_UINT32(64) },
774 { PN(features.geometryShader), PN(limits.maxGeometryOutputComponents), LIM_MIN_UINT32(64) },
775 { PN(features.geometryShader), PN(limits.maxGeometryOutputVertices), LIM_MIN_UINT32(256) },
776 { PN(features.geometryShader), PN(limits.maxGeometryTotalOutputComponents), LIM_MIN_UINT32(1024) },
777 { PN(checkAlways), PN(limits.maxFragmentInputComponents), LIM_MIN_UINT32(64) },
778 { PN(checkAlways), PN(limits.maxFragmentOutputAttachments), LIM_MIN_UINT32(4) },
779 { PN(features.dualSrcBlend), PN(limits.maxFragmentDualSrcAttachments), LIM_MIN_UINT32(1) },
780 { PN(checkAlways), PN(limits.maxFragmentCombinedOutputResources), LIM_MIN_UINT32(4) },
781 { PN(checkAlways), PN(limits.maxComputeSharedMemorySize), LIM_MIN_UINT32(16384) },
782 { PN(checkAlways), PN(limits.maxComputeWorkGroupCount[0]), LIM_MIN_UINT32(65535) },
783 { PN(checkAlways), PN(limits.maxComputeWorkGroupCount[1]), LIM_MIN_UINT32(65535) },
784 { PN(checkAlways), PN(limits.maxComputeWorkGroupCount[2]), LIM_MIN_UINT32(65535) },
785 { PN(checkAlways), PN(limits.maxComputeWorkGroupInvocations), LIM_MIN_UINT32(128) },
786 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[0]), LIM_MIN_UINT32(128) },
787 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[1]), LIM_MIN_UINT32(128) },
788 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[2]), LIM_MIN_UINT32(64) },
789 { PN(checkAlways), PN(limits.subPixelPrecisionBits), LIM_MIN_UINT32(4) },
790 { PN(checkAlways), PN(limits.subTexelPrecisionBits), LIM_MIN_UINT32(4) },
791 { PN(checkAlways), PN(limits.mipmapPrecisionBits), LIM_MIN_UINT32(4) },
792 { PN(features.fullDrawIndexUint32), PN(limits.maxDrawIndexedIndexValue), LIM_MIN_UINT32((deUint32)~0) },
793 { PN(features.multiDrawIndirect), PN(limits.maxDrawIndirectCount), LIM_MIN_UINT32(65535) },
794 { PN(checkAlways), PN(limits.maxSamplerLodBias), LIM_MIN_FLOAT(2.0f) },
795 { PN(features.samplerAnisotropy), PN(limits.maxSamplerAnisotropy), LIM_MIN_FLOAT(16.0f) },
796 { PN(features.multiViewport), PN(limits.maxViewports), LIM_MIN_UINT32(16) },
797 { PN(checkAlways), PN(limits.maxViewportDimensions[0]), LIM_MIN_UINT32(4096) },
798 { PN(checkAlways), PN(limits.maxViewportDimensions[1]), LIM_MIN_UINT32(4096) },
799 { PN(checkAlways), PN(limits.viewportBoundsRange[0]), LIM_MAX_FLOAT(-8192.0f) },
800 { PN(checkAlways), PN(limits.viewportBoundsRange[1]), LIM_MIN_FLOAT(8191.0f) },
801 { PN(checkAlways), PN(limits.viewportSubPixelBits), LIM_MIN_UINT32(0) },
802 { PN(checkAlways), PN(limits.minMemoryMapAlignment), LIM_MIN_UINT32(64) },
803 { PN(checkAlways), PN(limits.minTexelBufferOffsetAlignment), LIM_MIN_DEVSIZE(1) },
804 { PN(checkAlways), PN(limits.minTexelBufferOffsetAlignment), LIM_MAX_DEVSIZE(256) },
805 { PN(checkAlways), PN(limits.minUniformBufferOffsetAlignment), LIM_MIN_DEVSIZE(1) },
806 { PN(checkAlways), PN(limits.minUniformBufferOffsetAlignment), LIM_MAX_DEVSIZE(256) },
807 { PN(checkAlways), PN(limits.minStorageBufferOffsetAlignment), LIM_MIN_DEVSIZE(1) },
808 { PN(checkAlways), PN(limits.minStorageBufferOffsetAlignment), LIM_MAX_DEVSIZE(256) },
809 { PN(checkAlways), PN(limits.minTexelOffset), LIM_MAX_INT32(-8) },
810 { PN(checkAlways), PN(limits.maxTexelOffset), LIM_MIN_INT32(7) },
811 { PN(features.shaderImageGatherExtended), PN(limits.minTexelGatherOffset), LIM_MAX_INT32(-8) },
812 { PN(features.shaderImageGatherExtended), PN(limits.maxTexelGatherOffset), LIM_MIN_INT32(7) },
813 { PN(features.sampleRateShading), PN(limits.minInterpolationOffset), LIM_MAX_FLOAT(-0.5f) },
814 { PN(features.sampleRateShading), PN(limits.maxInterpolationOffset), LIM_MIN_FLOAT(0.5f - (1.0f/deFloatPow(2.0f, (float)limits.subPixelInterpolationOffsetBits))) },
815 { PN(features.sampleRateShading), PN(limits.subPixelInterpolationOffsetBits), LIM_MIN_UINT32(4) },
816 { PN(checkAlways), PN(limits.maxFramebufferWidth), LIM_MIN_UINT32(4096) },
817 { PN(checkAlways), PN(limits.maxFramebufferHeight), LIM_MIN_UINT32(4096) },
818 { PN(checkAlways), PN(limits.maxFramebufferLayers), LIM_MIN_UINT32(256) },
819 { PN(checkAlways), PN(limits.framebufferColorSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
820 { PN(checkVulkan12Limit), PN(vulkan12Properties.framebufferIntegerColorSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT) },
821 { PN(checkAlways), PN(limits.framebufferDepthSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
822 { PN(checkAlways), PN(limits.framebufferStencilSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
823 { PN(checkAlways), PN(limits.framebufferNoAttachmentsSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
824 { PN(checkAlways), PN(limits.maxColorAttachments), LIM_MIN_UINT32(4) },
825 { PN(checkAlways), PN(limits.sampledImageColorSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
826 { PN(checkAlways), PN(limits.sampledImageIntegerSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT) },
827 { PN(checkAlways), PN(limits.sampledImageDepthSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
828 { PN(checkAlways), PN(limits.sampledImageStencilSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
829 { PN(features.shaderStorageImageMultisample), PN(limits.storageImageSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
830 { PN(checkAlways), PN(limits.maxSampleMaskWords), LIM_MIN_UINT32(1) },
831 { PN(checkAlways), PN(limits.timestampComputeAndGraphics), LIM_NONE_UINT32 },
832 { PN(checkAlways), PN(limits.timestampPeriod), LIM_NONE_UINT32 },
833 { PN(features.shaderClipDistance), PN(limits.maxClipDistances), LIM_MIN_UINT32(8) },
834 { PN(features.shaderCullDistance), PN(limits.maxCullDistances), LIM_MIN_UINT32(8) },
835 { PN(features.shaderClipDistance), PN(limits.maxCombinedClipAndCullDistances), LIM_MIN_UINT32(8) },
836 { PN(checkAlways), PN(limits.discreteQueuePriorities), LIM_MIN_UINT32(2) },
837 { PN(features.largePoints), PN(limits.pointSizeRange[0]), LIM_MIN_FLOAT(0.0f) },
838 { PN(features.largePoints), PN(limits.pointSizeRange[0]), LIM_MAX_FLOAT(1.0f) },
839 { PN(features.largePoints), PN(limits.pointSizeRange[1]), LIM_MIN_FLOAT(64.0f - limits.pointSizeGranularity) },
840 { PN(features.wideLines), PN(limits.lineWidthRange[0]), LIM_MIN_FLOAT(0.0f) },
841 { PN(features.wideLines), PN(limits.lineWidthRange[0]), LIM_MAX_FLOAT(1.0f) },
842 { PN(features.wideLines), PN(limits.lineWidthRange[1]), LIM_MIN_FLOAT(8.0f - limits.lineWidthGranularity) },
843 { PN(features.largePoints), PN(limits.pointSizeGranularity), LIM_MIN_FLOAT(0.0f) },
844 { PN(features.largePoints), PN(limits.pointSizeGranularity), LIM_MAX_FLOAT(1.0f) },
845 { PN(features.wideLines), PN(limits.lineWidthGranularity), LIM_MIN_FLOAT(0.0f) },
846 { PN(features.wideLines), PN(limits.lineWidthGranularity), LIM_MAX_FLOAT(1.0f) },
847 { PN(checkAlways), PN(limits.strictLines), LIM_NONE_UINT32 },
848 { PN(checkAlways), PN(limits.standardSampleLocations), LIM_NONE_UINT32 },
849 { PN(checkAlways), PN(limits.optimalBufferCopyOffsetAlignment), LIM_NONE_DEVSIZE },
850 { PN(checkAlways), PN(limits.optimalBufferCopyRowPitchAlignment), LIM_NONE_DEVSIZE },
851 { PN(checkAlways), PN(limits.nonCoherentAtomSize), LIM_MIN_DEVSIZE(1) },
852 { PN(checkAlways), PN(limits.nonCoherentAtomSize), LIM_MAX_DEVSIZE(256) },
853
854 // VK_KHR_multiview
855 { PN(checkVulkan12Limit), PN(vulkan11Properties.maxMultiviewViewCount), LIM_MIN_UINT32(6) },
856 { PN(checkVulkan12Limit), PN(vulkan11Properties.maxMultiviewInstanceIndex), LIM_MIN_UINT32((1<<27) - 1) },
857
858 // VK_KHR_maintenance3
859 { PN(checkVulkan12Limit), PN(vulkan11Properties.maxPerSetDescriptors), LIM_MIN_UINT32(1024) },
860 { PN(checkVulkan12Limit), PN(vulkan11Properties.maxMemoryAllocationSize), LIM_MIN_DEVSIZE(1<<30) },
861
862 // VK_EXT_descriptor_indexing
863 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools), LIM_MIN_UINT32(500000) },
864 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers), LIM_MIN_UINT32(500000) },
865 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(12) },
866 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(500000) },
867 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages), LIM_MIN_UINT32(500000) },
868 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages), LIM_MIN_UINT32(500000) },
869 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments), LIM_MIN_UINT32(4) },
870 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageUpdateAfterBindResources), LIM_MIN_UINT32(500000) },
871 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers), LIM_MIN_UINT32(500000) },
872 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(shaderStages * 12) },
873 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), LIM_MIN_UINT32(8) },
874 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(500000) },
875 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), LIM_MIN_UINT32(4) },
876 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages), LIM_MIN_UINT32(500000) },
877 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages), LIM_MIN_UINT32(500000) },
878 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments), LIM_MIN_UINT32(4) },
879 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers), LIM_MIN_UINT32(limits.maxPerStageDescriptorSamplers) },
880 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(limits.maxPerStageDescriptorUniformBuffers) },
881 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageBuffers) },
882 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages), LIM_MIN_UINT32(limits.maxPerStageDescriptorSampledImages) },
883 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages), LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageImages) },
884 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments), LIM_MIN_UINT32(limits.maxPerStageDescriptorInputAttachments) },
885 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxPerStageUpdateAfterBindResources), LIM_MIN_UINT32(limits.maxPerStageResources) },
886 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers), LIM_MIN_UINT32(limits.maxDescriptorSetSamplers) },
887 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffers) },
888 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffersDynamic) },
889 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffers) },
890 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffersDynamic) },
891 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages), LIM_MIN_UINT32(limits.maxDescriptorSetSampledImages) },
892 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages), LIM_MIN_UINT32(limits.maxDescriptorSetStorageImages) },
893 { PN(features12.descriptorIndexing), PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments), LIM_MIN_UINT32(limits.maxDescriptorSetInputAttachments) },
894
895 // timelineSemaphore
896 { PN(checkVulkan12Limit), PN(vulkan12Properties.maxTimelineSemaphoreValueDifference), LIM_MIN_DEVSIZE((1ull<<31) - 1) },
897 };
898
899 log << TestLog::Message << limits << TestLog::EndMessage;
900
901 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
902 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
903
904 if (limits.maxFramebufferWidth > limits.maxViewportDimensions[0] ||
905 limits.maxFramebufferHeight > limits.maxViewportDimensions[1])
906 {
907 log << TestLog::Message << "limit validation failed, maxFramebufferDimension of "
908 << "[" << limits.maxFramebufferWidth << ", " << limits.maxFramebufferHeight << "] "
909 << "is larger than maxViewportDimension of "
910 << "[" << limits.maxViewportDimensions[0] << ", " << limits.maxViewportDimensions[1] << "]" << TestLog::EndMessage;
911 limitsOk = false;
912 }
913
914 if (limits.viewportBoundsRange[0] > float(-2 * limits.maxViewportDimensions[0]))
915 {
916 log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits.viewportBoundsRange[0]
917 << "is larger than -2*maxViewportDimension[0] of " << -2*limits.maxViewportDimensions[0] << TestLog::EndMessage;
918 limitsOk = false;
919 }
920
921 if (limits.viewportBoundsRange[1] < float(2 * limits.maxViewportDimensions[1] - 1))
922 {
923 log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits.viewportBoundsRange[1]
924 << "is less than 2*maxViewportDimension[1] of " << 2*limits.maxViewportDimensions[1] << TestLog::EndMessage;
925 limitsOk = false;
926 }
927
928 if (limitsOk)
929 return tcu::TestStatus::pass("pass");
930 else
931 return tcu::TestStatus::fail("fail");
932 }
933
checkSupportKhrPushDescriptor(Context & context)934 void checkSupportKhrPushDescriptor (Context& context)
935 {
936 context.requireDeviceFunctionality("VK_KHR_push_descriptor");
937 }
938
validateLimitsKhrPushDescriptor(Context & context)939 tcu::TestStatus validateLimitsKhrPushDescriptor (Context& context)
940 {
941 const VkBool32 checkAlways = VK_TRUE;
942 const VkPhysicalDevicePushDescriptorPropertiesKHR& pushDescriptorPropertiesKHR = context.getPushDescriptorProperties();
943 TestLog& log = context.getTestContext().getLog();
944 bool limitsOk = true;
945
946 FeatureLimitTableItem featureLimitTable[] =
947 {
948 { PN(checkAlways), PN(pushDescriptorPropertiesKHR.maxPushDescriptors), LIM_MIN_UINT32(32) },
949 };
950
951 log << TestLog::Message << pushDescriptorPropertiesKHR << TestLog::EndMessage;
952
953 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
954 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
955
956 if (limitsOk)
957 return tcu::TestStatus::pass("pass");
958 else
959 return tcu::TestStatus::fail("fail");
960 }
961
checkSupportKhrMultiview(Context & context)962 void checkSupportKhrMultiview (Context& context)
963 {
964 context.requireDeviceFunctionality("VK_KHR_multiview");
965 }
966
validateLimitsKhrMultiview(Context & context)967 tcu::TestStatus validateLimitsKhrMultiview (Context& context)
968 {
969 const VkBool32 checkAlways = VK_TRUE;
970 const VkPhysicalDeviceMultiviewProperties& multiviewProperties = context.getMultiviewProperties();
971 TestLog& log = context.getTestContext().getLog();
972 bool limitsOk = true;
973
974 FeatureLimitTableItem featureLimitTable[] =
975 {
976 // VK_KHR_multiview
977 { PN(checkAlways), PN(multiviewProperties.maxMultiviewViewCount), LIM_MIN_UINT32(6) },
978 { PN(checkAlways), PN(multiviewProperties.maxMultiviewInstanceIndex), LIM_MIN_UINT32((1<<27) - 1) },
979 };
980
981 log << TestLog::Message << multiviewProperties << TestLog::EndMessage;
982
983 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
984 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
985
986 if (limitsOk)
987 return tcu::TestStatus::pass("pass");
988 else
989 return tcu::TestStatus::fail("fail");
990 }
991
checkSupportExtDiscardRectangles(Context & context)992 void checkSupportExtDiscardRectangles (Context& context)
993 {
994 context.requireDeviceFunctionality("VK_EXT_discard_rectangles");
995 }
996
validateLimitsExtDiscardRectangles(Context & context)997 tcu::TestStatus validateLimitsExtDiscardRectangles (Context& context)
998 {
999 const VkBool32 checkAlways = VK_TRUE;
1000 const VkPhysicalDeviceDiscardRectanglePropertiesEXT& discardRectanglePropertiesEXT = context.getDiscardRectanglePropertiesEXT();
1001 TestLog& log = context.getTestContext().getLog();
1002 bool limitsOk = true;
1003
1004 FeatureLimitTableItem featureLimitTable[] =
1005 {
1006 { PN(checkAlways), PN(discardRectanglePropertiesEXT.maxDiscardRectangles), LIM_MIN_UINT32(4) },
1007 };
1008
1009 log << TestLog::Message << discardRectanglePropertiesEXT << TestLog::EndMessage;
1010
1011 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1012 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1013
1014 if (limitsOk)
1015 return tcu::TestStatus::pass("pass");
1016 else
1017 return tcu::TestStatus::fail("fail");
1018 }
1019
checkSupportExtSampleLocations(Context & context)1020 void checkSupportExtSampleLocations (Context& context)
1021 {
1022 context.requireDeviceFunctionality("VK_EXT_sample_locations");
1023 }
1024
validateLimitsExtSampleLocations(Context & context)1025 tcu::TestStatus validateLimitsExtSampleLocations (Context& context)
1026 {
1027 const VkBool32 checkAlways = VK_TRUE;
1028 const VkPhysicalDeviceSampleLocationsPropertiesEXT& sampleLocationsPropertiesEXT = context.getSampleLocationsPropertiesEXT();
1029 TestLog& log = context.getTestContext().getLog();
1030 bool limitsOk = true;
1031
1032 FeatureLimitTableItem featureLimitTable[] =
1033 {
1034 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.sampleLocationSampleCounts), LIM_MIN_BITI32(VK_SAMPLE_COUNT_4_BIT) },
1035 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.maxSampleLocationGridSize.width), LIM_MIN_FLOAT(0.0f) },
1036 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.maxSampleLocationGridSize.height), LIM_MIN_FLOAT(0.0f) },
1037 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.sampleLocationCoordinateRange[0]), LIM_MAX_FLOAT(0.0f) },
1038 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.sampleLocationCoordinateRange[1]), LIM_MIN_FLOAT(0.9375f) },
1039 { PN(checkAlways), PN(sampleLocationsPropertiesEXT.sampleLocationSubPixelBits), LIM_MIN_UINT32(4) },
1040 };
1041
1042 log << TestLog::Message << sampleLocationsPropertiesEXT << TestLog::EndMessage;
1043
1044 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1045 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1046
1047 if (limitsOk)
1048 return tcu::TestStatus::pass("pass");
1049 else
1050 return tcu::TestStatus::fail("fail");
1051 }
1052
checkSupportExtExternalMemoryHost(Context & context)1053 void checkSupportExtExternalMemoryHost (Context& context)
1054 {
1055 context.requireDeviceFunctionality("VK_EXT_external_memory_host");
1056 }
1057
validateLimitsExtExternalMemoryHost(Context & context)1058 tcu::TestStatus validateLimitsExtExternalMemoryHost (Context& context)
1059 {
1060 const VkBool32 checkAlways = VK_TRUE;
1061 const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& externalMemoryHostPropertiesEXT = context.getExternalMemoryHostPropertiesEXT();
1062 TestLog& log = context.getTestContext().getLog();
1063 bool limitsOk = true;
1064
1065 FeatureLimitTableItem featureLimitTable[] =
1066 {
1067 { PN(checkAlways), PN(externalMemoryHostPropertiesEXT.minImportedHostPointerAlignment), LIM_MAX_DEVSIZE(65536) },
1068 };
1069
1070 log << TestLog::Message << externalMemoryHostPropertiesEXT << TestLog::EndMessage;
1071
1072 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1073 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1074
1075 if (limitsOk)
1076 return tcu::TestStatus::pass("pass");
1077 else
1078 return tcu::TestStatus::fail("fail");
1079 }
1080
checkSupportExtBlendOperationAdvanced(Context & context)1081 void checkSupportExtBlendOperationAdvanced (Context& context)
1082 {
1083 context.requireDeviceFunctionality("VK_EXT_blend_operation_advanced");
1084 }
1085
validateLimitsExtBlendOperationAdvanced(Context & context)1086 tcu::TestStatus validateLimitsExtBlendOperationAdvanced (Context& context)
1087 {
1088 const VkBool32 checkAlways = VK_TRUE;
1089 const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& blendOperationAdvancedPropertiesEXT = context.getBlendOperationAdvancedPropertiesEXT();
1090 TestLog& log = context.getTestContext().getLog();
1091 bool limitsOk = true;
1092
1093 FeatureLimitTableItem featureLimitTable[] =
1094 {
1095 { PN(checkAlways), PN(blendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments), LIM_MIN_UINT32(1) },
1096 };
1097
1098 log << TestLog::Message << blendOperationAdvancedPropertiesEXT << TestLog::EndMessage;
1099
1100 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1101 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1102
1103 if (limitsOk)
1104 return tcu::TestStatus::pass("pass");
1105 else
1106 return tcu::TestStatus::fail("fail");
1107 }
1108
checkSupportKhrMaintenance3(Context & context)1109 void checkSupportKhrMaintenance3 (Context& context)
1110 {
1111 context.requireDeviceFunctionality("VK_KHR_maintenance3");
1112 }
1113
checkSupportKhrMaintenance4(Context & context)1114 void checkSupportKhrMaintenance4 (Context& context)
1115 {
1116 context.requireDeviceFunctionality("VK_KHR_maintenance4");
1117 }
1118
validateLimitsKhrMaintenance3(Context & context)1119 tcu::TestStatus validateLimitsKhrMaintenance3 (Context& context)
1120 {
1121 const VkBool32 checkAlways = VK_TRUE;
1122 const VkPhysicalDeviceMaintenance3Properties& maintenance3Properties = context.getMaintenance3Properties();
1123 TestLog& log = context.getTestContext().getLog();
1124 bool limitsOk = true;
1125
1126 FeatureLimitTableItem featureLimitTable[] =
1127 {
1128 { PN(checkAlways), PN(maintenance3Properties.maxPerSetDescriptors), LIM_MIN_UINT32(1024) },
1129 { PN(checkAlways), PN(maintenance3Properties.maxMemoryAllocationSize), LIM_MIN_DEVSIZE(1<<30) },
1130 };
1131
1132 log << TestLog::Message << maintenance3Properties << TestLog::EndMessage;
1133
1134 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1135 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1136
1137 if (limitsOk)
1138 return tcu::TestStatus::pass("pass");
1139 else
1140 return tcu::TestStatus::fail("fail");
1141 }
1142
validateLimitsKhrMaintenance4(Context & context)1143 tcu::TestStatus validateLimitsKhrMaintenance4 (Context& context)
1144 {
1145 const VkBool32 checkAlways = VK_TRUE;
1146 const VkPhysicalDeviceMaintenance4Properties& maintenance4Properties = context.getMaintenance4Properties();
1147 TestLog& log = context.getTestContext().getLog();
1148 bool limitsOk = true;
1149
1150 FeatureLimitTableItem featureLimitTable[] =
1151 {
1152 { PN(checkAlways), PN(maintenance4Properties.maxBufferSize), LIM_MIN_DEVSIZE(1<<30) },
1153 };
1154
1155 log << TestLog::Message << maintenance4Properties << TestLog::EndMessage;
1156
1157 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1158 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1159
1160 if (limitsOk)
1161 return tcu::TestStatus::pass("pass");
1162 else
1163 return tcu::TestStatus::fail("fail");
1164 }
1165
checkSupportExtConservativeRasterization(Context & context)1166 void checkSupportExtConservativeRasterization (Context& context)
1167 {
1168 context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
1169 }
1170
validateLimitsExtConservativeRasterization(Context & context)1171 tcu::TestStatus validateLimitsExtConservativeRasterization (Context& context)
1172 {
1173 const VkBool32 checkAlways = VK_TRUE;
1174 const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& conservativeRasterizationPropertiesEXT = context.getConservativeRasterizationPropertiesEXT();
1175 TestLog& log = context.getTestContext().getLog();
1176 bool limitsOk = true;
1177
1178 FeatureLimitTableItem featureLimitTable[] =
1179 {
1180 { PN(checkAlways), PN(conservativeRasterizationPropertiesEXT.primitiveOverestimationSize), LIM_MIN_FLOAT(0.0f) },
1181 { PN(checkAlways), PN(conservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize), LIM_MIN_FLOAT(0.0f) },
1182 { PN(checkAlways), PN(conservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity), LIM_MIN_FLOAT(0.0f) },
1183 };
1184
1185 log << TestLog::Message << conservativeRasterizationPropertiesEXT << TestLog::EndMessage;
1186
1187 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1188 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1189
1190 if (limitsOk)
1191 return tcu::TestStatus::pass("pass");
1192 else
1193 return tcu::TestStatus::fail("fail");
1194 }
1195
checkSupportExtDescriptorIndexing(Context & context)1196 void checkSupportExtDescriptorIndexing (Context& context)
1197 {
1198 const std::string& requiredDeviceExtension = "VK_EXT_descriptor_indexing";
1199 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1200 const InstanceInterface& vki = context.getInstanceInterface();
1201 const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1202
1203 if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1204 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1205
1206 // Extension string is present, then extension is really supported and should have been added into chain in DefaultDevice properties and features
1207 }
1208
validateLimitsExtDescriptorIndexing(Context & context)1209 tcu::TestStatus validateLimitsExtDescriptorIndexing (Context& context)
1210 {
1211 const VkBool32 checkAlways = VK_TRUE;
1212 const VkPhysicalDeviceProperties2& properties2 = context.getDeviceProperties2();
1213 const VkPhysicalDeviceLimits& limits = properties2.properties.limits;
1214 const VkPhysicalDeviceDescriptorIndexingPropertiesEXT& descriptorIndexingPropertiesEXT = context.getDescriptorIndexingProperties();
1215 const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures();
1216 const deUint32 tessellationShaderCount = (features.tessellationShader) ? 2 : 0;
1217 const deUint32 geometryShaderCount = (features.geometryShader) ? 1 : 0;
1218 const deUint32 shaderStages = 3 + tessellationShaderCount + geometryShaderCount;
1219 TestLog& log = context.getTestContext().getLog();
1220 bool limitsOk = true;
1221
1222 FeatureLimitTableItem featureLimitTable[] =
1223 {
1224 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxUpdateAfterBindDescriptorsInAllPools), LIM_MIN_UINT32(500000) },
1225 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSamplers), LIM_MIN_UINT32(500000) },
1226 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(12) },
1227 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(500000) },
1228 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSampledImages), LIM_MIN_UINT32(500000) },
1229 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageImages), LIM_MIN_UINT32(500000) },
1230 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInputAttachments), LIM_MIN_UINT32(4) },
1231 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageUpdateAfterBindResources), LIM_MIN_UINT32(500000) },
1232 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSamplers), LIM_MIN_UINT32(500000) },
1233 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(shaderStages * 12) },
1234 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), LIM_MIN_UINT32(8) },
1235 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(500000) },
1236 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), LIM_MIN_UINT32(4) },
1237 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSampledImages), LIM_MIN_UINT32(500000) },
1238 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageImages), LIM_MIN_UINT32(500000) },
1239 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindInputAttachments), LIM_MIN_UINT32(4) },
1240 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSamplers), LIM_MIN_UINT32(limits.maxPerStageDescriptorSamplers) },
1241 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(limits.maxPerStageDescriptorUniformBuffers) },
1242 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageBuffers) },
1243 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSampledImages), LIM_MIN_UINT32(limits.maxPerStageDescriptorSampledImages) },
1244 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageImages), LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageImages) },
1245 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInputAttachments), LIM_MIN_UINT32(limits.maxPerStageDescriptorInputAttachments) },
1246 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxPerStageUpdateAfterBindResources), LIM_MIN_UINT32(limits.maxPerStageResources) },
1247 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSamplers), LIM_MIN_UINT32(limits.maxDescriptorSetSamplers) },
1248 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffers), LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffers) },
1249 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic), LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffersDynamic) },
1250 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffers), LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffers) },
1251 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic), LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffersDynamic) },
1252 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSampledImages), LIM_MIN_UINT32(limits.maxDescriptorSetSampledImages) },
1253 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageImages), LIM_MIN_UINT32(limits.maxDescriptorSetStorageImages) },
1254 { PN(checkAlways), PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindInputAttachments), LIM_MIN_UINT32(limits.maxDescriptorSetInputAttachments) },
1255 };
1256
1257 log << TestLog::Message << descriptorIndexingPropertiesEXT << TestLog::EndMessage;
1258
1259 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1260 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1261
1262 if (limitsOk)
1263 return tcu::TestStatus::pass("pass");
1264 else
1265 return tcu::TestStatus::fail("fail");
1266 }
1267
checkSupportExtInlineUniformBlock(Context & context)1268 void checkSupportExtInlineUniformBlock (Context& context)
1269 {
1270 context.requireDeviceFunctionality("VK_EXT_inline_uniform_block");
1271 }
1272
validateLimitsExtInlineUniformBlock(Context & context)1273 tcu::TestStatus validateLimitsExtInlineUniformBlock (Context& context)
1274 {
1275 const VkBool32 checkAlways = VK_TRUE;
1276 const VkPhysicalDeviceInlineUniformBlockProperties& inlineUniformBlockPropertiesEXT = context.getInlineUniformBlockProperties();
1277 TestLog& log = context.getTestContext().getLog();
1278 bool limitsOk = true;
1279
1280 FeatureLimitTableItem featureLimitTable[] =
1281 {
1282 { PN(checkAlways), PN(inlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize), LIM_MIN_UINT32(256) },
1283 { PN(checkAlways), PN(inlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks), LIM_MIN_UINT32(4) },
1284 { PN(checkAlways), PN(inlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks), LIM_MIN_UINT32(4) },
1285 { PN(checkAlways), PN(inlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks), LIM_MIN_UINT32(4) },
1286 { PN(checkAlways), PN(inlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks), LIM_MIN_UINT32(4) },
1287 };
1288
1289 log << TestLog::Message << inlineUniformBlockPropertiesEXT << TestLog::EndMessage;
1290
1291 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1292 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1293
1294 if (limitsOk)
1295 return tcu::TestStatus::pass("pass");
1296 else
1297 return tcu::TestStatus::fail("fail");
1298 }
1299
checkSupportExtVertexAttributeDivisor(Context & context)1300 void checkSupportExtVertexAttributeDivisor (Context& context)
1301 {
1302 context.requireDeviceFunctionality("VK_EXT_vertex_attribute_divisor");
1303 }
1304
validateLimitsExtVertexAttributeDivisor(Context & context)1305 tcu::TestStatus validateLimitsExtVertexAttributeDivisor (Context& context)
1306 {
1307 const VkBool32 checkAlways = VK_TRUE;
1308 const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& vertexAttributeDivisorPropertiesEXT = context.getVertexAttributeDivisorPropertiesEXT();
1309 TestLog& log = context.getTestContext().getLog();
1310 bool limitsOk = true;
1311
1312 FeatureLimitTableItem featureLimitTable[] =
1313 {
1314 { PN(checkAlways), PN(vertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor), LIM_MIN_UINT32((1<<16) - 1) },
1315 };
1316
1317 log << TestLog::Message << vertexAttributeDivisorPropertiesEXT << TestLog::EndMessage;
1318
1319 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1320 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1321
1322 if (limitsOk)
1323 return tcu::TestStatus::pass("pass");
1324 else
1325 return tcu::TestStatus::fail("fail");
1326 }
1327
checkSupportNvMeshShader(Context & context)1328 void checkSupportNvMeshShader (Context& context)
1329 {
1330 const std::string& requiredDeviceExtension = "VK_NV_mesh_shader";
1331 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1332 const InstanceInterface& vki = context.getInstanceInterface();
1333 const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1334
1335 if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1336 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1337 }
1338
validateLimitsNvMeshShader(Context & context)1339 tcu::TestStatus validateLimitsNvMeshShader (Context& context)
1340 {
1341 const VkBool32 checkAlways = VK_TRUE;
1342 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1343 const InstanceInterface& vki = context.getInstanceInterface();
1344 TestLog& log = context.getTestContext().getLog();
1345 bool limitsOk = true;
1346 VkPhysicalDeviceMeshShaderPropertiesNV meshShaderPropertiesNV = initVulkanStructure();
1347 VkPhysicalDeviceProperties2 properties2 = initVulkanStructure(&meshShaderPropertiesNV);
1348
1349 vki.getPhysicalDeviceProperties2(physicalDevice, &properties2);
1350
1351 FeatureLimitTableItem featureLimitTable[] =
1352 {
1353 { PN(checkAlways), PN(meshShaderPropertiesNV.maxDrawMeshTasksCount), LIM_MIN_UINT32(deUint32((1ull<<16) - 1)) },
1354 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskWorkGroupInvocations), LIM_MIN_UINT32(32) },
1355 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[0]), LIM_MIN_UINT32(32) },
1356 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[1]), LIM_MIN_UINT32(1) },
1357 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[2]), LIM_MIN_UINT32(1) },
1358 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskTotalMemorySize), LIM_MIN_UINT32(16384) },
1359 { PN(checkAlways), PN(meshShaderPropertiesNV.maxTaskOutputCount), LIM_MIN_UINT32((1<<16) - 1) },
1360 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshWorkGroupInvocations), LIM_MIN_UINT32(32) },
1361 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[0]), LIM_MIN_UINT32(32) },
1362 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[1]), LIM_MIN_UINT32(1) },
1363 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[2]), LIM_MIN_UINT32(1) },
1364 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshTotalMemorySize), LIM_MIN_UINT32(16384) },
1365 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshOutputVertices), LIM_MIN_UINT32(256) },
1366 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshOutputPrimitives), LIM_MIN_UINT32(256) },
1367 { PN(checkAlways), PN(meshShaderPropertiesNV.maxMeshMultiviewViewCount), LIM_MIN_UINT32(1) },
1368 };
1369
1370 log << TestLog::Message << meshShaderPropertiesNV << TestLog::EndMessage;
1371
1372 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1373 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1374
1375 if (limitsOk)
1376 return tcu::TestStatus::pass("pass");
1377 else
1378 return tcu::TestStatus::fail("fail");
1379 }
1380
checkSupportExtTransformFeedback(Context & context)1381 void checkSupportExtTransformFeedback (Context& context)
1382 {
1383 context.requireDeviceFunctionality("VK_EXT_transform_feedback");
1384 }
1385
validateLimitsExtTransformFeedback(Context & context)1386 tcu::TestStatus validateLimitsExtTransformFeedback (Context& context)
1387 {
1388 const VkBool32 checkAlways = VK_TRUE;
1389 const VkPhysicalDeviceTransformFeedbackPropertiesEXT& transformFeedbackPropertiesEXT = context.getTransformFeedbackPropertiesEXT();
1390 TestLog& log = context.getTestContext().getLog();
1391 bool limitsOk = true;
1392
1393 FeatureLimitTableItem featureLimitTable[] =
1394 {
1395 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackStreams), LIM_MIN_UINT32(1) },
1396 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBuffers), LIM_MIN_UINT32(1) },
1397 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize), LIM_MIN_DEVSIZE(1ull<<27) },
1398 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize), LIM_MIN_UINT32(512) },
1399 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize), LIM_MIN_UINT32(512) },
1400 { PN(checkAlways), PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride), LIM_MIN_UINT32(512) },
1401 };
1402
1403 log << TestLog::Message << transformFeedbackPropertiesEXT << TestLog::EndMessage;
1404
1405 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1406 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1407
1408 if (limitsOk)
1409 return tcu::TestStatus::pass("pass");
1410 else
1411 return tcu::TestStatus::fail("fail");
1412 }
1413
checkSupportExtFragmentDensityMap(Context & context)1414 void checkSupportExtFragmentDensityMap (Context& context)
1415 {
1416 context.requireDeviceFunctionality("VK_EXT_fragment_density_map");
1417 }
1418
validateLimitsExtFragmentDensityMap(Context & context)1419 tcu::TestStatus validateLimitsExtFragmentDensityMap (Context& context)
1420 {
1421 const VkBool32 checkAlways = VK_TRUE;
1422 const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& fragmentDensityMapPropertiesEXT = context.getFragmentDensityMapPropertiesEXT();
1423 TestLog& log = context.getTestContext().getLog();
1424 bool limitsOk = true;
1425
1426 FeatureLimitTableItem featureLimitTable[] =
1427 {
1428 { PN(checkAlways), PN(fragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize.width), LIM_MIN_UINT32(1) },
1429 { PN(checkAlways), PN(fragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize.height), LIM_MIN_UINT32(1) },
1430 { PN(checkAlways), PN(fragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize.width), LIM_MIN_UINT32(1) },
1431 { PN(checkAlways), PN(fragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize.height), LIM_MIN_UINT32(1) },
1432 };
1433
1434 log << TestLog::Message << fragmentDensityMapPropertiesEXT << TestLog::EndMessage;
1435
1436 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1437 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1438
1439 if (limitsOk)
1440 return tcu::TestStatus::pass("pass");
1441 else
1442 return tcu::TestStatus::fail("fail");
1443 }
1444
checkSupportNvRayTracing(Context & context)1445 void checkSupportNvRayTracing (Context& context)
1446 {
1447 const std::string& requiredDeviceExtension = "VK_NV_ray_tracing";
1448 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1449 const InstanceInterface& vki = context.getInstanceInterface();
1450 const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1451
1452 if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1453 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1454 }
1455
validateLimitsNvRayTracing(Context & context)1456 tcu::TestStatus validateLimitsNvRayTracing (Context& context)
1457 {
1458 const VkBool32 checkAlways = VK_TRUE;
1459 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1460 const InstanceInterface& vki = context.getInstanceInterface();
1461 TestLog& log = context.getTestContext().getLog();
1462 bool limitsOk = true;
1463 VkPhysicalDeviceRayTracingPropertiesNV rayTracingPropertiesNV = initVulkanStructure();
1464 VkPhysicalDeviceProperties2 properties2 = initVulkanStructure(&rayTracingPropertiesNV);
1465
1466 vki.getPhysicalDeviceProperties2(physicalDevice, &properties2);
1467
1468 FeatureLimitTableItem featureLimitTable[] =
1469 {
1470 { PN(checkAlways), PN(rayTracingPropertiesNV.shaderGroupHandleSize), LIM_MIN_UINT32(16) },
1471 { PN(checkAlways), PN(rayTracingPropertiesNV.maxRecursionDepth), LIM_MIN_UINT32(31) },
1472 { PN(checkAlways), PN(rayTracingPropertiesNV.shaderGroupBaseAlignment), LIM_MIN_UINT32(64) },
1473 { PN(checkAlways), PN(rayTracingPropertiesNV.maxGeometryCount), LIM_MIN_UINT32((1<<24) - 1) },
1474 { PN(checkAlways), PN(rayTracingPropertiesNV.maxInstanceCount), LIM_MIN_UINT32((1<<24) - 1) },
1475 { PN(checkAlways), PN(rayTracingPropertiesNV.maxTriangleCount), LIM_MIN_UINT32((1<<29) - 1) },
1476 { PN(checkAlways), PN(rayTracingPropertiesNV.maxDescriptorSetAccelerationStructures), LIM_MIN_UINT32(16) },
1477 };
1478
1479 log << TestLog::Message << rayTracingPropertiesNV << TestLog::EndMessage;
1480
1481 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1482 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1483
1484 if (limitsOk)
1485 return tcu::TestStatus::pass("pass");
1486 else
1487 return tcu::TestStatus::fail("fail");
1488 }
1489
checkSupportKhrTimelineSemaphore(Context & context)1490 void checkSupportKhrTimelineSemaphore (Context& context)
1491 {
1492 context.requireDeviceFunctionality("VK_KHR_timeline_semaphore");
1493 }
1494
validateLimitsKhrTimelineSemaphore(Context & context)1495 tcu::TestStatus validateLimitsKhrTimelineSemaphore (Context& context)
1496 {
1497 const VkBool32 checkAlways = VK_TRUE;
1498 const VkPhysicalDeviceTimelineSemaphorePropertiesKHR& timelineSemaphorePropertiesKHR = context.getTimelineSemaphoreProperties();
1499 bool limitsOk = true;
1500 TestLog& log = context.getTestContext().getLog();
1501
1502 FeatureLimitTableItem featureLimitTable[] =
1503 {
1504 { PN(checkAlways), PN(timelineSemaphorePropertiesKHR.maxTimelineSemaphoreValueDifference), LIM_MIN_DEVSIZE((1ull<<31) - 1) },
1505 };
1506
1507 log << TestLog::Message << timelineSemaphorePropertiesKHR << TestLog::EndMessage;
1508
1509 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1510 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1511
1512 if (limitsOk)
1513 return tcu::TestStatus::pass("pass");
1514 else
1515 return tcu::TestStatus::fail("fail");
1516 }
1517
checkSupportExtLineRasterization(Context & context)1518 void checkSupportExtLineRasterization (Context& context)
1519 {
1520 context.requireDeviceFunctionality("VK_EXT_line_rasterization");
1521 }
1522
validateLimitsExtLineRasterization(Context & context)1523 tcu::TestStatus validateLimitsExtLineRasterization (Context& context)
1524 {
1525 const VkBool32 checkAlways = VK_TRUE;
1526 const VkPhysicalDeviceLineRasterizationPropertiesEXT& lineRasterizationPropertiesEXT = context.getLineRasterizationPropertiesEXT();
1527 TestLog& log = context.getTestContext().getLog();
1528 bool limitsOk = true;
1529
1530 FeatureLimitTableItem featureLimitTable[] =
1531 {
1532 { PN(checkAlways), PN(lineRasterizationPropertiesEXT.lineSubPixelPrecisionBits), LIM_MIN_UINT32(4) },
1533 };
1534
1535 log << TestLog::Message << lineRasterizationPropertiesEXT << TestLog::EndMessage;
1536
1537 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1538 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1539
1540 if (limitsOk)
1541 return tcu::TestStatus::pass("pass");
1542 else
1543 return tcu::TestStatus::fail("fail");
1544 }
1545
validateLimitsMaxInlineUniformTotalSize(Context & context)1546 tcu::TestStatus validateLimitsMaxInlineUniformTotalSize (Context& context)
1547 {
1548 const VkBool32 checkAlways = VK_TRUE;
1549 const VkPhysicalDeviceVulkan13Properties& vulkan13Properties = context.getDeviceVulkan13Properties();
1550 bool limitsOk = true;
1551 TestLog& log = context.getTestContext().getLog();
1552
1553 FeatureLimitTableItem featureLimitTable[] =
1554 {
1555 { PN(checkAlways), PN(vulkan13Properties.maxInlineUniformTotalSize), LIM_MIN_DEVSIZE(256) },
1556 };
1557
1558 log << TestLog::Message << vulkan13Properties << TestLog::EndMessage;
1559
1560 for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1561 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1562
1563 if (limitsOk)
1564 return tcu::TestStatus::pass("pass");
1565 else
1566 return tcu::TestStatus::fail("fail");
1567 }
1568
validateRoadmap2022(Context & context)1569 tcu::TestStatus validateRoadmap2022(Context& context)
1570 {
1571 if (context.getUsedApiVersion() < VK_API_VERSION_1_3)
1572 TCU_THROW(NotSupportedError, "Profile not supported");
1573
1574 const VkBool32 checkAlways = VK_TRUE;
1575 VkBool32 oneOrMoreChecksFailed = VK_FALSE;
1576 TestLog& log = context.getTestContext().getLog();
1577
1578 auto vk10Features = context.getDeviceFeatures();
1579 auto vk11Features = context.getDeviceVulkan11Features();
1580 auto vk12Features = context.getDeviceVulkan12Features();
1581
1582 const auto& vk10Properties = context.getDeviceProperties2();
1583 const auto& vk11Properties = context.getDeviceVulkan11Properties();
1584 const auto& vk12Properties = context.getDeviceVulkan12Properties();
1585 const auto& vk13Properties = context.getDeviceVulkan13Properties();
1586 const auto& limits = vk10Properties.properties.limits;
1587
1588 #define ROADMAP_FEATURE_ITEM(STRUC, FIELD) { &(STRUC), &(STRUC.FIELD), #STRUC "." #FIELD }
1589
1590 struct FeatureTable
1591 {
1592 void* structPtr;
1593 VkBool32* fieldPtr;
1594 const char* fieldName;
1595 };
1596
1597 std::vector<FeatureTable> featureTable
1598 {
1599 // Vulkan 1.0 Features
1600 ROADMAP_FEATURE_ITEM(vk10Features, fullDrawIndexUint32),
1601 ROADMAP_FEATURE_ITEM(vk10Features, imageCubeArray),
1602 ROADMAP_FEATURE_ITEM(vk10Features, independentBlend),
1603 ROADMAP_FEATURE_ITEM(vk10Features, sampleRateShading),
1604 ROADMAP_FEATURE_ITEM(vk10Features, drawIndirectFirstInstance),
1605 ROADMAP_FEATURE_ITEM(vk10Features, depthClamp),
1606 ROADMAP_FEATURE_ITEM(vk10Features, depthBiasClamp),
1607 ROADMAP_FEATURE_ITEM(vk10Features, samplerAnisotropy),
1608 ROADMAP_FEATURE_ITEM(vk10Features, occlusionQueryPrecise),
1609 ROADMAP_FEATURE_ITEM(vk10Features, fragmentStoresAndAtomics),
1610 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageImageExtendedFormats),
1611 ROADMAP_FEATURE_ITEM(vk10Features, shaderUniformBufferArrayDynamicIndexing),
1612 ROADMAP_FEATURE_ITEM(vk10Features, shaderSampledImageArrayDynamicIndexing),
1613 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageBufferArrayDynamicIndexing),
1614 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageImageArrayDynamicIndexing),
1615
1616 // Vulkan 1.1 Features
1617 ROADMAP_FEATURE_ITEM(vk11Features, samplerYcbcrConversion),
1618
1619 // Vulkan 1.2 Features
1620 ROADMAP_FEATURE_ITEM(vk12Features, samplerMirrorClampToEdge),
1621 ROADMAP_FEATURE_ITEM(vk12Features, descriptorIndexing),
1622 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformTexelBufferArrayDynamicIndexing),
1623 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageTexelBufferArrayDynamicIndexing),
1624 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformBufferArrayNonUniformIndexing),
1625 ROADMAP_FEATURE_ITEM(vk12Features, shaderSampledImageArrayNonUniformIndexing),
1626 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageBufferArrayNonUniformIndexing),
1627 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageImageArrayNonUniformIndexing),
1628 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformTexelBufferArrayNonUniformIndexing),
1629 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageTexelBufferArrayNonUniformIndexing),
1630 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingSampledImageUpdateAfterBind),
1631 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageImageUpdateAfterBind),
1632 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageBufferUpdateAfterBind),
1633 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingUniformTexelBufferUpdateAfterBind),
1634 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageTexelBufferUpdateAfterBind),
1635 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingUpdateUnusedWhilePending),
1636 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingPartiallyBound),
1637 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingVariableDescriptorCount),
1638 ROADMAP_FEATURE_ITEM(vk12Features, runtimeDescriptorArray),
1639 ROADMAP_FEATURE_ITEM(vk12Features, scalarBlockLayout),
1640 };
1641
1642 for (FeatureTable& testedFeature : featureTable)
1643 {
1644 if (!testedFeature.fieldPtr[0])
1645 {
1646 log << TestLog::Message
1647 << "Feature " << testedFeature.fieldName << "is not supported"
1648 << TestLog::EndMessage;
1649 oneOrMoreChecksFailed = VK_TRUE;
1650 }
1651 }
1652
1653 std::vector<FeatureLimitTableItem> featureLimitTable
1654 {
1655 // Vulkan 1.0 limits
1656 { PN(checkAlways), PN(limits.maxImageDimension1D), LIM_MIN_UINT32(8192) },
1657 { PN(checkAlways), PN(limits.maxImageDimension2D), LIM_MIN_UINT32(8192) },
1658 { PN(checkAlways), PN(limits.maxImageDimensionCube), LIM_MIN_UINT32(8192) },
1659 { PN(checkAlways), PN(limits.maxImageArrayLayers), LIM_MIN_UINT32(2048) },
1660 { PN(checkAlways), PN(limits.maxUniformBufferRange), LIM_MIN_UINT32(65536) },
1661 { PN(checkAlways), PN(limits.bufferImageGranularity), LIM_MAX_DEVSIZE(4096) },
1662 { PN(checkAlways), PN(limits.maxPerStageDescriptorSamplers), LIM_MIN_UINT32(64) },
1663 { PN(checkAlways), PN(limits.maxPerStageDescriptorUniformBuffers), LIM_MIN_UINT32(15) },
1664 { PN(checkAlways), PN(limits.maxPerStageDescriptorStorageBuffers), LIM_MIN_UINT32(30) },
1665 { PN(checkAlways), PN(limits.maxPerStageDescriptorSampledImages), LIM_MIN_UINT32(200) },
1666 { PN(checkAlways), PN(limits.maxPerStageDescriptorStorageImages), LIM_MIN_UINT32(16) },
1667 { PN(checkAlways), PN(limits.maxPerStageResources), LIM_MIN_UINT32(200) },
1668 { PN(checkAlways), PN(limits.maxDescriptorSetSamplers), LIM_MIN_UINT32(576) },
1669 { PN(checkAlways), PN(limits.maxDescriptorSetUniformBuffers), LIM_MIN_UINT32(90) },
1670 { PN(checkAlways), PN(limits.maxDescriptorSetStorageBuffers), LIM_MIN_UINT32(96) },
1671 { PN(checkAlways), PN(limits.maxDescriptorSetSampledImages), LIM_MIN_UINT32(1800) },
1672 { PN(checkAlways), PN(limits.maxDescriptorSetStorageImages), LIM_MIN_UINT32(144) },
1673 { PN(checkAlways), PN(limits.maxFragmentCombinedOutputResources), LIM_MIN_UINT32(16) },
1674 { PN(checkAlways), PN(limits.maxComputeWorkGroupInvocations), LIM_MIN_UINT32(256) },
1675 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[0]), LIM_MIN_UINT32(256) },
1676 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[1]), LIM_MIN_UINT32(256) },
1677 { PN(checkAlways), PN(limits.maxComputeWorkGroupSize[2]), LIM_MIN_UINT32(64) },
1678 { PN(checkAlways), PN(limits.subPixelPrecisionBits), LIM_MIN_UINT32(8) },
1679 { PN(checkAlways), PN(limits.mipmapPrecisionBits), LIM_MIN_UINT32(6) },
1680 { PN(checkAlways), PN(limits.maxSamplerLodBias), LIM_MIN_FLOAT(14.0f) },
1681 { PN(checkAlways), PN(limits.pointSizeGranularity), LIM_MAX_FLOAT(0.125f) },
1682 { PN(checkAlways), PN(limits.lineWidthGranularity), LIM_MAX_FLOAT(0.5f) },
1683 { PN(checkAlways), PN(limits.standardSampleLocations), LIM_MIN_UINT32(1) },
1684 { PN(checkAlways), PN(limits.maxColorAttachments), LIM_MIN_UINT32(7) },
1685
1686 // Vulkan 1.1 limits
1687 { PN(checkAlways), PN(vk11Properties.subgroupSize), LIM_MIN_UINT32(4) },
1688 { PN(checkAlways), PN(vk11Properties.subgroupSupportedStages), LIM_MIN_UINT32(VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_FRAGMENT_BIT) },
1689 { PN(checkAlways), PN(vk11Properties.subgroupSupportedOperations), LIM_MIN_UINT32(VK_SUBGROUP_FEATURE_BASIC_BIT|VK_SUBGROUP_FEATURE_VOTE_BIT|
1690 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT|VK_SUBGROUP_FEATURE_BALLOT_BIT|
1691 VK_SUBGROUP_FEATURE_SHUFFLE_BIT|VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT|
1692 VK_SUBGROUP_FEATURE_QUAD_BIT) },
1693 // Vulkan 1.2 limits
1694 { PN(checkAlways), PN(vk12Properties.shaderSignedZeroInfNanPreserveFloat16), LIM_MIN_UINT32(1) },
1695 { PN(checkAlways), PN(vk12Properties.shaderSignedZeroInfNanPreserveFloat32), LIM_MIN_UINT32(1) },
1696
1697 // Vulkan 1.3 limits
1698 { PN(checkAlways), PN(vk13Properties.maxSubgroupSize), LIM_MIN_UINT32(4) },
1699 };
1700
1701 for (const auto& featureLimit : featureLimitTable)
1702 oneOrMoreChecksFailed |= !validateLimit(featureLimit, log);
1703
1704 if (!context.isDeviceFunctionalitySupported("VK_KHR_global_priority"))
1705 {
1706 log << TestLog::Message
1707 << "VK_KHR_global_priority is not supported"
1708 << TestLog::EndMessage;
1709 oneOrMoreChecksFailed = VK_TRUE;
1710 }
1711
1712 if (oneOrMoreChecksFailed)
1713 TCU_THROW(NotSupportedError, "Profile not supported");
1714
1715 return tcu::TestStatus::pass("Profile supported");
1716 }
1717
createTestDevice(Context & context,void * pNext,const char * const * ppEnabledExtensionNames,deUint32 enabledExtensionCount)1718 void createTestDevice (Context& context, void* pNext, const char* const* ppEnabledExtensionNames, deUint32 enabledExtensionCount)
1719 {
1720 const PlatformInterface& platformInterface = context.getPlatformInterface();
1721 const auto validationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
1722 const Unique<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
1723 const InstanceDriver instanceDriver (platformInterface, instance.get());
1724 const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
1725 const deUint32 queueFamilyIndex = 0;
1726 const deUint32 queueCount = 1;
1727 const deUint32 queueIndex = 0;
1728 const float queuePriority = 1.0f;
1729 const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
1730 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
1731 {
1732 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
1733 DE_NULL, // const void* pNext;
1734 (VkDeviceQueueCreateFlags)0u, // VkDeviceQueueCreateFlags flags;
1735 queueFamilyIndex, // deUint32 queueFamilyIndex;
1736 queueCount, // deUint32 queueCount;
1737 &queuePriority, // const float* pQueuePriorities;
1738 };
1739 const VkDeviceCreateInfo deviceCreateInfo =
1740 {
1741 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
1742 pNext, // const void* pNext;
1743 (VkDeviceCreateFlags)0u, // VkDeviceCreateFlags flags;
1744 1, // deUint32 queueCreateInfoCount;
1745 &deviceQueueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
1746 0, // deUint32 enabledLayerCount;
1747 DE_NULL, // const char* const* ppEnabledLayerNames;
1748 enabledExtensionCount, // deUint32 enabledExtensionCount;
1749 ppEnabledExtensionNames, // const char* const* ppEnabledExtensionNames;
1750 DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
1751 };
1752 const Unique<VkDevice> device (createCustomDevice(validationEnabled, platformInterface, *instance, instanceDriver, physicalDevice, &deviceCreateInfo));
1753 const DeviceDriver deviceDriver (platformInterface, instance.get(), device.get());
1754 const VkQueue queue = getDeviceQueue(deviceDriver, *device, queueFamilyIndex, queueIndex);
1755
1756 VK_CHECK(deviceDriver.queueWaitIdle(queue));
1757 }
1758
cleanVulkanStruct(void * structPtr,size_t structSize)1759 void cleanVulkanStruct (void* structPtr, size_t structSize)
1760 {
1761 struct StructureBase
1762 {
1763 VkStructureType sType;
1764 void* pNext;
1765 };
1766
1767 VkStructureType sType = ((StructureBase*)structPtr)->sType;
1768
1769 deMemset(structPtr, 0, structSize);
1770
1771 ((StructureBase*)structPtr)->sType = sType;
1772 }
1773
1774 template <deUint32 VK_API_VERSION>
featureBitInfluenceOnDeviceCreate(Context & context)1775 tcu::TestStatus featureBitInfluenceOnDeviceCreate (Context& context)
1776 {
1777 #define FEATURE_TABLE_ITEM(CORE, EXT, FIELD, STR) { &(CORE), sizeof(CORE), &(CORE.FIELD), #CORE "." #FIELD, &(EXT), sizeof(EXT), &(EXT.FIELD), #EXT "." #FIELD, STR }
1778 #define DEPENDENCY_DUAL_ITEM(CORE, EXT, FIELD, PARENT) { &(CORE.FIELD), &(CORE.PARENT) }, { &(EXT.FIELD), &(EXT.PARENT) }
1779 #define DEPENDENCY_SINGLE_ITEM(CORE, FIELD, PARENT) { &(CORE.FIELD), &(CORE.PARENT) }
1780
1781 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1782 const InstanceInterface& vki = context.getInstanceInterface();
1783 TestLog& log = context.getTestContext().getLog();
1784 const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1785
1786 VkPhysicalDeviceFeatures2 features2 = initVulkanStructure();
1787
1788 VkPhysicalDeviceVulkan11Features vulkan11Features = initVulkanStructure();
1789 VkPhysicalDeviceVulkan12Features vulkan12Features = initVulkanStructure();
1790 VkPhysicalDevice16BitStorageFeaturesKHR sixteenBitStorageFeatures = initVulkanStructure();
1791 VkPhysicalDeviceMultiviewFeatures multiviewFeatures = initVulkanStructure();
1792 VkPhysicalDeviceVariablePointersFeatures variablePointersFeatures = initVulkanStructure();
1793 VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeatures = initVulkanStructure();
1794 VkPhysicalDeviceSamplerYcbcrConversionFeatures samplerYcbcrConversionFeatures = initVulkanStructure();
1795 VkPhysicalDeviceShaderDrawParametersFeatures shaderDrawParametersFeatures = initVulkanStructure();
1796 VkPhysicalDevice8BitStorageFeatures eightBitStorageFeatures = initVulkanStructure();
1797 VkPhysicalDeviceShaderAtomicInt64Features shaderAtomicInt64Features = initVulkanStructure();
1798 VkPhysicalDeviceShaderFloat16Int8Features shaderFloat16Int8Features = initVulkanStructure();
1799 VkPhysicalDeviceDescriptorIndexingFeatures descriptorIndexingFeatures = initVulkanStructure();
1800 VkPhysicalDeviceScalarBlockLayoutFeatures scalarBlockLayoutFeatures = initVulkanStructure();
1801 VkPhysicalDeviceImagelessFramebufferFeatures imagelessFramebufferFeatures = initVulkanStructure();
1802 VkPhysicalDeviceUniformBufferStandardLayoutFeatures uniformBufferStandardLayoutFeatures = initVulkanStructure();
1803 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures shaderSubgroupExtendedTypesFeatures = initVulkanStructure();
1804 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures separateDepthStencilLayoutsFeatures = initVulkanStructure();
1805 VkPhysicalDeviceHostQueryResetFeatures hostQueryResetFeatures = initVulkanStructure();
1806 VkPhysicalDeviceTimelineSemaphoreFeatures timelineSemaphoreFeatures = initVulkanStructure();
1807 VkPhysicalDeviceBufferDeviceAddressFeatures bufferDeviceAddressFeatures = initVulkanStructure();
1808 VkPhysicalDeviceVulkanMemoryModelFeatures vulkanMemoryModelFeatures = initVulkanStructure();
1809
1810 VkPhysicalDeviceVulkan13Features vulkan13Features = initVulkanStructure();
1811 VkPhysicalDeviceImageRobustnessFeatures imageRobustnessFeatures = initVulkanStructure();
1812 VkPhysicalDeviceInlineUniformBlockFeatures inlineUniformBlockFeatures = initVulkanStructure();
1813 VkPhysicalDevicePipelineCreationCacheControlFeatures pipelineCreationCacheControlFeatures = initVulkanStructure();
1814 VkPhysicalDevicePrivateDataFeatures privateDataFeatures = initVulkanStructure();
1815 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures shaderDemoteToHelperInvocationFeatures = initVulkanStructure();
1816 VkPhysicalDeviceShaderTerminateInvocationFeatures shaderTerminateInvocationFeatures = initVulkanStructure();
1817 VkPhysicalDeviceSubgroupSizeControlFeatures subgroupSizeControlFeatures = initVulkanStructure();
1818 VkPhysicalDeviceSynchronization2Features synchronization2Features = initVulkanStructure();
1819 VkPhysicalDeviceTextureCompressionASTCHDRFeatures textureCompressionASTCHDRFeatures = initVulkanStructure();
1820 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures zeroInitializeWorkgroupMemoryFeatures = initVulkanStructure();
1821 VkPhysicalDeviceDynamicRenderingFeatures dynamicRenderingFeatures = initVulkanStructure();
1822 VkPhysicalDeviceShaderIntegerDotProductFeatures shaderIntegerDotProductFeatures = initVulkanStructure();
1823 VkPhysicalDeviceMaintenance4Features maintenance4Features = initVulkanStructure();
1824
1825 struct UnusedExtensionFeatures
1826 {
1827 VkStructureType sType;
1828 void* pNext;
1829 VkBool32 descriptorIndexing;
1830 VkBool32 samplerFilterMinmax;
1831 } unusedExtensionFeatures;
1832
1833 struct FeatureTable
1834 {
1835 void* coreStructPtr;
1836 size_t coreStructSize;
1837 VkBool32* coreFieldPtr;
1838 const char* coreFieldName;
1839 void* extStructPtr;
1840 size_t extStructSize;
1841 VkBool32* extFieldPtr;
1842 const char* extFieldName;
1843 const char* extString;
1844 };
1845 struct FeatureDependencyTable
1846 {
1847 VkBool32* featurePtr;
1848 VkBool32* dependOnPtr;
1849 };
1850
1851 std::vector<FeatureTable> featureTable;
1852 std::vector<FeatureDependencyTable> featureDependencyTable;
1853
1854 if (VK_API_VERSION == VK_API_VERSION_1_2)
1855 {
1856 featureTable =
1857 {
1858 FEATURE_TABLE_ITEM(vulkan11Features, sixteenBitStorageFeatures, storageBuffer16BitAccess, "VK_KHR_16bit_storage"),
1859 FEATURE_TABLE_ITEM(vulkan11Features, sixteenBitStorageFeatures, uniformAndStorageBuffer16BitAccess, "VK_KHR_16bit_storage"),
1860 FEATURE_TABLE_ITEM(vulkan11Features, sixteenBitStorageFeatures, storagePushConstant16, "VK_KHR_16bit_storage"),
1861 FEATURE_TABLE_ITEM(vulkan11Features, sixteenBitStorageFeatures, storageInputOutput16, "VK_KHR_16bit_storage"),
1862 FEATURE_TABLE_ITEM(vulkan11Features, multiviewFeatures, multiview, "VK_KHR_multiview"),
1863 FEATURE_TABLE_ITEM(vulkan11Features, multiviewFeatures, multiviewGeometryShader, "VK_KHR_multiview"),
1864 FEATURE_TABLE_ITEM(vulkan11Features, multiviewFeatures, multiviewTessellationShader, "VK_KHR_multiview"),
1865 FEATURE_TABLE_ITEM(vulkan11Features, variablePointersFeatures, variablePointersStorageBuffer, "VK_KHR_variable_pointers"),
1866 FEATURE_TABLE_ITEM(vulkan11Features, variablePointersFeatures, variablePointers, "VK_KHR_variable_pointers"),
1867 FEATURE_TABLE_ITEM(vulkan11Features, protectedMemoryFeatures, protectedMemory, DE_NULL),
1868 FEATURE_TABLE_ITEM(vulkan11Features, samplerYcbcrConversionFeatures, samplerYcbcrConversion, "VK_KHR_sampler_ycbcr_conversion"),
1869 FEATURE_TABLE_ITEM(vulkan11Features, shaderDrawParametersFeatures, shaderDrawParameters, DE_NULL),
1870 FEATURE_TABLE_ITEM(vulkan12Features, eightBitStorageFeatures, storageBuffer8BitAccess, "VK_KHR_8bit_storage"),
1871 FEATURE_TABLE_ITEM(vulkan12Features, eightBitStorageFeatures, uniformAndStorageBuffer8BitAccess, "VK_KHR_8bit_storage"),
1872 FEATURE_TABLE_ITEM(vulkan12Features, eightBitStorageFeatures, storagePushConstant8, "VK_KHR_8bit_storage"),
1873 FEATURE_TABLE_ITEM(vulkan12Features, shaderAtomicInt64Features, shaderBufferInt64Atomics, "VK_KHR_shader_atomic_int64"),
1874 FEATURE_TABLE_ITEM(vulkan12Features, shaderAtomicInt64Features, shaderSharedInt64Atomics, "VK_KHR_shader_atomic_int64"),
1875 FEATURE_TABLE_ITEM(vulkan12Features, shaderFloat16Int8Features, shaderFloat16, "VK_KHR_shader_float16_int8"),
1876 FEATURE_TABLE_ITEM(vulkan12Features, shaderFloat16Int8Features, shaderInt8, "VK_KHR_shader_float16_int8"),
1877 FEATURE_TABLE_ITEM(vulkan12Features, unusedExtensionFeatures, descriptorIndexing, DE_NULL),
1878 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderInputAttachmentArrayDynamicIndexing, "VK_EXT_descriptor_indexing"),
1879 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderUniformTexelBufferArrayDynamicIndexing, "VK_EXT_descriptor_indexing"),
1880 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderStorageTexelBufferArrayDynamicIndexing, "VK_EXT_descriptor_indexing"),
1881 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderUniformBufferArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1882 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderSampledImageArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1883 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderStorageBufferArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1884 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderStorageImageArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1885 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderInputAttachmentArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1886 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderUniformTexelBufferArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1887 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, shaderStorageTexelBufferArrayNonUniformIndexing, "VK_EXT_descriptor_indexing"),
1888 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingUniformBufferUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1889 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingSampledImageUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1890 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingStorageImageUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1891 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingStorageBufferUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1892 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingUniformTexelBufferUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1893 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingStorageTexelBufferUpdateAfterBind, "VK_EXT_descriptor_indexing"),
1894 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingUpdateUnusedWhilePending, "VK_EXT_descriptor_indexing"),
1895 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingPartiallyBound, "VK_EXT_descriptor_indexing"),
1896 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, descriptorBindingVariableDescriptorCount, "VK_EXT_descriptor_indexing"),
1897 FEATURE_TABLE_ITEM(vulkan12Features, descriptorIndexingFeatures, runtimeDescriptorArray, "VK_EXT_descriptor_indexing"),
1898 FEATURE_TABLE_ITEM(vulkan12Features, unusedExtensionFeatures, samplerFilterMinmax, "VK_EXT_sampler_filter_minmax"),
1899 FEATURE_TABLE_ITEM(vulkan12Features, scalarBlockLayoutFeatures, scalarBlockLayout, "VK_EXT_scalar_block_layout"),
1900 FEATURE_TABLE_ITEM(vulkan12Features, imagelessFramebufferFeatures, imagelessFramebuffer, "VK_KHR_imageless_framebuffer"),
1901 FEATURE_TABLE_ITEM(vulkan12Features, uniformBufferStandardLayoutFeatures, uniformBufferStandardLayout, "VK_KHR_uniform_buffer_standard_layout"),
1902 FEATURE_TABLE_ITEM(vulkan12Features, shaderSubgroupExtendedTypesFeatures, shaderSubgroupExtendedTypes, "VK_KHR_shader_subgroup_extended_types"),
1903 FEATURE_TABLE_ITEM(vulkan12Features, separateDepthStencilLayoutsFeatures, separateDepthStencilLayouts, "VK_KHR_separate_depth_stencil_layouts"),
1904 FEATURE_TABLE_ITEM(vulkan12Features, hostQueryResetFeatures, hostQueryReset, "VK_EXT_host_query_reset"),
1905 FEATURE_TABLE_ITEM(vulkan12Features, timelineSemaphoreFeatures, timelineSemaphore, "VK_KHR_timeline_semaphore"),
1906 FEATURE_TABLE_ITEM(vulkan12Features, bufferDeviceAddressFeatures, bufferDeviceAddress, "VK_EXT_buffer_device_address"),
1907 FEATURE_TABLE_ITEM(vulkan12Features, bufferDeviceAddressFeatures, bufferDeviceAddressCaptureReplay, "VK_EXT_buffer_device_address"),
1908 FEATURE_TABLE_ITEM(vulkan12Features, bufferDeviceAddressFeatures, bufferDeviceAddressMultiDevice, "VK_EXT_buffer_device_address"),
1909 FEATURE_TABLE_ITEM(vulkan12Features, vulkanMemoryModelFeatures, vulkanMemoryModel, "VK_KHR_vulkan_memory_model"),
1910 FEATURE_TABLE_ITEM(vulkan12Features, vulkanMemoryModelFeatures, vulkanMemoryModelDeviceScope, "VK_KHR_vulkan_memory_model"),
1911 FEATURE_TABLE_ITEM(vulkan12Features, vulkanMemoryModelFeatures, vulkanMemoryModelAvailabilityVisibilityChains, "VK_KHR_vulkan_memory_model"),
1912 };
1913
1914 featureDependencyTable =
1915 {
1916 DEPENDENCY_DUAL_ITEM (vulkan11Features, multiviewFeatures, multiviewGeometryShader, multiview),
1917 DEPENDENCY_DUAL_ITEM (vulkan11Features, multiviewFeatures, multiviewTessellationShader, multiview),
1918 DEPENDENCY_DUAL_ITEM (vulkan11Features, variablePointersFeatures, variablePointers, variablePointersStorageBuffer),
1919 DEPENDENCY_DUAL_ITEM (vulkan12Features, bufferDeviceAddressFeatures, bufferDeviceAddressCaptureReplay, bufferDeviceAddress),
1920 DEPENDENCY_DUAL_ITEM (vulkan12Features, bufferDeviceAddressFeatures, bufferDeviceAddressMultiDevice, bufferDeviceAddress),
1921 DEPENDENCY_DUAL_ITEM (vulkan12Features, vulkanMemoryModelFeatures, vulkanMemoryModelDeviceScope, vulkanMemoryModel),
1922 DEPENDENCY_DUAL_ITEM (vulkan12Features, vulkanMemoryModelFeatures, vulkanMemoryModelAvailabilityVisibilityChains, vulkanMemoryModel),
1923 };
1924 }
1925 else // if (VK_API_VERSION == VK_API_VERSION_1_3)
1926 {
1927 featureTable =
1928 {
1929 FEATURE_TABLE_ITEM(vulkan13Features, imageRobustnessFeatures, robustImageAccess, "VK_EXT_image_robustness"),
1930 FEATURE_TABLE_ITEM(vulkan13Features, inlineUniformBlockFeatures, inlineUniformBlock, "VK_EXT_inline_uniform_block"),
1931 FEATURE_TABLE_ITEM(vulkan13Features, inlineUniformBlockFeatures, descriptorBindingInlineUniformBlockUpdateAfterBind, "VK_EXT_inline_uniform_block"),
1932 FEATURE_TABLE_ITEM(vulkan13Features, pipelineCreationCacheControlFeatures, pipelineCreationCacheControl, "VK_EXT_pipeline_creation_cache_control"),
1933 FEATURE_TABLE_ITEM(vulkan13Features, privateDataFeatures, privateData, "VK_EXT_private_data"),
1934 FEATURE_TABLE_ITEM(vulkan13Features, shaderDemoteToHelperInvocationFeatures, shaderDemoteToHelperInvocation, "VK_EXT_shader_demote_to_helper_invocation"),
1935 FEATURE_TABLE_ITEM(vulkan13Features, shaderTerminateInvocationFeatures, shaderTerminateInvocation, "VK_KHR_shader_terminate_invocation"),
1936 FEATURE_TABLE_ITEM(vulkan13Features, subgroupSizeControlFeatures, subgroupSizeControl, "VK_EXT_subgroup_size_control"),
1937 FEATURE_TABLE_ITEM(vulkan13Features, subgroupSizeControlFeatures, computeFullSubgroups, "VK_EXT_subgroup_size_control"),
1938 FEATURE_TABLE_ITEM(vulkan13Features, synchronization2Features, synchronization2, "VK_KHR_synchronization2"),
1939 FEATURE_TABLE_ITEM(vulkan13Features, textureCompressionASTCHDRFeatures, textureCompressionASTC_HDR, "VK_EXT_texture_compression_astc_hdr"),
1940 FEATURE_TABLE_ITEM(vulkan13Features, zeroInitializeWorkgroupMemoryFeatures, shaderZeroInitializeWorkgroupMemory, "VK_KHR_zero_initialize_workgroup_memory"),
1941 FEATURE_TABLE_ITEM(vulkan13Features, dynamicRenderingFeatures, dynamicRendering, "VK_KHR_dynamic_rendering"),
1942 FEATURE_TABLE_ITEM(vulkan13Features, shaderIntegerDotProductFeatures, shaderIntegerDotProduct, "VK_KHR_shader_integer_dot_product"),
1943 FEATURE_TABLE_ITEM(vulkan13Features, maintenance4Features, maintenance4, "VK_KHR_maintenance4"),
1944 };
1945 }
1946
1947 deMemset(&unusedExtensionFeatures, 0, sizeof(unusedExtensionFeatures));
1948
1949 for (FeatureTable& testedFeature : featureTable)
1950 {
1951 VkBool32 coreFeatureState= DE_FALSE;
1952 VkBool32 extFeatureState = DE_FALSE;
1953
1954 // Core test
1955 {
1956 void* structPtr = testedFeature.coreStructPtr;
1957 size_t structSize = testedFeature.coreStructSize;
1958 VkBool32* featurePtr = testedFeature.coreFieldPtr;
1959
1960 if (structPtr != &unusedExtensionFeatures)
1961 features2.pNext = structPtr;
1962
1963 vki.getPhysicalDeviceFeatures2(physicalDevice, &features2);
1964
1965 coreFeatureState = featurePtr[0];
1966
1967 log << TestLog::Message
1968 << "Feature status "
1969 << testedFeature.coreFieldName << "=" << coreFeatureState
1970 << TestLog::EndMessage;
1971
1972 if (coreFeatureState)
1973 {
1974 cleanVulkanStruct(structPtr, structSize);
1975
1976 featurePtr[0] = DE_TRUE;
1977
1978 for (FeatureDependencyTable featureDependency : featureDependencyTable)
1979 if (featureDependency.featurePtr == featurePtr)
1980 featureDependency.dependOnPtr[0] = DE_TRUE;
1981
1982 createTestDevice(context, &features2, DE_NULL, 0u);
1983 }
1984 }
1985
1986 // ext test
1987 {
1988 void* structPtr = testedFeature.extStructPtr;
1989 size_t structSize = testedFeature.extStructSize;
1990 VkBool32* featurePtr = testedFeature.extFieldPtr;
1991 const char* extStringPtr = testedFeature.extString;
1992
1993 if (structPtr != &unusedExtensionFeatures)
1994 features2.pNext = structPtr;
1995
1996 if (extStringPtr == DE_NULL || isExtensionSupported(deviceExtensionProperties, RequiredExtension(extStringPtr)))
1997 {
1998 vki.getPhysicalDeviceFeatures2(physicalDevice, &features2);
1999
2000 extFeatureState = *featurePtr;
2001
2002 log << TestLog::Message
2003 << "Feature status "
2004 << testedFeature.extFieldName << "=" << extFeatureState
2005 << TestLog::EndMessage;
2006
2007 if (extFeatureState)
2008 {
2009 cleanVulkanStruct(structPtr, structSize);
2010
2011 featurePtr[0] = DE_TRUE;
2012
2013 for (FeatureDependencyTable& featureDependency : featureDependencyTable)
2014 if (featureDependency.featurePtr == featurePtr)
2015 featureDependency.dependOnPtr[0] = DE_TRUE;
2016
2017 createTestDevice(context, &features2, &extStringPtr, (extStringPtr == DE_NULL) ? 0u : 1u );
2018 }
2019 }
2020 }
2021 }
2022
2023 return tcu::TestStatus::pass("pass");
2024 }
2025
2026 template<typename T>
2027 class CheckIncompleteResult
2028 {
2029 public:
~CheckIncompleteResult(void)2030 virtual ~CheckIncompleteResult (void) {}
2031 virtual void getResult (Context& context, T* data) = 0;
2032
operator ()(Context & context,tcu::ResultCollector & results,const std::size_t expectedCompleteSize)2033 void operator() (Context& context, tcu::ResultCollector& results, const std::size_t expectedCompleteSize)
2034 {
2035 if (expectedCompleteSize == 0)
2036 return;
2037
2038 vector<T> outputData (expectedCompleteSize);
2039 const deUint32 usedSize = static_cast<deUint32>(expectedCompleteSize / 3);
2040
2041 ValidateQueryBits::fillBits(outputData.begin(), outputData.end()); // unused entries should have this pattern intact
2042 m_count = usedSize;
2043 m_result = VK_SUCCESS;
2044
2045 getResult(context, &outputData[0]); // update m_count and m_result
2046
2047 if (m_count != usedSize || m_result != VK_INCOMPLETE || !ValidateQueryBits::checkBits(outputData.begin() + m_count, outputData.end()))
2048 results.fail("Query didn't return VK_INCOMPLETE");
2049 }
2050
2051 protected:
2052 deUint32 m_count;
2053 VkResult m_result;
2054 };
2055
2056 struct CheckEnumeratePhysicalDevicesIncompleteResult : public CheckIncompleteResult<VkPhysicalDevice>
2057 {
getResultvkt::api::__anona6c540bb0111::CheckEnumeratePhysicalDevicesIncompleteResult2058 void getResult (Context& context, VkPhysicalDevice* data)
2059 {
2060 m_result = context.getInstanceInterface().enumeratePhysicalDevices(context.getInstance(), &m_count, data);
2061 }
2062 };
2063
2064 struct CheckEnumeratePhysicalDeviceGroupsIncompleteResult : public CheckIncompleteResult<VkPhysicalDeviceGroupProperties>
2065 {
CheckEnumeratePhysicalDeviceGroupsIncompleteResultvkt::api::__anona6c540bb0111::CheckEnumeratePhysicalDeviceGroupsIncompleteResult2066 CheckEnumeratePhysicalDeviceGroupsIncompleteResult (const InstanceInterface& vki, const VkInstance instance)
2067 : m_vki (vki)
2068 , m_instance (instance)
2069 {}
2070
getResultvkt::api::__anona6c540bb0111::CheckEnumeratePhysicalDeviceGroupsIncompleteResult2071 void getResult (Context&, VkPhysicalDeviceGroupProperties* data)
2072 {
2073 for (uint32_t idx = 0u; idx < m_count; ++idx)
2074 data[idx] = initVulkanStructure();
2075 m_result = m_vki.enumeratePhysicalDeviceGroups(m_instance, &m_count, data);
2076 }
2077
2078 protected:
2079 const InstanceInterface& m_vki;
2080 const VkInstance m_instance;
2081 };
2082
2083 struct CheckEnumerateInstanceLayerPropertiesIncompleteResult : public CheckIncompleteResult<VkLayerProperties>
2084 {
getResultvkt::api::__anona6c540bb0111::CheckEnumerateInstanceLayerPropertiesIncompleteResult2085 void getResult (Context& context, VkLayerProperties* data)
2086 {
2087 m_result = context.getPlatformInterface().enumerateInstanceLayerProperties(&m_count, data);
2088 }
2089 };
2090
2091 struct CheckEnumerateDeviceLayerPropertiesIncompleteResult : public CheckIncompleteResult<VkLayerProperties>
2092 {
getResultvkt::api::__anona6c540bb0111::CheckEnumerateDeviceLayerPropertiesIncompleteResult2093 void getResult (Context& context, VkLayerProperties* data)
2094 {
2095 m_result = context.getInstanceInterface().enumerateDeviceLayerProperties(context.getPhysicalDevice(), &m_count, data);
2096 }
2097 };
2098
2099 struct CheckEnumerateInstanceExtensionPropertiesIncompleteResult : public CheckIncompleteResult<VkExtensionProperties>
2100 {
CheckEnumerateInstanceExtensionPropertiesIncompleteResultvkt::api::__anona6c540bb0111::CheckEnumerateInstanceExtensionPropertiesIncompleteResult2101 CheckEnumerateInstanceExtensionPropertiesIncompleteResult (std::string layerName = std::string()) : m_layerName(layerName) {}
2102
getResultvkt::api::__anona6c540bb0111::CheckEnumerateInstanceExtensionPropertiesIncompleteResult2103 void getResult (Context& context, VkExtensionProperties* data)
2104 {
2105 const char* pLayerName = (m_layerName.length() != 0 ? m_layerName.c_str() : DE_NULL);
2106 m_result = context.getPlatformInterface().enumerateInstanceExtensionProperties(pLayerName, &m_count, data);
2107 }
2108
2109 private:
2110 const std::string m_layerName;
2111 };
2112
2113 struct CheckEnumerateDeviceExtensionPropertiesIncompleteResult : public CheckIncompleteResult<VkExtensionProperties>
2114 {
CheckEnumerateDeviceExtensionPropertiesIncompleteResultvkt::api::__anona6c540bb0111::CheckEnumerateDeviceExtensionPropertiesIncompleteResult2115 CheckEnumerateDeviceExtensionPropertiesIncompleteResult (std::string layerName = std::string()) : m_layerName(layerName) {}
2116
getResultvkt::api::__anona6c540bb0111::CheckEnumerateDeviceExtensionPropertiesIncompleteResult2117 void getResult (Context& context, VkExtensionProperties* data)
2118 {
2119 const char* pLayerName = (m_layerName.length() != 0 ? m_layerName.c_str() : DE_NULL);
2120 m_result = context.getInstanceInterface().enumerateDeviceExtensionProperties(context.getPhysicalDevice(), pLayerName, &m_count, data);
2121 }
2122
2123 private:
2124 const std::string m_layerName;
2125 };
2126
enumeratePhysicalDevices(Context & context)2127 tcu::TestStatus enumeratePhysicalDevices (Context& context)
2128 {
2129 TestLog& log = context.getTestContext().getLog();
2130 tcu::ResultCollector results (log);
2131 const vector<VkPhysicalDevice> devices = enumeratePhysicalDevices(context.getInstanceInterface(), context.getInstance());
2132
2133 log << TestLog::Integer("NumDevices", "Number of devices", "", QP_KEY_TAG_NONE, deInt64(devices.size()));
2134
2135 for (size_t ndx = 0; ndx < devices.size(); ndx++)
2136 log << TestLog::Message << ndx << ": " << devices[ndx] << TestLog::EndMessage;
2137
2138 CheckEnumeratePhysicalDevicesIncompleteResult()(context, results, devices.size());
2139
2140 return tcu::TestStatus(results.getResult(), results.getMessage());
2141 }
2142
enumeratePhysicalDeviceGroups(Context & context)2143 tcu::TestStatus enumeratePhysicalDeviceGroups (Context& context)
2144 {
2145 TestLog& log = context.getTestContext().getLog();
2146 tcu::ResultCollector results (log);
2147 CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
2148 const InstanceDriver& vki (instance.getDriver());
2149 const vector<VkPhysicalDeviceGroupProperties> devicegroups = enumeratePhysicalDeviceGroups(vki, instance);
2150
2151 log << TestLog::Integer("NumDevices", "Number of device groups", "", QP_KEY_TAG_NONE, deInt64(devicegroups.size()));
2152
2153 for (size_t ndx = 0; ndx < devicegroups.size(); ndx++)
2154 log << TestLog::Message << ndx << ": " << devicegroups[ndx] << TestLog::EndMessage;
2155
2156 CheckEnumeratePhysicalDeviceGroupsIncompleteResult(vki, instance)(context, results, devicegroups.size());
2157
2158 instance.collectMessages();
2159 return tcu::TestStatus(results.getResult(), results.getMessage());
2160 }
2161
2162 template<typename T>
collectDuplicates(set<T> & duplicates,const vector<T> & values)2163 void collectDuplicates (set<T>& duplicates, const vector<T>& values)
2164 {
2165 set<T> seen;
2166
2167 for (size_t ndx = 0; ndx < values.size(); ndx++)
2168 {
2169 const T& value = values[ndx];
2170
2171 if (!seen.insert(value).second)
2172 duplicates.insert(value);
2173 }
2174 }
2175
checkDuplicates(tcu::ResultCollector & results,const char * what,const vector<string> & values)2176 void checkDuplicates (tcu::ResultCollector& results, const char* what, const vector<string>& values)
2177 {
2178 set<string> duplicates;
2179
2180 collectDuplicates(duplicates, values);
2181
2182 for (set<string>::const_iterator iter = duplicates.begin(); iter != duplicates.end(); ++iter)
2183 {
2184 std::ostringstream msg;
2185 msg << "Duplicate " << what << ": " << *iter;
2186 results.fail(msg.str());
2187 }
2188 }
2189
checkDuplicateExtensions(tcu::ResultCollector & results,const vector<string> & extensions)2190 void checkDuplicateExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2191 {
2192 checkDuplicates(results, "extension", extensions);
2193 }
2194
checkDuplicateLayers(tcu::ResultCollector & results,const vector<string> & layers)2195 void checkDuplicateLayers (tcu::ResultCollector& results, const vector<string>& layers)
2196 {
2197 checkDuplicates(results, "layer", layers);
2198 }
2199
checkKhrExtensions(tcu::ResultCollector & results,const vector<string> & extensions,const int numAllowedKhrExtensions,const char * const * allowedKhrExtensions)2200 void checkKhrExtensions (tcu::ResultCollector& results,
2201 const vector<string>& extensions,
2202 const int numAllowedKhrExtensions,
2203 const char* const* allowedKhrExtensions)
2204 {
2205 const set<string> allowedExtSet (allowedKhrExtensions, allowedKhrExtensions+numAllowedKhrExtensions);
2206
2207 for (vector<string>::const_iterator extIter = extensions.begin(); extIter != extensions.end(); ++extIter)
2208 {
2209 // Only Khronos-controlled extensions are checked
2210 if (de::beginsWith(*extIter, "VK_KHR_") &&
2211 !de::contains(allowedExtSet, *extIter))
2212 {
2213 results.fail("Unknown extension " + *extIter);
2214 }
2215 }
2216 }
2217
checkInstanceExtensions(tcu::ResultCollector & results,const vector<string> & extensions)2218 void checkInstanceExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2219 {
2220 #include "vkInstanceExtensions.inl"
2221
2222 checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedInstanceKhrExtensions), s_allowedInstanceKhrExtensions);
2223 checkDuplicateExtensions(results, extensions);
2224 }
2225
checkDeviceExtensions(tcu::ResultCollector & results,const vector<string> & extensions)2226 void checkDeviceExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2227 {
2228 #include "vkDeviceExtensions.inl"
2229
2230 checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedDeviceKhrExtensions), s_allowedDeviceKhrExtensions);
2231 checkDuplicateExtensions(results, extensions);
2232 }
2233
checkInstanceExtensionDependencies(tcu::ResultCollector & results,int dependencyLength,const std::tuple<deUint32,deUint32,const char *,const char * > * dependencies,deUint32 versionMajor,deUint32 versionMinor,const vector<VkExtensionProperties> & extensionProperties)2234 void checkInstanceExtensionDependencies(tcu::ResultCollector& results,
2235 int dependencyLength,
2236 const std::tuple<deUint32, deUint32, const char*, const char*>* dependencies,
2237 deUint32 versionMajor,
2238 deUint32 versionMinor,
2239 const vector<VkExtensionProperties>& extensionProperties)
2240 {
2241 for (int ndx = 0; ndx < dependencyLength; ndx++)
2242 {
2243 deUint32 currentVersionMajor, currentVersionMinor;
2244 const char* extensionFirst;
2245 const char* extensionSecond;
2246 std::tie(currentVersionMajor, currentVersionMinor, extensionFirst, extensionSecond) = dependencies[ndx];
2247 if (currentVersionMajor != versionMajor || currentVersionMinor != versionMinor)
2248 continue;
2249 if (isExtensionSupported(extensionProperties, RequiredExtension(extensionFirst)) &&
2250 !isExtensionSupported(extensionProperties, RequiredExtension(extensionSecond)))
2251 {
2252 results.fail("Extension " + string(extensionFirst) + " is missing dependency: " + string(extensionSecond));
2253 }
2254 }
2255 }
2256
checkDeviceExtensionDependencies(tcu::ResultCollector & results,int dependencyLength,const std::tuple<deUint32,deUint32,const char *,const char * > * dependencies,deUint32 versionMajor,deUint32 versionMinor,const vector<VkExtensionProperties> & instanceExtensionProperties,const vector<VkExtensionProperties> & deviceExtensionProperties)2257 void checkDeviceExtensionDependencies(tcu::ResultCollector& results,
2258 int dependencyLength,
2259 const std::tuple<deUint32, deUint32, const char*, const char*>* dependencies,
2260 deUint32 versionMajor,
2261 deUint32 versionMinor,
2262 const vector<VkExtensionProperties>& instanceExtensionProperties,
2263 const vector<VkExtensionProperties>& deviceExtensionProperties)
2264 {
2265 for (int ndx = 0; ndx < dependencyLength; ndx++)
2266 {
2267 deUint32 currentVersionMajor, currentVersionMinor;
2268 const char* extensionFirst;
2269 const char* extensionSecond;
2270 std::tie(currentVersionMajor, currentVersionMinor, extensionFirst, extensionSecond) = dependencies[ndx];
2271 if (currentVersionMajor != versionMajor || currentVersionMinor != versionMinor)
2272 continue;
2273 if (isExtensionSupported(deviceExtensionProperties, RequiredExtension(extensionFirst)) &&
2274 !isExtensionSupported(deviceExtensionProperties, RequiredExtension(extensionSecond)) &&
2275 !isExtensionSupported(instanceExtensionProperties, RequiredExtension(extensionSecond)))
2276 {
2277 results.fail("Extension " + string(extensionFirst) + " is missing dependency: " + string(extensionSecond));
2278 }
2279 }
2280 }
2281
enumerateInstanceLayers(Context & context)2282 tcu::TestStatus enumerateInstanceLayers (Context& context)
2283 {
2284 TestLog& log = context.getTestContext().getLog();
2285 tcu::ResultCollector results (log);
2286 const vector<VkLayerProperties> properties = enumerateInstanceLayerProperties(context.getPlatformInterface());
2287 vector<string> layerNames;
2288
2289 for (size_t ndx = 0; ndx < properties.size(); ndx++)
2290 {
2291 log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2292
2293 layerNames.push_back(properties[ndx].layerName);
2294 }
2295
2296 checkDuplicateLayers(results, layerNames);
2297 CheckEnumerateInstanceLayerPropertiesIncompleteResult()(context, results, layerNames.size());
2298
2299 return tcu::TestStatus(results.getResult(), results.getMessage());
2300 }
2301
enumerateInstanceExtensions(Context & context)2302 tcu::TestStatus enumerateInstanceExtensions (Context& context)
2303 {
2304 TestLog& log = context.getTestContext().getLog();
2305 tcu::ResultCollector results (log);
2306
2307 {
2308 const ScopedLogSection section (log, "Global", "Global Extensions");
2309 const vector<VkExtensionProperties> properties = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2310 vector<string> extensionNames;
2311
2312 for (size_t ndx = 0; ndx < properties.size(); ndx++)
2313 {
2314 log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2315
2316 extensionNames.push_back(properties[ndx].extensionName);
2317 }
2318
2319 checkInstanceExtensions(results, extensionNames);
2320 CheckEnumerateInstanceExtensionPropertiesIncompleteResult()(context, results, properties.size());
2321
2322 for (const auto& version : releasedApiVersions)
2323 {
2324 deUint32 versionMajor, versionMinor;
2325 std::tie(std::ignore, versionMajor, versionMinor) = version;
2326 if (context.contextSupports(vk::ApiVersion(versionMajor, versionMinor, 0)))
2327 {
2328 checkInstanceExtensionDependencies(results,
2329 DE_LENGTH_OF_ARRAY(instanceExtensionDependencies),
2330 instanceExtensionDependencies,
2331 versionMajor,
2332 versionMinor,
2333 properties);
2334 break;
2335 }
2336 }
2337 }
2338
2339 {
2340 const vector<VkLayerProperties> layers = enumerateInstanceLayerProperties(context.getPlatformInterface());
2341
2342 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
2343 {
2344 const ScopedLogSection section (log, layer->layerName, string("Layer: ") + layer->layerName);
2345 const vector<VkExtensionProperties> properties = enumerateInstanceExtensionProperties(context.getPlatformInterface(), layer->layerName);
2346 vector<string> extensionNames;
2347
2348 for (size_t extNdx = 0; extNdx < properties.size(); extNdx++)
2349 {
2350 log << TestLog::Message << extNdx << ": " << properties[extNdx] << TestLog::EndMessage;
2351
2352 extensionNames.push_back(properties[extNdx].extensionName);
2353 }
2354
2355 checkInstanceExtensions(results, extensionNames);
2356 CheckEnumerateInstanceExtensionPropertiesIncompleteResult(layer->layerName)(context, results, properties.size());
2357 }
2358 }
2359
2360 return tcu::TestStatus(results.getResult(), results.getMessage());
2361 }
2362
testNoKhxExtensions(Context & context)2363 tcu::TestStatus testNoKhxExtensions (Context& context)
2364 {
2365 VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
2366 const PlatformInterface& vkp = context.getPlatformInterface();
2367 const InstanceInterface& vki = context.getInstanceInterface();
2368
2369 tcu::ResultCollector results(context.getTestContext().getLog());
2370 bool testSucceeded = true;
2371 deUint32 instanceExtensionsCount;
2372 deUint32 deviceExtensionsCount;
2373
2374 // grab number of instance and device extensions
2375 vkp.enumerateInstanceExtensionProperties(DE_NULL, &instanceExtensionsCount, DE_NULL);
2376 vki.enumerateDeviceExtensionProperties(physicalDevice, DE_NULL, &deviceExtensionsCount, DE_NULL);
2377 vector<VkExtensionProperties> extensionsProperties(instanceExtensionsCount + deviceExtensionsCount);
2378
2379 // grab instance and device extensions into single vector
2380 if (instanceExtensionsCount)
2381 vkp.enumerateInstanceExtensionProperties(DE_NULL, &instanceExtensionsCount, &extensionsProperties[0]);
2382 if (deviceExtensionsCount)
2383 vki.enumerateDeviceExtensionProperties(physicalDevice, DE_NULL, &deviceExtensionsCount, &extensionsProperties[instanceExtensionsCount]);
2384
2385 // iterate over all extensions and verify their names
2386 vector<VkExtensionProperties>::const_iterator extension = extensionsProperties.begin();
2387 while (extension != extensionsProperties.end())
2388 {
2389 // KHX author ID is no longer used, all KHX extensions have been promoted to KHR status
2390 std::string extensionName(extension->extensionName);
2391 bool caseFailed = de::beginsWith(extensionName, "VK_KHX_");
2392 if (caseFailed)
2393 {
2394 results.fail("Invalid extension name " + extensionName);
2395 testSucceeded = false;
2396 }
2397 ++extension;
2398 }
2399
2400 if (testSucceeded)
2401 return tcu::TestStatus::pass("No extensions begining with \"VK_KHX\"");
2402 return tcu::TestStatus::fail("One or more extensions begins with \"VK_KHX\"");
2403 }
2404
enumerateDeviceLayers(Context & context)2405 tcu::TestStatus enumerateDeviceLayers (Context& context)
2406 {
2407 TestLog& log = context.getTestContext().getLog();
2408 tcu::ResultCollector results (log);
2409 const vector<VkLayerProperties> properties = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2410 vector<string> layerNames;
2411
2412 for (size_t ndx = 0; ndx < properties.size(); ndx++)
2413 {
2414 log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2415
2416 layerNames.push_back(properties[ndx].layerName);
2417 }
2418
2419 checkDuplicateLayers(results, layerNames);
2420 CheckEnumerateDeviceLayerPropertiesIncompleteResult()(context, results, layerNames.size());
2421
2422 return tcu::TestStatus(results.getResult(), results.getMessage());
2423 }
2424
enumerateDeviceExtensions(Context & context)2425 tcu::TestStatus enumerateDeviceExtensions (Context& context)
2426 {
2427 TestLog& log = context.getTestContext().getLog();
2428 tcu::ResultCollector results (log);
2429
2430 {
2431 const ScopedLogSection section (log, "Global", "Global Extensions");
2432 const vector<VkExtensionProperties> instanceExtensionProperties = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2433 const vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
2434 vector<string> deviceExtensionNames;
2435
2436 for (size_t ndx = 0; ndx < deviceExtensionProperties.size(); ndx++)
2437 {
2438 log << TestLog::Message << ndx << ": " << deviceExtensionProperties[ndx] << TestLog::EndMessage;
2439
2440 deviceExtensionNames.push_back(deviceExtensionProperties[ndx].extensionName);
2441 }
2442
2443 checkDeviceExtensions(results, deviceExtensionNames);
2444 CheckEnumerateDeviceExtensionPropertiesIncompleteResult()(context, results, deviceExtensionProperties.size());
2445
2446 for (const auto& version : releasedApiVersions)
2447 {
2448 deUint32 versionMajor, versionMinor;
2449 std::tie(std::ignore, versionMajor, versionMinor) = version;
2450 if (context.contextSupports(vk::ApiVersion(versionMajor, versionMinor, 0)))
2451 {
2452 checkDeviceExtensionDependencies(results,
2453 DE_LENGTH_OF_ARRAY(deviceExtensionDependencies),
2454 deviceExtensionDependencies,
2455 versionMajor,
2456 versionMinor,
2457 instanceExtensionProperties,
2458 deviceExtensionProperties);
2459 break;
2460 }
2461 }
2462 }
2463
2464 {
2465 const vector<VkLayerProperties> layers = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2466
2467 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
2468 {
2469 const ScopedLogSection section (log, layer->layerName, string("Layer: ") + layer->layerName);
2470 const vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), layer->layerName);
2471 vector<string> extensionNames;
2472
2473 for (size_t extNdx = 0; extNdx < properties.size(); extNdx++)
2474 {
2475 log << TestLog::Message << extNdx << ": " << properties[extNdx] << TestLog::EndMessage;
2476
2477
2478 extensionNames.push_back(properties[extNdx].extensionName);
2479 }
2480
2481 checkDeviceExtensions(results, extensionNames);
2482 CheckEnumerateDeviceExtensionPropertiesIncompleteResult(layer->layerName)(context, results, properties.size());
2483 }
2484 }
2485
2486 return tcu::TestStatus(results.getResult(), results.getMessage());
2487 }
2488
extensionCoreVersions(Context & context)2489 tcu::TestStatus extensionCoreVersions (Context& context)
2490 {
2491 deUint32 major;
2492 deUint32 minor;
2493 const char* extName;
2494
2495 auto& log = context.getTestContext().getLog();
2496 tcu::ResultCollector results (log);
2497
2498 const auto instanceExtensionProperties = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2499 const auto deviceExtensionProperties = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
2500
2501 for (const auto& majorMinorName : extensionRequiredCoreVersion)
2502 {
2503 std::tie(major, minor, extName) = majorMinorName;
2504 const RequiredExtension reqExt (extName);
2505
2506 if ((isExtensionSupported(instanceExtensionProperties, reqExt) || isExtensionSupported(deviceExtensionProperties, reqExt)) &&
2507 !context.contextSupports(vk::ApiVersion(major, minor, 0u)))
2508 {
2509 results.fail("Required core version for " + std::string(extName) + " not met (" + de::toString(major) + "." + de::toString(minor) + ")");
2510 }
2511 }
2512
2513 return tcu::TestStatus(results.getResult(), results.getMessage());
2514 }
2515
2516 #define VK_SIZE_OF(STRUCT, MEMBER) (sizeof(((STRUCT*)0)->MEMBER))
2517 #define OFFSET_TABLE_ENTRY(STRUCT, MEMBER) { (size_t)DE_OFFSET_OF(STRUCT, MEMBER), VK_SIZE_OF(STRUCT, MEMBER) }
2518
deviceFeatures(Context & context)2519 tcu::TestStatus deviceFeatures (Context& context)
2520 {
2521 using namespace ValidateQueryBits;
2522
2523 TestLog& log = context.getTestContext().getLog();
2524 VkPhysicalDeviceFeatures* features;
2525 deUint8 buffer[sizeof(VkPhysicalDeviceFeatures) + GUARD_SIZE];
2526
2527 const QueryMemberTableEntry featureOffsetTable[] =
2528 {
2529 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, robustBufferAccess),
2530 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fullDrawIndexUint32),
2531 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, imageCubeArray),
2532 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, independentBlend),
2533 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, geometryShader),
2534 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, tessellationShader),
2535 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sampleRateShading),
2536 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, dualSrcBlend),
2537 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, logicOp),
2538 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, multiDrawIndirect),
2539 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, drawIndirectFirstInstance),
2540 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthClamp),
2541 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthBiasClamp),
2542 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fillModeNonSolid),
2543 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthBounds),
2544 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, wideLines),
2545 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, largePoints),
2546 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, alphaToOne),
2547 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, multiViewport),
2548 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, samplerAnisotropy),
2549 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionETC2),
2550 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionASTC_LDR),
2551 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionBC),
2552 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, occlusionQueryPrecise),
2553 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, pipelineStatisticsQuery),
2554 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics),
2555 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fragmentStoresAndAtomics),
2556 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize),
2557 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderImageGatherExtended),
2558 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats),
2559 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageMultisample),
2560 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat),
2561 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat),
2562 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing),
2563 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing),
2564 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing),
2565 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing),
2566 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderClipDistance),
2567 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderCullDistance),
2568 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderFloat64),
2569 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderInt64),
2570 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderInt16),
2571 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderResourceResidency),
2572 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderResourceMinLod),
2573 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseBinding),
2574 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyBuffer),
2575 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyImage2D),
2576 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyImage3D),
2577 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency2Samples),
2578 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency4Samples),
2579 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency8Samples),
2580 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency16Samples),
2581 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyAliased),
2582 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, variableMultisampleRate),
2583 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, inheritedQueries),
2584 { 0, 0 }
2585 };
2586
2587 deMemset(buffer, GUARD_VALUE, sizeof(buffer));
2588 features = reinterpret_cast<VkPhysicalDeviceFeatures*>(buffer);
2589
2590 context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), features);
2591
2592 log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2593 << TestLog::Message << *features << TestLog::EndMessage;
2594
2595 // Requirements and dependencies
2596 {
2597 if (!features->robustBufferAccess)
2598 return tcu::TestStatus::fail("robustBufferAccess is not supported");
2599
2600 // multiViewport requires MultiViewport (SPIR-V capability) support, which depends on Geometry
2601 if (features->multiViewport && !features->geometryShader)
2602 return tcu::TestStatus::fail("multiViewport is supported but geometryShader is not");
2603 }
2604
2605 for (int ndx = 0; ndx < GUARD_SIZE; ndx++)
2606 {
2607 if (buffer[ndx + sizeof(VkPhysicalDeviceFeatures)] != GUARD_VALUE)
2608 {
2609 log << TestLog::Message << "deviceFeatures - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2610 return tcu::TestStatus::fail("deviceFeatures buffer overflow");
2611 }
2612 }
2613
2614 if (!validateInitComplete(context.getPhysicalDevice(), &InstanceInterface::getPhysicalDeviceFeatures, context.getInstanceInterface(), featureOffsetTable))
2615 {
2616 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceFeatures not completely initialized" << TestLog::EndMessage;
2617 return tcu::TestStatus::fail("deviceFeatures incomplete initialization");
2618 }
2619
2620 return tcu::TestStatus::pass("Query succeeded");
2621 }
2622
2623 static const ValidateQueryBits::QueryMemberTableEntry s_physicalDevicePropertiesOffsetTable[] =
2624 {
2625 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, apiVersion),
2626 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, driverVersion),
2627 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, vendorID),
2628 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, deviceID),
2629 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, deviceType),
2630 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, pipelineCacheUUID),
2631 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension1D),
2632 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension2D),
2633 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension3D),
2634 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimensionCube),
2635 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageArrayLayers),
2636 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelBufferElements),
2637 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxUniformBufferRange),
2638 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxStorageBufferRange),
2639 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPushConstantsSize),
2640 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxMemoryAllocationCount),
2641 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerAllocationCount),
2642 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.bufferImageGranularity),
2643 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sparseAddressSpaceSize),
2644 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxBoundDescriptorSets),
2645 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorSamplers),
2646 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorUniformBuffers),
2647 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorStorageBuffers),
2648 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorSampledImages),
2649 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorStorageImages),
2650 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorInputAttachments),
2651 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageResources),
2652 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetSamplers),
2653 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetUniformBuffers),
2654 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetUniformBuffersDynamic),
2655 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageBuffers),
2656 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageBuffersDynamic),
2657 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetSampledImages),
2658 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageImages),
2659 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetInputAttachments),
2660 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputAttributes),
2661 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputBindings),
2662 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputAttributeOffset),
2663 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputBindingStride),
2664 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexOutputComponents),
2665 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationGenerationLevel),
2666 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationPatchSize),
2667 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerVertexInputComponents),
2668 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerVertexOutputComponents),
2669 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerPatchOutputComponents),
2670 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlTotalOutputComponents),
2671 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationEvaluationInputComponents),
2672 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationEvaluationOutputComponents),
2673 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryShaderInvocations),
2674 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryInputComponents),
2675 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryOutputComponents),
2676 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryOutputVertices),
2677 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryTotalOutputComponents),
2678 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentInputComponents),
2679 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentOutputAttachments),
2680 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentDualSrcAttachments),
2681 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentCombinedOutputResources),
2682 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeSharedMemorySize),
2683 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupCount[3]),
2684 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupInvocations),
2685 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupSize[3]),
2686 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subPixelPrecisionBits),
2687 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subTexelPrecisionBits),
2688 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.mipmapPrecisionBits),
2689 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDrawIndexedIndexValue),
2690 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDrawIndirectCount),
2691 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerLodBias),
2692 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerAnisotropy),
2693 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxViewports),
2694 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxViewportDimensions[2]),
2695 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.viewportBoundsRange[2]),
2696 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.viewportSubPixelBits),
2697 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minMemoryMapAlignment),
2698 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelBufferOffsetAlignment),
2699 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minUniformBufferOffsetAlignment),
2700 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minStorageBufferOffsetAlignment),
2701 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelOffset),
2702 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelOffset),
2703 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelGatherOffset),
2704 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelGatherOffset),
2705 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minInterpolationOffset),
2706 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxInterpolationOffset),
2707 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subPixelInterpolationOffsetBits),
2708 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferWidth),
2709 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferHeight),
2710 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferLayers),
2711 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferColorSampleCounts),
2712 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferDepthSampleCounts),
2713 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferStencilSampleCounts),
2714 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferNoAttachmentsSampleCounts),
2715 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxColorAttachments),
2716 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageColorSampleCounts),
2717 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageIntegerSampleCounts),
2718 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageDepthSampleCounts),
2719 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageStencilSampleCounts),
2720 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.storageImageSampleCounts),
2721 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSampleMaskWords),
2722 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.timestampComputeAndGraphics),
2723 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.timestampPeriod),
2724 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxClipDistances),
2725 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxCullDistances),
2726 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxCombinedClipAndCullDistances),
2727 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.discreteQueuePriorities),
2728 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.pointSizeRange[2]),
2729 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.lineWidthRange[2]),
2730 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.pointSizeGranularity),
2731 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.lineWidthGranularity),
2732 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.strictLines),
2733 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.standardSampleLocations),
2734 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.optimalBufferCopyOffsetAlignment),
2735 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.optimalBufferCopyRowPitchAlignment),
2736 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.nonCoherentAtomSize),
2737 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard2DBlockShape),
2738 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard2DMultisampleBlockShape),
2739 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard3DBlockShape),
2740 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyAlignedMipSize),
2741 OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyNonResidentStrict),
2742 { 0, 0 }
2743 };
2744
deviceProperties(Context & context)2745 tcu::TestStatus deviceProperties (Context& context)
2746 {
2747 using namespace ValidateQueryBits;
2748
2749 TestLog& log = context.getTestContext().getLog();
2750 VkPhysicalDeviceProperties* props;
2751 VkPhysicalDeviceFeatures features;
2752 deUint8 buffer[sizeof(VkPhysicalDeviceProperties) + GUARD_SIZE];
2753
2754 props = reinterpret_cast<VkPhysicalDeviceProperties*>(buffer);
2755 deMemset(props, GUARD_VALUE, sizeof(buffer));
2756
2757 context.getInstanceInterface().getPhysicalDeviceProperties(context.getPhysicalDevice(), props);
2758 context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &features);
2759
2760 log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2761 << TestLog::Message << *props << TestLog::EndMessage;
2762
2763 if (!validateFeatureLimits(props, &features, log))
2764 return tcu::TestStatus::fail("deviceProperties - feature limits failed");
2765
2766 for (int ndx = 0; ndx < GUARD_SIZE; ndx++)
2767 {
2768 if (buffer[ndx + sizeof(VkPhysicalDeviceProperties)] != GUARD_VALUE)
2769 {
2770 log << TestLog::Message << "deviceProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2771 return tcu::TestStatus::fail("deviceProperties buffer overflow");
2772 }
2773 }
2774
2775 if (!validateInitComplete(context.getPhysicalDevice(), &InstanceInterface::getPhysicalDeviceProperties, context.getInstanceInterface(), s_physicalDevicePropertiesOffsetTable))
2776 {
2777 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceProperties not completely initialized" << TestLog::EndMessage;
2778 return tcu::TestStatus::fail("deviceProperties incomplete initialization");
2779 }
2780
2781 // Check if deviceName string is properly terminated.
2782 if (deStrnlen(props->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE) == VK_MAX_PHYSICAL_DEVICE_NAME_SIZE)
2783 {
2784 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceProperties deviceName not properly initialized" << TestLog::EndMessage;
2785 return tcu::TestStatus::fail("deviceProperties incomplete initialization");
2786 }
2787
2788 {
2789 const ApiVersion deviceVersion = unpackVersion(props->apiVersion);
2790 const ApiVersion deqpVersion = unpackVersion(VK_API_VERSION_1_3);
2791
2792 if (deviceVersion.majorNum != deqpVersion.majorNum)
2793 {
2794 log << TestLog::Message << "deviceProperties - API Major Version " << deviceVersion.majorNum << " is not valid" << TestLog::EndMessage;
2795 return tcu::TestStatus::fail("deviceProperties apiVersion not valid");
2796 }
2797
2798 if (deviceVersion.minorNum > deqpVersion.minorNum)
2799 {
2800 log << TestLog::Message << "deviceProperties - API Minor Version " << deviceVersion.minorNum << " is not valid for this version of dEQP" << TestLog::EndMessage;
2801 return tcu::TestStatus::fail("deviceProperties apiVersion not valid");
2802 }
2803 }
2804
2805 return tcu::TestStatus::pass("DeviceProperites query succeeded");
2806 }
2807
deviceQueueFamilyProperties(Context & context)2808 tcu::TestStatus deviceQueueFamilyProperties (Context& context)
2809 {
2810 TestLog& log = context.getTestContext().getLog();
2811 const vector<VkQueueFamilyProperties> queueProperties = getPhysicalDeviceQueueFamilyProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2812
2813 log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage;
2814
2815 for (size_t queueNdx = 0; queueNdx < queueProperties.size(); queueNdx++)
2816 log << TestLog::Message << queueNdx << ": " << queueProperties[queueNdx] << TestLog::EndMessage;
2817
2818 return tcu::TestStatus::pass("Querying queue properties succeeded");
2819 }
2820
deviceMemoryProperties(Context & context)2821 tcu::TestStatus deviceMemoryProperties (Context& context)
2822 {
2823 TestLog& log = context.getTestContext().getLog();
2824 VkPhysicalDeviceMemoryProperties* memProps;
2825 deUint8 buffer[sizeof(VkPhysicalDeviceMemoryProperties) + GUARD_SIZE];
2826
2827 memProps = reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(buffer);
2828 deMemset(buffer, GUARD_VALUE, sizeof(buffer));
2829
2830 context.getInstanceInterface().getPhysicalDeviceMemoryProperties(context.getPhysicalDevice(), memProps);
2831
2832 log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2833 << TestLog::Message << *memProps << TestLog::EndMessage;
2834
2835 for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
2836 {
2837 if (buffer[ndx + sizeof(VkPhysicalDeviceMemoryProperties)] != GUARD_VALUE)
2838 {
2839 log << TestLog::Message << "deviceMemoryProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2840 return tcu::TestStatus::fail("deviceMemoryProperties buffer overflow");
2841 }
2842 }
2843
2844 if (memProps->memoryHeapCount >= VK_MAX_MEMORY_HEAPS)
2845 {
2846 log << TestLog::Message << "deviceMemoryProperties - HeapCount larger than " << (deUint32)VK_MAX_MEMORY_HEAPS << TestLog::EndMessage;
2847 return tcu::TestStatus::fail("deviceMemoryProperties HeapCount too large");
2848 }
2849
2850 if (memProps->memoryHeapCount == 1)
2851 {
2852 if ((memProps->memoryHeaps[0].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) == 0)
2853 {
2854 log << TestLog::Message << "deviceMemoryProperties - Single heap is not marked DEVICE_LOCAL" << TestLog::EndMessage;
2855 return tcu::TestStatus::fail("deviceMemoryProperties invalid HeapFlags");
2856 }
2857 }
2858
2859 const VkMemoryPropertyFlags validPropertyFlags[] =
2860 {
2861 0,
2862 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
2863 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2864 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
2865 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2866 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2867 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
2868 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2869 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
2870 };
2871
2872 const VkMemoryPropertyFlags requiredPropertyFlags[] =
2873 {
2874 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
2875 };
2876
2877 bool requiredFlagsFound[DE_LENGTH_OF_ARRAY(requiredPropertyFlags)];
2878 std::fill(DE_ARRAY_BEGIN(requiredFlagsFound), DE_ARRAY_END(requiredFlagsFound), false);
2879
2880 for (deUint32 memoryNdx = 0; memoryNdx < memProps->memoryTypeCount; memoryNdx++)
2881 {
2882 bool validPropTypeFound = false;
2883
2884 if (memProps->memoryTypes[memoryNdx].heapIndex >= memProps->memoryHeapCount)
2885 {
2886 log << TestLog::Message << "deviceMemoryProperties - heapIndex " << memProps->memoryTypes[memoryNdx].heapIndex << " larger than heapCount" << TestLog::EndMessage;
2887 return tcu::TestStatus::fail("deviceMemoryProperties - invalid heapIndex");
2888 }
2889
2890 const VkMemoryPropertyFlags bitsToCheck = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
2891
2892 for (const VkMemoryPropertyFlags* requiredFlagsIterator = DE_ARRAY_BEGIN(requiredPropertyFlags); requiredFlagsIterator != DE_ARRAY_END(requiredPropertyFlags); requiredFlagsIterator++)
2893 if ((memProps->memoryTypes[memoryNdx].propertyFlags & *requiredFlagsIterator) == *requiredFlagsIterator)
2894 requiredFlagsFound[requiredFlagsIterator - DE_ARRAY_BEGIN(requiredPropertyFlags)] = true;
2895
2896 if (de::contains(DE_ARRAY_BEGIN(validPropertyFlags), DE_ARRAY_END(validPropertyFlags), memProps->memoryTypes[memoryNdx].propertyFlags & bitsToCheck))
2897 validPropTypeFound = true;
2898
2899 if (!validPropTypeFound)
2900 {
2901 log << TestLog::Message << "deviceMemoryProperties - propertyFlags "
2902 << memProps->memoryTypes[memoryNdx].propertyFlags << " not valid" << TestLog::EndMessage;
2903 return tcu::TestStatus::fail("deviceMemoryProperties propertyFlags not valid");
2904 }
2905
2906 if (memProps->memoryTypes[memoryNdx].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
2907 {
2908 if ((memProps->memoryHeaps[memProps->memoryTypes[memoryNdx].heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) == 0)
2909 {
2910 log << TestLog::Message << "deviceMemoryProperties - DEVICE_LOCAL memory type references heap which is not DEVICE_LOCAL" << TestLog::EndMessage;
2911 return tcu::TestStatus::fail("deviceMemoryProperties inconsistent memoryType and HeapFlags");
2912 }
2913 }
2914 else
2915 {
2916 if (memProps->memoryHeaps[memProps->memoryTypes[memoryNdx].heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
2917 {
2918 log << TestLog::Message << "deviceMemoryProperties - non-DEVICE_LOCAL memory type references heap with is DEVICE_LOCAL" << TestLog::EndMessage;
2919 return tcu::TestStatus::fail("deviceMemoryProperties inconsistent memoryType and HeapFlags");
2920 }
2921 }
2922 }
2923
2924 bool* requiredFlagsFoundIterator = std::find(DE_ARRAY_BEGIN(requiredFlagsFound), DE_ARRAY_END(requiredFlagsFound), false);
2925 if (requiredFlagsFoundIterator != DE_ARRAY_END(requiredFlagsFound))
2926 {
2927 DE_ASSERT(requiredFlagsFoundIterator - DE_ARRAY_BEGIN(requiredFlagsFound) <= DE_LENGTH_OF_ARRAY(requiredPropertyFlags));
2928 log << TestLog::Message << "deviceMemoryProperties - required property flags "
2929 << getMemoryPropertyFlagsStr(requiredPropertyFlags[requiredFlagsFoundIterator - DE_ARRAY_BEGIN(requiredFlagsFound)]) << " not found" << TestLog::EndMessage;
2930
2931 return tcu::TestStatus::fail("deviceMemoryProperties propertyFlags not valid");
2932 }
2933
2934 return tcu::TestStatus::pass("Querying memory properties succeeded");
2935 }
2936
deviceGroupPeerMemoryFeatures(Context & context)2937 tcu::TestStatus deviceGroupPeerMemoryFeatures (Context& context)
2938 {
2939 TestLog& log = context.getTestContext().getLog();
2940 const PlatformInterface& vkp = context.getPlatformInterface();
2941 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
2942 const InstanceDriver& vki (instance.getDriver());
2943 const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
2944 const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
2945 const deUint32 deviceIdx = vk::chooseDeviceIndex(context.getInstanceInterface(), instance, cmdLine);
2946 const float queuePriority = 1.0f;
2947 VkPhysicalDeviceMemoryProperties memProps;
2948 VkPeerMemoryFeatureFlags* peerMemFeatures;
2949 deUint8 buffer [sizeof(VkPeerMemoryFeatureFlags) + GUARD_SIZE];
2950 deUint32 numPhysicalDevices = 0;
2951 deUint32 queueFamilyIndex = 0;
2952
2953 const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(vki, instance);
2954 std::vector<const char*> deviceExtensions;
2955 deviceExtensions.push_back("VK_KHR_device_group");
2956
2957 if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
2958 deviceExtensions.push_back("VK_KHR_device_group");
2959
2960 const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
2961 for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
2962 {
2963 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
2964 queueFamilyIndex = (deUint32)queueNdx;
2965 }
2966 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
2967 {
2968 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, //type
2969 DE_NULL, //pNext
2970 (VkDeviceQueueCreateFlags)0u, //flags
2971 queueFamilyIndex, //queueFamilyIndex;
2972 1u, //queueCount;
2973 &queuePriority, //pQueuePriorities;
2974 };
2975
2976 // Need atleast 2 devices for peer memory features
2977 numPhysicalDevices = deviceGroupProps[devGroupIdx].physicalDeviceCount;
2978 if (numPhysicalDevices < 2)
2979 TCU_THROW(NotSupportedError, "Need a device Group with at least 2 physical devices.");
2980
2981 // Create device groups
2982 const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
2983 {
2984 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, //stype
2985 DE_NULL, //pNext
2986 deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
2987 deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
2988 };
2989
2990 const VkDeviceCreateInfo deviceCreateInfo =
2991 {
2992 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
2993 &deviceGroupInfo, //pNext;
2994 (VkDeviceCreateFlags)0u, //flags
2995 1, //queueRecordCount;
2996 &deviceQueueCreateInfo, //pRequestedQueues;
2997 0, //layerCount;
2998 DE_NULL, //ppEnabledLayerNames;
2999 deUint32(deviceExtensions.size()), //extensionCount;
3000 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]), //ppEnabledExtensionNames;
3001 DE_NULL, //pEnabledFeatures;
3002 };
3003
3004 Move<VkDevice> deviceGroup = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
3005 const DeviceDriver vk (vkp, instance, *deviceGroup);
3006 context.getInstanceInterface().getPhysicalDeviceMemoryProperties(deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &memProps);
3007
3008 peerMemFeatures = reinterpret_cast<VkPeerMemoryFeatureFlags*>(buffer);
3009 deMemset(buffer, GUARD_VALUE, sizeof(buffer));
3010
3011 for (deUint32 heapIndex = 0; heapIndex < memProps.memoryHeapCount; heapIndex++)
3012 {
3013 for (deUint32 localDeviceIndex = 0; localDeviceIndex < numPhysicalDevices; localDeviceIndex++)
3014 {
3015 for (deUint32 remoteDeviceIndex = 0; remoteDeviceIndex < numPhysicalDevices; remoteDeviceIndex++)
3016 {
3017 if (localDeviceIndex != remoteDeviceIndex)
3018 {
3019 vk.getDeviceGroupPeerMemoryFeatures(deviceGroup.get(), heapIndex, localDeviceIndex, remoteDeviceIndex, peerMemFeatures);
3020
3021 // Check guard
3022 for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
3023 {
3024 if (buffer[ndx + sizeof(VkPeerMemoryFeatureFlags)] != GUARD_VALUE)
3025 {
3026 log << TestLog::Message << "deviceGroupPeerMemoryFeatures - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
3027 return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures buffer overflow");
3028 }
3029 }
3030
3031 VkPeerMemoryFeatureFlags requiredFlag = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
3032 VkPeerMemoryFeatureFlags maxValidFlag = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT|
3033 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
3034 if ((!(*peerMemFeatures & requiredFlag)) ||
3035 *peerMemFeatures > maxValidFlag)
3036 return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures invalid flag");
3037
3038 log << TestLog::Message << "deviceGroup = " << deviceGroup.get() << TestLog::EndMessage
3039 << TestLog::Message << "heapIndex = " << heapIndex << TestLog::EndMessage
3040 << TestLog::Message << "localDeviceIndex = " << localDeviceIndex << TestLog::EndMessage
3041 << TestLog::Message << "remoteDeviceIndex = " << remoteDeviceIndex << TestLog::EndMessage
3042 << TestLog::Message << "PeerMemoryFeatureFlags = " << *peerMemFeatures << TestLog::EndMessage;
3043 }
3044 } // remote device
3045 } // local device
3046 } // heap Index
3047
3048 return tcu::TestStatus::pass("Querying deviceGroup peer memory features succeeded");
3049 }
3050
deviceMemoryBudgetProperties(Context & context)3051 tcu::TestStatus deviceMemoryBudgetProperties (Context& context)
3052 {
3053 TestLog& log = context.getTestContext().getLog();
3054 deUint8 buffer[sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT) + GUARD_SIZE];
3055
3056 if (!context.isDeviceFunctionalitySupported("VK_EXT_memory_budget"))
3057 TCU_THROW(NotSupportedError, "VK_EXT_memory_budget is not supported");
3058
3059 VkPhysicalDeviceMemoryBudgetPropertiesEXT *budgetProps = reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(buffer);
3060 deMemset(buffer, GUARD_VALUE, sizeof(buffer));
3061
3062 budgetProps->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
3063 budgetProps->pNext = DE_NULL;
3064
3065 VkPhysicalDeviceMemoryProperties2 memProps;
3066 deMemset(&memProps, 0, sizeof(memProps));
3067 memProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
3068 memProps.pNext = budgetProps;
3069
3070 context.getInstanceInterface().getPhysicalDeviceMemoryProperties2(context.getPhysicalDevice(), &memProps);
3071
3072 log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
3073 << TestLog::Message << *budgetProps << TestLog::EndMessage;
3074
3075 for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
3076 {
3077 if (buffer[ndx + sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)] != GUARD_VALUE)
3078 {
3079 log << TestLog::Message << "deviceMemoryBudgetProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
3080 return tcu::TestStatus::fail("deviceMemoryBudgetProperties buffer overflow");
3081 }
3082 }
3083
3084 for (deUint32 i = 0; i < memProps.memoryProperties.memoryHeapCount; ++i)
3085 {
3086 if (budgetProps->heapBudget[i] == 0)
3087 {
3088 log << TestLog::Message << "deviceMemoryBudgetProperties - Supported heaps must report nonzero budget" << TestLog::EndMessage;
3089 return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid heap budget (zero)");
3090 }
3091 if (budgetProps->heapBudget[i] > memProps.memoryProperties.memoryHeaps[i].size)
3092 {
3093 log << TestLog::Message << "deviceMemoryBudgetProperties - Heap budget must be less than or equal to heap size" << TestLog::EndMessage;
3094 return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid heap budget (too large)");
3095 }
3096 }
3097
3098 for (deUint32 i = memProps.memoryProperties.memoryHeapCount; i < VK_MAX_MEMORY_HEAPS; ++i)
3099 {
3100 if (budgetProps->heapBudget[i] != 0 || budgetProps->heapUsage[i] != 0)
3101 {
3102 log << TestLog::Message << "deviceMemoryBudgetProperties - Unused heaps must report budget/usage of zero" << TestLog::EndMessage;
3103 return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid unused heaps");
3104 }
3105 }
3106
3107 return tcu::TestStatus::pass("Querying memory budget properties succeeded");
3108 }
3109
3110 namespace
3111 {
3112
3113 #include "vkMandatoryFeatures.inl"
3114
3115 }
3116
deviceMandatoryFeatures(Context & context)3117 tcu::TestStatus deviceMandatoryFeatures(Context& context)
3118 {
3119 if ( checkMandatoryFeatures(context) )
3120 return tcu::TestStatus::pass("Passed");
3121 return tcu::TestStatus::fail("Not all mandatory features are supported ( see: vkspec.html#features-requirements )");
3122 }
3123
getBaseRequiredOptimalTilingFeatures(VkFormat format)3124 VkFormatFeatureFlags getBaseRequiredOptimalTilingFeatures (VkFormat format)
3125 {
3126 struct Formatpair
3127 {
3128 VkFormat format;
3129 VkFormatFeatureFlags flags;
3130 };
3131
3132 enum
3133 {
3134 SAIM = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
3135 BLSR = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
3136 SIFL = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
3137 COAT = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
3138 BLDS = VK_FORMAT_FEATURE_BLIT_DST_BIT,
3139 CABL = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
3140 STIM = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
3141 STIA = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
3142 DSAT = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
3143 TRSR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
3144 TRDS = VK_FORMAT_FEATURE_TRANSFER_DST_BIT
3145 };
3146
3147 static const Formatpair formatflags[] =
3148 {
3149 { VK_FORMAT_B4G4R4A4_UNORM_PACK16, SAIM | BLSR | TRSR | TRDS | SIFL },
3150 { VK_FORMAT_R5G6B5_UNORM_PACK16, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3151 { VK_FORMAT_A1R5G5B5_UNORM_PACK16, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3152 { VK_FORMAT_R8_UNORM, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3153 { VK_FORMAT_R8_SNORM, SAIM | BLSR | TRSR | TRDS | SIFL },
3154 { VK_FORMAT_R8_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3155 { VK_FORMAT_R8_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3156 { VK_FORMAT_R8G8_UNORM, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3157 { VK_FORMAT_R8G8_SNORM, SAIM | BLSR | TRSR | TRDS | SIFL },
3158 { VK_FORMAT_R8G8_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3159 { VK_FORMAT_R8G8_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3160 { VK_FORMAT_R8G8B8A8_UNORM, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | STIM | CABL },
3161 { VK_FORMAT_R8G8B8A8_SNORM, SAIM | BLSR | TRSR | TRDS | SIFL | STIM },
3162 { VK_FORMAT_R8G8B8A8_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3163 { VK_FORMAT_R8G8B8A8_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3164 { VK_FORMAT_R8G8B8A8_SRGB, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3165 { VK_FORMAT_B8G8R8A8_UNORM, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3166 { VK_FORMAT_B8G8R8A8_SRGB, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3167 { VK_FORMAT_A8B8G8R8_UNORM_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3168 { VK_FORMAT_A8B8G8R8_SNORM_PACK32, SAIM | BLSR | TRSR | TRDS | SIFL },
3169 { VK_FORMAT_A8B8G8R8_UINT_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3170 { VK_FORMAT_A8B8G8R8_SINT_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3171 { VK_FORMAT_A8B8G8R8_SRGB_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3172 { VK_FORMAT_A2B10G10R10_UNORM_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3173 { VK_FORMAT_A2B10G10R10_UINT_PACK32, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3174 { VK_FORMAT_R16_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3175 { VK_FORMAT_R16_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3176 { VK_FORMAT_R16_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3177 { VK_FORMAT_R16G16_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3178 { VK_FORMAT_R16G16_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3179 { VK_FORMAT_R16G16_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | CABL },
3180 { VK_FORMAT_R16G16B16A16_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3181 { VK_FORMAT_R16G16B16A16_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3182 { VK_FORMAT_R16G16B16A16_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | STIM | CABL },
3183 { VK_FORMAT_R32_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM | STIA },
3184 { VK_FORMAT_R32_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM | STIA },
3185 { VK_FORMAT_R32_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3186 { VK_FORMAT_R32G32_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3187 { VK_FORMAT_R32G32_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3188 { VK_FORMAT_R32G32_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3189 { VK_FORMAT_R32G32B32A32_UINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3190 { VK_FORMAT_R32G32B32A32_SINT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3191 { VK_FORMAT_R32G32B32A32_SFLOAT, SAIM | BLSR | TRSR | TRDS | COAT | BLDS | STIM },
3192 { VK_FORMAT_B10G11R11_UFLOAT_PACK32, SAIM | BLSR | TRSR | TRDS | SIFL },
3193 { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, SAIM | BLSR | TRSR | TRDS | SIFL },
3194 { VK_FORMAT_D16_UNORM, SAIM | BLSR | TRSR | TRDS | DSAT },
3195 };
3196
3197 size_t formatpairs = sizeof(formatflags) / sizeof(Formatpair);
3198
3199 for (unsigned int i = 0; i < formatpairs; i++)
3200 if (formatflags[i].format == format)
3201 return formatflags[i].flags;
3202 return 0;
3203 }
3204
getRequiredOptimalExtendedTilingFeatures(Context & context,VkFormat format,VkFormatFeatureFlags queriedFlags)3205 VkFormatFeatureFlags getRequiredOptimalExtendedTilingFeatures (Context& context, VkFormat format, VkFormatFeatureFlags queriedFlags)
3206 {
3207 VkFormatFeatureFlags flags = (VkFormatFeatureFlags)0;
3208
3209 // VK_EXT_sampler_filter_minmax:
3210 // If filterMinmaxSingleComponentFormats is VK_TRUE, the following formats must
3211 // support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT feature with
3212 // VK_IMAGE_TILING_OPTIMAL, if they support VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
3213
3214 static const VkFormat s_requiredSampledImageFilterMinMaxFormats[] =
3215 {
3216 VK_FORMAT_R8_UNORM,
3217 VK_FORMAT_R8_SNORM,
3218 VK_FORMAT_R16_UNORM,
3219 VK_FORMAT_R16_SNORM,
3220 VK_FORMAT_R16_SFLOAT,
3221 VK_FORMAT_R32_SFLOAT,
3222 VK_FORMAT_D16_UNORM,
3223 VK_FORMAT_X8_D24_UNORM_PACK32,
3224 VK_FORMAT_D32_SFLOAT,
3225 VK_FORMAT_D16_UNORM_S8_UINT,
3226 VK_FORMAT_D24_UNORM_S8_UINT,
3227 VK_FORMAT_D32_SFLOAT_S8_UINT,
3228 };
3229
3230 if ((queriedFlags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
3231 {
3232 if (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_EXT_sampler_filter_minmax"))
3233 {
3234 if (de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterMinMaxFormats), DE_ARRAY_END(s_requiredSampledImageFilterMinMaxFormats), format))
3235 {
3236 VkPhysicalDeviceSamplerFilterMinmaxProperties physicalDeviceSamplerMinMaxProperties =
3237 {
3238 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT,
3239 DE_NULL,
3240 DE_FALSE,
3241 DE_FALSE
3242 };
3243
3244 {
3245 VkPhysicalDeviceProperties2 physicalDeviceProperties;
3246 physicalDeviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
3247 physicalDeviceProperties.pNext = &physicalDeviceSamplerMinMaxProperties;
3248
3249 const InstanceInterface& vk = context.getInstanceInterface();
3250 vk.getPhysicalDeviceProperties2(context.getPhysicalDevice(), &physicalDeviceProperties);
3251 }
3252
3253 if (physicalDeviceSamplerMinMaxProperties.filterMinmaxSingleComponentFormats)
3254 {
3255 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
3256 }
3257 }
3258 }
3259 }
3260
3261 // VK_EXT_filter_cubic:
3262 // If cubic filtering is supported, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT must be supported for the following image view types:
3263 // VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_VIEW_TYPE_2D_ARRAY
3264 static const VkFormat s_requiredSampledImageFilterCubicFormats[] =
3265 {
3266 VK_FORMAT_R4G4_UNORM_PACK8,
3267 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3268 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3269 VK_FORMAT_R5G6B5_UNORM_PACK16,
3270 VK_FORMAT_B5G6R5_UNORM_PACK16,
3271 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3272 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3273 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3274 VK_FORMAT_R8_UNORM,
3275 VK_FORMAT_R8_SNORM,
3276 VK_FORMAT_R8_SRGB,
3277 VK_FORMAT_R8G8_UNORM,
3278 VK_FORMAT_R8G8_SNORM,
3279 VK_FORMAT_R8G8_SRGB,
3280 VK_FORMAT_R8G8B8_UNORM,
3281 VK_FORMAT_R8G8B8_SNORM,
3282 VK_FORMAT_R8G8B8_SRGB,
3283 VK_FORMAT_B8G8R8_UNORM,
3284 VK_FORMAT_B8G8R8_SNORM,
3285 VK_FORMAT_B8G8R8_SRGB,
3286 VK_FORMAT_R8G8B8A8_UNORM,
3287 VK_FORMAT_R8G8B8A8_SNORM,
3288 VK_FORMAT_R8G8B8A8_SRGB,
3289 VK_FORMAT_B8G8R8A8_UNORM,
3290 VK_FORMAT_B8G8R8A8_SNORM,
3291 VK_FORMAT_B8G8R8A8_SRGB,
3292 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3293 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3294 VK_FORMAT_A8B8G8R8_SRGB_PACK32
3295 };
3296
3297 static const VkFormat s_requiredSampledImageFilterCubicFormatsETC2[] =
3298 {
3299 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3300 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3301 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3302 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3303 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3304 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
3305 };
3306
3307 if ( (queriedFlags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0 && de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_EXT_filter_cubic") )
3308 {
3309 if ( de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterCubicFormats), DE_ARRAY_END(s_requiredSampledImageFilterCubicFormats), format) )
3310 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
3311
3312 VkPhysicalDeviceFeatures2 coreFeatures;
3313 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3314
3315 coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3316 coreFeatures.pNext = DE_NULL;
3317 context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
3318 if ( coreFeatures.features.textureCompressionETC2 && de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterCubicFormatsETC2), DE_ARRAY_END(s_requiredSampledImageFilterCubicFormatsETC2), format) )
3319 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
3320 }
3321
3322 return flags;
3323 }
3324
getRequiredBufferFeatures(VkFormat format)3325 VkFormatFeatureFlags getRequiredBufferFeatures (VkFormat format)
3326 {
3327 static const VkFormat s_requiredVertexBufferFormats[] =
3328 {
3329 VK_FORMAT_R8_UNORM,
3330 VK_FORMAT_R8_SNORM,
3331 VK_FORMAT_R8_UINT,
3332 VK_FORMAT_R8_SINT,
3333 VK_FORMAT_R8G8_UNORM,
3334 VK_FORMAT_R8G8_SNORM,
3335 VK_FORMAT_R8G8_UINT,
3336 VK_FORMAT_R8G8_SINT,
3337 VK_FORMAT_R8G8B8A8_UNORM,
3338 VK_FORMAT_R8G8B8A8_SNORM,
3339 VK_FORMAT_R8G8B8A8_UINT,
3340 VK_FORMAT_R8G8B8A8_SINT,
3341 VK_FORMAT_B8G8R8A8_UNORM,
3342 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3343 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3344 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3345 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3346 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3347 VK_FORMAT_R16_UNORM,
3348 VK_FORMAT_R16_SNORM,
3349 VK_FORMAT_R16_UINT,
3350 VK_FORMAT_R16_SINT,
3351 VK_FORMAT_R16_SFLOAT,
3352 VK_FORMAT_R16G16_UNORM,
3353 VK_FORMAT_R16G16_SNORM,
3354 VK_FORMAT_R16G16_UINT,
3355 VK_FORMAT_R16G16_SINT,
3356 VK_FORMAT_R16G16_SFLOAT,
3357 VK_FORMAT_R16G16B16A16_UNORM,
3358 VK_FORMAT_R16G16B16A16_SNORM,
3359 VK_FORMAT_R16G16B16A16_UINT,
3360 VK_FORMAT_R16G16B16A16_SINT,
3361 VK_FORMAT_R16G16B16A16_SFLOAT,
3362 VK_FORMAT_R32_UINT,
3363 VK_FORMAT_R32_SINT,
3364 VK_FORMAT_R32_SFLOAT,
3365 VK_FORMAT_R32G32_UINT,
3366 VK_FORMAT_R32G32_SINT,
3367 VK_FORMAT_R32G32_SFLOAT,
3368 VK_FORMAT_R32G32B32_UINT,
3369 VK_FORMAT_R32G32B32_SINT,
3370 VK_FORMAT_R32G32B32_SFLOAT,
3371 VK_FORMAT_R32G32B32A32_UINT,
3372 VK_FORMAT_R32G32B32A32_SINT,
3373 VK_FORMAT_R32G32B32A32_SFLOAT
3374 };
3375 static const VkFormat s_requiredUniformTexelBufferFormats[] =
3376 {
3377 VK_FORMAT_R8_UNORM,
3378 VK_FORMAT_R8_SNORM,
3379 VK_FORMAT_R8_UINT,
3380 VK_FORMAT_R8_SINT,
3381 VK_FORMAT_R8G8_UNORM,
3382 VK_FORMAT_R8G8_SNORM,
3383 VK_FORMAT_R8G8_UINT,
3384 VK_FORMAT_R8G8_SINT,
3385 VK_FORMAT_R8G8B8A8_UNORM,
3386 VK_FORMAT_R8G8B8A8_SNORM,
3387 VK_FORMAT_R8G8B8A8_UINT,
3388 VK_FORMAT_R8G8B8A8_SINT,
3389 VK_FORMAT_B8G8R8A8_UNORM,
3390 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3391 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3392 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3393 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3394 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3395 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3396 VK_FORMAT_R16_UINT,
3397 VK_FORMAT_R16_SINT,
3398 VK_FORMAT_R16_SFLOAT,
3399 VK_FORMAT_R16G16_UINT,
3400 VK_FORMAT_R16G16_SINT,
3401 VK_FORMAT_R16G16_SFLOAT,
3402 VK_FORMAT_R16G16B16A16_UINT,
3403 VK_FORMAT_R16G16B16A16_SINT,
3404 VK_FORMAT_R16G16B16A16_SFLOAT,
3405 VK_FORMAT_R32_UINT,
3406 VK_FORMAT_R32_SINT,
3407 VK_FORMAT_R32_SFLOAT,
3408 VK_FORMAT_R32G32_UINT,
3409 VK_FORMAT_R32G32_SINT,
3410 VK_FORMAT_R32G32_SFLOAT,
3411 VK_FORMAT_R32G32B32A32_UINT,
3412 VK_FORMAT_R32G32B32A32_SINT,
3413 VK_FORMAT_R32G32B32A32_SFLOAT,
3414 VK_FORMAT_B10G11R11_UFLOAT_PACK32
3415 };
3416 static const VkFormat s_requiredStorageTexelBufferFormats[] =
3417 {
3418 VK_FORMAT_R8G8B8A8_UNORM,
3419 VK_FORMAT_R8G8B8A8_SNORM,
3420 VK_FORMAT_R8G8B8A8_UINT,
3421 VK_FORMAT_R8G8B8A8_SINT,
3422 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3423 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3424 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3425 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3426 VK_FORMAT_R16G16B16A16_UINT,
3427 VK_FORMAT_R16G16B16A16_SINT,
3428 VK_FORMAT_R16G16B16A16_SFLOAT,
3429 VK_FORMAT_R32_UINT,
3430 VK_FORMAT_R32_SINT,
3431 VK_FORMAT_R32_SFLOAT,
3432 VK_FORMAT_R32G32_UINT,
3433 VK_FORMAT_R32G32_SINT,
3434 VK_FORMAT_R32G32_SFLOAT,
3435 VK_FORMAT_R32G32B32A32_UINT,
3436 VK_FORMAT_R32G32B32A32_SINT,
3437 VK_FORMAT_R32G32B32A32_SFLOAT
3438 };
3439 static const VkFormat s_requiredStorageTexelBufferAtomicFormats[] =
3440 {
3441 VK_FORMAT_R32_UINT,
3442 VK_FORMAT_R32_SINT
3443 };
3444
3445 VkFormatFeatureFlags flags = (VkFormatFeatureFlags)0;
3446
3447 if (de::contains(DE_ARRAY_BEGIN(s_requiredVertexBufferFormats), DE_ARRAY_END(s_requiredVertexBufferFormats), format))
3448 flags |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
3449
3450 if (de::contains(DE_ARRAY_BEGIN(s_requiredUniformTexelBufferFormats), DE_ARRAY_END(s_requiredUniformTexelBufferFormats), format))
3451 flags |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
3452
3453 if (de::contains(DE_ARRAY_BEGIN(s_requiredStorageTexelBufferFormats), DE_ARRAY_END(s_requiredStorageTexelBufferFormats), format))
3454 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
3455
3456 if (de::contains(DE_ARRAY_BEGIN(s_requiredStorageTexelBufferAtomicFormats), DE_ARRAY_END(s_requiredStorageTexelBufferAtomicFormats), format))
3457 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
3458
3459 return flags;
3460 }
3461
getPhysicalDeviceSamplerYcbcrConversionFeatures(const InstanceInterface & vk,VkPhysicalDevice physicalDevice)3462 VkPhysicalDeviceSamplerYcbcrConversionFeatures getPhysicalDeviceSamplerYcbcrConversionFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
3463 {
3464 VkPhysicalDeviceFeatures2 coreFeatures;
3465 VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcrFeatures;
3466
3467 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3468 deMemset(&ycbcrFeatures, 0, sizeof(ycbcrFeatures));
3469
3470 coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3471 coreFeatures.pNext = &ycbcrFeatures;
3472 ycbcrFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
3473
3474 vk.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
3475
3476 return ycbcrFeatures;
3477 }
3478
checkYcbcrApiSupport(Context & context)3479 void checkYcbcrApiSupport (Context& context)
3480 {
3481 // check if YCbcr API and are supported by implementation
3482
3483 // the support for formats and YCbCr may still be optional - see isYcbcrConversionSupported below
3484
3485 if (!vk::isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_sampler_ycbcr_conversion"))
3486 {
3487 if (!context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion"))
3488 TCU_THROW(NotSupportedError, "VK_KHR_sampler_ycbcr_conversion is not supported");
3489
3490 // Hard dependency for ycbcr
3491 TCU_CHECK(de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_physical_device_properties2"));
3492 }
3493 }
3494
isYcbcrConversionSupported(Context & context)3495 bool isYcbcrConversionSupported (Context& context)
3496 {
3497 checkYcbcrApiSupport(context);
3498
3499 const VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcrFeatures = getPhysicalDeviceSamplerYcbcrConversionFeatures(context.getInstanceInterface(), context.getPhysicalDevice());
3500
3501 return (ycbcrFeatures.samplerYcbcrConversion == VK_TRUE);
3502 }
3503
getRequiredYcbcrFormatFeatures(Context & context,VkFormat format)3504 VkFormatFeatureFlags getRequiredYcbcrFormatFeatures (Context& context, VkFormat format)
3505 {
3506 bool req = isYcbcrConversionSupported(context) && ( format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
3507 format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM);
3508
3509 const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
3510 | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
3511 | VK_FORMAT_FEATURE_TRANSFER_DST_BIT
3512 | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
3513 return req ? required : (VkFormatFeatureFlags)0;
3514 }
3515
getRequiredOptimalTilingFeatures(Context & context,VkFormat format)3516 VkFormatFeatureFlags getRequiredOptimalTilingFeatures (Context& context, VkFormat format)
3517 {
3518 if (isYCbCrFormat(format))
3519 return getRequiredYcbcrFormatFeatures(context, format);
3520 else
3521 {
3522 VkFormatFeatureFlags ret = getBaseRequiredOptimalTilingFeatures(format);
3523
3524 // \todo [2017-05-16 pyry] This should be extended to cover for example COLOR_ATTACHMENT for depth formats etc.
3525 // \todo [2017-05-18 pyry] Any other color conversion related features that can't be supported by regular formats?
3526 ret |= getRequiredOptimalExtendedTilingFeatures(context, format, ret);
3527
3528 // Compressed formats have optional support for some features
3529 // TODO: Is this really correct? It looks like it should be checking the different compressed features
3530 if (isCompressedFormat(format) && (ret & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
3531 ret |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
3532 VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
3533 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
3534 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
3535
3536 return ret;
3537 }
3538 }
3539
requiresYCbCrConversion(Context & context,VkFormat format)3540 bool requiresYCbCrConversion(Context& context, VkFormat format)
3541 {
3542 if (format == VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16)
3543 {
3544 if (!context.isDeviceFunctionalitySupported("VK_EXT_rgba10x6_formats"))
3545 return true;
3546 VkPhysicalDeviceFeatures2 coreFeatures;
3547 VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT rgba10x6features;
3548
3549 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3550 deMemset(&rgba10x6features, 0, sizeof(rgba10x6features));
3551
3552 coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3553 coreFeatures.pNext = &rgba10x6features;
3554 rgba10x6features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
3555
3556 const InstanceInterface &vk = context.getInstanceInterface();
3557 vk.getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
3558
3559 return !rgba10x6features.formatRgba10x6WithoutYCbCrSampler;
3560 }
3561
3562 return isYCbCrFormat(format) &&
3563 format != VK_FORMAT_R10X6_UNORM_PACK16 && format != VK_FORMAT_R10X6G10X6_UNORM_2PACK16 &&
3564 format != VK_FORMAT_R12X4_UNORM_PACK16 && format != VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
3565 }
3566
getAllowedOptimalTilingFeatures(Context & context,VkFormat format)3567 VkFormatFeatureFlags getAllowedOptimalTilingFeatures (Context &context, VkFormat format)
3568 {
3569 // YCbCr formats only support a subset of format feature flags
3570 const VkFormatFeatureFlags ycbcrAllows =
3571 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
3572 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
3573 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG |
3574 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
3575 VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
3576 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
3577 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT |
3578 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT |
3579 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT |
3580 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT |
3581 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT |
3582 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT |
3583 VK_FORMAT_FEATURE_DISJOINT_BIT;
3584
3585 // By default everything is allowed.
3586 VkFormatFeatureFlags allow = (VkFormatFeatureFlags)~0u;
3587 // Formats for which SamplerYCbCrConversion is required may not support certain features.
3588 if (requiresYCbCrConversion(context, format))
3589 allow &= ycbcrAllows;
3590 // single-plane formats *may not* support DISJOINT_BIT
3591 if (!isYCbCrFormat(format) || getPlaneCount(format) == 1)
3592 allow &= ~VK_FORMAT_FEATURE_DISJOINT_BIT;
3593
3594 return allow;
3595 }
3596
getAllowedBufferFeatures(Context & context,VkFormat format)3597 VkFormatFeatureFlags getAllowedBufferFeatures (Context &context, VkFormat format)
3598 {
3599 // TODO: Do we allow non-buffer flags in the bufferFeatures?
3600 return requiresYCbCrConversion(context, format) ? (VkFormatFeatureFlags)0 : (VkFormatFeatureFlags)(~VK_FORMAT_FEATURE_DISJOINT_BIT);
3601 }
3602
formatProperties(Context & context,VkFormat format)3603 tcu::TestStatus formatProperties (Context& context, VkFormat format)
3604 {
3605 // check if Ycbcr format enums are valid given the version and extensions
3606 if (isYCbCrFormat(format))
3607 checkYcbcrApiSupport(context);
3608
3609 TestLog& log = context.getTestContext().getLog();
3610 const VkFormatProperties properties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
3611 bool allOk = true;
3612
3613 const VkFormatFeatureFlags reqImg = getRequiredOptimalTilingFeatures(context, format);
3614 const VkFormatFeatureFlags reqBuf = getRequiredBufferFeatures(format);
3615 const VkFormatFeatureFlags allowImg = getAllowedOptimalTilingFeatures(context, format);
3616 const VkFormatFeatureFlags allowBuf = getAllowedBufferFeatures(context, format);
3617
3618 const struct feature_req
3619 {
3620 const char* fieldName;
3621 VkFormatFeatureFlags supportedFeatures;
3622 VkFormatFeatureFlags requiredFeatures;
3623 VkFormatFeatureFlags allowedFeatures;
3624 } fields[] =
3625 {
3626 { "linearTilingFeatures", properties.linearTilingFeatures, (VkFormatFeatureFlags)0, allowImg },
3627 { "optimalTilingFeatures", properties.optimalTilingFeatures, reqImg, allowImg },
3628 { "bufferFeatures", properties.bufferFeatures, reqBuf, allowBuf }
3629 };
3630
3631 log << TestLog::Message << properties << TestLog::EndMessage;
3632
3633 for (int fieldNdx = 0; fieldNdx < DE_LENGTH_OF_ARRAY(fields); fieldNdx++)
3634 {
3635 const char* const fieldName = fields[fieldNdx].fieldName;
3636 const VkFormatFeatureFlags supported = fields[fieldNdx].supportedFeatures;
3637 const VkFormatFeatureFlags required = fields[fieldNdx].requiredFeatures;
3638 const VkFormatFeatureFlags allowed = fields[fieldNdx].allowedFeatures;
3639
3640 if ((supported & required) != required)
3641 {
3642 log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3643 << " required: " << getFormatFeatureFlagsStr(required) << "\n "
3644 << " missing: " << getFormatFeatureFlagsStr(~supported & required)
3645 << TestLog::EndMessage;
3646 allOk = false;
3647 }
3648
3649 if ((supported & ~allowed) != 0)
3650 {
3651 log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3652 << " has: " << getFormatFeatureFlagsStr(supported & ~allowed)
3653 << TestLog::EndMessage;
3654 allOk = false;
3655 }
3656
3657 if (((supported & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) != 0) &&
3658 ((supported & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) == 0))
3659 {
3660 log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3661 << " supports VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"
3662 << " but not VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"
3663 << TestLog::EndMessage;
3664 allOk = false;
3665 }
3666 }
3667
3668 if (allOk)
3669 return tcu::TestStatus::pass("Query and validation passed");
3670 else
3671 return tcu::TestStatus::fail("Required features not supported");
3672 }
3673
optimalTilingFeaturesSupported(Context & context,VkFormat format,VkFormatFeatureFlags features)3674 bool optimalTilingFeaturesSupported (Context& context, VkFormat format, VkFormatFeatureFlags features)
3675 {
3676 const VkFormatProperties properties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
3677
3678 return (properties.optimalTilingFeatures & features) == features;
3679 }
3680
optimalTilingFeaturesSupportedForAll(Context & context,const VkFormat * begin,const VkFormat * end,VkFormatFeatureFlags features)3681 bool optimalTilingFeaturesSupportedForAll (Context& context, const VkFormat* begin, const VkFormat* end, VkFormatFeatureFlags features)
3682 {
3683 for (const VkFormat* cur = begin; cur != end; ++cur)
3684 {
3685 if (!optimalTilingFeaturesSupported(context, *cur, features))
3686 return false;
3687 }
3688
3689 return true;
3690 }
3691
testDepthStencilSupported(Context & context)3692 tcu::TestStatus testDepthStencilSupported (Context& context)
3693 {
3694 if (!optimalTilingFeaturesSupported(context, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
3695 !optimalTilingFeaturesSupported(context, VK_FORMAT_D32_SFLOAT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
3696 return tcu::TestStatus::fail("Doesn't support one of VK_FORMAT_X8_D24_UNORM_PACK32 or VK_FORMAT_D32_SFLOAT");
3697
3698 if (!optimalTilingFeaturesSupported(context, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
3699 !optimalTilingFeaturesSupported(context, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
3700 return tcu::TestStatus::fail("Doesn't support one of VK_FORMAT_D24_UNORM_S8_UINT or VK_FORMAT_D32_SFLOAT_S8_UINT");
3701
3702 return tcu::TestStatus::pass("Required depth/stencil formats supported");
3703 }
3704
testCompressedFormatsSupported(Context & context)3705 tcu::TestStatus testCompressedFormatsSupported (Context& context)
3706 {
3707 static const VkFormat s_allBcFormats[] =
3708 {
3709 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3710 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3711 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3712 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3713 VK_FORMAT_BC2_UNORM_BLOCK,
3714 VK_FORMAT_BC2_SRGB_BLOCK,
3715 VK_FORMAT_BC3_UNORM_BLOCK,
3716 VK_FORMAT_BC3_SRGB_BLOCK,
3717 VK_FORMAT_BC4_UNORM_BLOCK,
3718 VK_FORMAT_BC4_SNORM_BLOCK,
3719 VK_FORMAT_BC5_UNORM_BLOCK,
3720 VK_FORMAT_BC5_SNORM_BLOCK,
3721 VK_FORMAT_BC6H_UFLOAT_BLOCK,
3722 VK_FORMAT_BC6H_SFLOAT_BLOCK,
3723 VK_FORMAT_BC7_UNORM_BLOCK,
3724 VK_FORMAT_BC7_SRGB_BLOCK,
3725 };
3726 static const VkFormat s_allEtc2Formats[] =
3727 {
3728 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3729 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3730 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3731 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3732 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3733 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3734 VK_FORMAT_EAC_R11_UNORM_BLOCK,
3735 VK_FORMAT_EAC_R11_SNORM_BLOCK,
3736 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3737 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3738 };
3739 static const VkFormat s_allAstcLdrFormats[] =
3740 {
3741 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3742 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3743 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3744 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3745 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3746 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3747 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3748 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3749 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3750 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3751 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3752 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3753 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3754 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3755 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3756 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3757 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3758 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3759 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3760 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3761 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3762 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3763 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3764 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3765 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3766 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3767 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3768 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3769 };
3770
3771 static const struct
3772 {
3773 const char* setName;
3774 const char* featureName;
3775 const VkBool32 VkPhysicalDeviceFeatures::* feature;
3776 const VkFormat* formatsBegin;
3777 const VkFormat* formatsEnd;
3778 } s_compressedFormatSets[] =
3779 {
3780 { "BC", "textureCompressionBC", &VkPhysicalDeviceFeatures::textureCompressionBC, DE_ARRAY_BEGIN(s_allBcFormats), DE_ARRAY_END(s_allBcFormats) },
3781 { "ETC2", "textureCompressionETC2", &VkPhysicalDeviceFeatures::textureCompressionETC2, DE_ARRAY_BEGIN(s_allEtc2Formats), DE_ARRAY_END(s_allEtc2Formats) },
3782 { "ASTC LDR", "textureCompressionASTC_LDR", &VkPhysicalDeviceFeatures::textureCompressionASTC_LDR, DE_ARRAY_BEGIN(s_allAstcLdrFormats), DE_ARRAY_END(s_allAstcLdrFormats) },
3783 };
3784
3785 TestLog& log = context.getTestContext().getLog();
3786 const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures();
3787 int numSupportedSets = 0;
3788 int numErrors = 0;
3789 int numWarnings = 0;
3790
3791 for (int setNdx = 0; setNdx < DE_LENGTH_OF_ARRAY(s_compressedFormatSets); ++setNdx)
3792 {
3793 const char* const setName = s_compressedFormatSets[setNdx].setName;
3794 const char* const featureName = s_compressedFormatSets[setNdx].featureName;
3795 const bool featureBitSet = features.*s_compressedFormatSets[setNdx].feature == VK_TRUE;
3796 const VkFormatFeatureFlags requiredFeatures =
3797 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
3798 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
3799 const bool allSupported = optimalTilingFeaturesSupportedForAll(context,
3800 s_compressedFormatSets[setNdx].formatsBegin,
3801 s_compressedFormatSets[setNdx].formatsEnd,
3802 requiredFeatures);
3803
3804 if (featureBitSet && !allSupported)
3805 {
3806 log << TestLog::Message << "ERROR: " << featureName << " = VK_TRUE but " << setName << " formats not supported" << TestLog::EndMessage;
3807 numErrors += 1;
3808 }
3809 else if (allSupported && !featureBitSet)
3810 {
3811 log << TestLog::Message << "WARNING: " << setName << " formats supported but " << featureName << " = VK_FALSE" << TestLog::EndMessage;
3812 numWarnings += 1;
3813 }
3814
3815 if (featureBitSet)
3816 {
3817 log << TestLog::Message << "All " << setName << " formats are supported" << TestLog::EndMessage;
3818 numSupportedSets += 1;
3819 }
3820 else
3821 log << TestLog::Message << setName << " formats are not supported" << TestLog::EndMessage;
3822 }
3823
3824 if (numSupportedSets == 0)
3825 {
3826 log << TestLog::Message << "No compressed format sets supported" << TestLog::EndMessage;
3827 numErrors += 1;
3828 }
3829
3830 if (numErrors > 0)
3831 return tcu::TestStatus::fail("Compressed format support not valid");
3832 else if (numWarnings > 0)
3833 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Found inconsistencies in compressed format support");
3834 else
3835 return tcu::TestStatus::pass("Compressed texture format support is valid");
3836 }
3837
createFormatTests(tcu::TestCaseGroup * testGroup)3838 void createFormatTests (tcu::TestCaseGroup* testGroup)
3839 {
3840 DE_STATIC_ASSERT(VK_FORMAT_UNDEFINED == 0);
3841
3842 static const struct
3843 {
3844 VkFormat begin;
3845 VkFormat end;
3846 } s_formatRanges[] =
3847 {
3848 // core formats
3849 { (VkFormat)(VK_FORMAT_UNDEFINED+1), VK_CORE_FORMAT_LAST },
3850
3851 // YCbCr formats
3852 { VK_FORMAT_G8B8G8R8_422_UNORM, (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM+1) },
3853
3854 // YCbCr extended formats
3855 { VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, (VkFormat)(VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT+1) },
3856 };
3857
3858 for (int rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(s_formatRanges); ++rangeNdx)
3859 {
3860 const VkFormat rangeBegin = s_formatRanges[rangeNdx].begin;
3861 const VkFormat rangeEnd = s_formatRanges[rangeNdx].end;
3862
3863 for (VkFormat format = rangeBegin; format != rangeEnd; format = (VkFormat)(format+1))
3864 {
3865 const char* const enumName = getFormatName(format);
3866 const string caseName = de::toLower(string(enumName).substr(10));
3867
3868 addFunctionCase(testGroup, caseName, enumName, formatProperties, format);
3869 }
3870 }
3871
3872 addFunctionCase(testGroup, "depth_stencil", "", testDepthStencilSupported);
3873 addFunctionCase(testGroup, "compressed_formats", "", testCompressedFormatsSupported);
3874 }
3875
getValidImageUsageFlags(const VkFormatFeatureFlags supportedFeatures,const bool useKhrMaintenance1Semantics)3876 VkImageUsageFlags getValidImageUsageFlags (const VkFormatFeatureFlags supportedFeatures, const bool useKhrMaintenance1Semantics)
3877 {
3878 VkImageUsageFlags flags = (VkImageUsageFlags)0;
3879
3880 if (useKhrMaintenance1Semantics)
3881 {
3882 if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) != 0)
3883 flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3884
3885 if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) != 0)
3886 flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3887 }
3888 else
3889 {
3890 // If format is supported at all, it must be valid transfer src+dst
3891 if (supportedFeatures != 0)
3892 flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3893 }
3894
3895 if ((supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
3896 flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
3897
3898 if ((supportedFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) != 0)
3899 flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
3900
3901 if ((supportedFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)
3902 flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
3903
3904 if ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0)
3905 flags |= VK_IMAGE_USAGE_STORAGE_BIT;
3906
3907 return flags;
3908 }
3909
isValidImageUsageFlagCombination(VkImageUsageFlags usage)3910 bool isValidImageUsageFlagCombination (VkImageUsageFlags usage)
3911 {
3912 if ((usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0)
3913 {
3914 const VkImageUsageFlags allowedFlags = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
3915 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
3916 | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
3917 | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
3918
3919 // Only *_ATTACHMENT_BIT flags can be combined with TRANSIENT_ATTACHMENT_BIT
3920 if ((usage & ~allowedFlags) != 0)
3921 return false;
3922
3923 // TRANSIENT_ATTACHMENT_BIT is not valid without COLOR_ or DEPTH_STENCIL_ATTACHMENT_BIT
3924 if ((usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) == 0)
3925 return false;
3926 }
3927
3928 return usage != 0;
3929 }
3930
getValidImageCreateFlags(const VkPhysicalDeviceFeatures & deviceFeatures,VkFormat format,VkFormatFeatureFlags formatFeatures,VkImageType type,VkImageUsageFlags usage)3931 VkImageCreateFlags getValidImageCreateFlags (const VkPhysicalDeviceFeatures& deviceFeatures, VkFormat format, VkFormatFeatureFlags formatFeatures, VkImageType type, VkImageUsageFlags usage)
3932 {
3933 VkImageCreateFlags flags = (VkImageCreateFlags)0;
3934
3935 if ((usage & VK_IMAGE_USAGE_SAMPLED_BIT) != 0)
3936 {
3937 flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
3938
3939 if (type == VK_IMAGE_TYPE_2D && !isYCbCrFormat(format))
3940 {
3941 flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
3942 }
3943 }
3944
3945 if (isYCbCrFormat(format) && getPlaneCount(format) > 1)
3946 {
3947 if (formatFeatures & VK_FORMAT_FEATURE_DISJOINT_BIT_KHR)
3948 flags |= VK_IMAGE_CREATE_DISJOINT_BIT_KHR;
3949 }
3950
3951 if ((usage & (VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT)) != 0 &&
3952 (usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)
3953 {
3954 if (deviceFeatures.sparseBinding)
3955 flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT;
3956
3957 if (deviceFeatures.sparseResidencyAliased)
3958 flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT;
3959 }
3960
3961 return flags;
3962 }
3963
isValidImageCreateFlagCombination(VkImageCreateFlags createFlags)3964 bool isValidImageCreateFlagCombination (VkImageCreateFlags createFlags)
3965 {
3966 bool isValid = true;
3967
3968 if (((createFlags & (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)) != 0) &&
3969 ((createFlags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) == 0))
3970 {
3971 isValid = false;
3972 }
3973
3974 return isValid;
3975 }
3976
isRequiredImageParameterCombination(const VkPhysicalDeviceFeatures & deviceFeatures,const VkFormat format,const VkFormatProperties & formatProperties,const VkImageType imageType,const VkImageTiling imageTiling,const VkImageUsageFlags usageFlags,const VkImageCreateFlags createFlags)3977 bool isRequiredImageParameterCombination (const VkPhysicalDeviceFeatures& deviceFeatures,
3978 const VkFormat format,
3979 const VkFormatProperties& formatProperties,
3980 const VkImageType imageType,
3981 const VkImageTiling imageTiling,
3982 const VkImageUsageFlags usageFlags,
3983 const VkImageCreateFlags createFlags)
3984 {
3985 DE_UNREF(deviceFeatures);
3986 DE_UNREF(formatProperties);
3987 DE_UNREF(createFlags);
3988
3989 // Linear images can have arbitrary limitations
3990 if (imageTiling == VK_IMAGE_TILING_LINEAR)
3991 return false;
3992
3993 // Support for other usages for compressed formats is optional
3994 if (isCompressedFormat(format) &&
3995 (usageFlags & ~(VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT)) != 0)
3996 return false;
3997
3998 // Support for 1D, and sliced 3D compressed formats is optional
3999 if (isCompressedFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
4000 return false;
4001
4002 // Support for 1D and 3D depth/stencil textures is optional
4003 if (isDepthStencilFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
4004 return false;
4005
4006 DE_ASSERT(deviceFeatures.sparseBinding || (createFlags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) == 0);
4007 DE_ASSERT(deviceFeatures.sparseResidencyAliased || (createFlags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) == 0);
4008
4009 if (isYCbCrFormat(format) && (createFlags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)))
4010 return false;
4011
4012 if (createFlags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)
4013 {
4014 if (isCompressedFormat(format))
4015 return false;
4016
4017 if (isDepthStencilFormat(format))
4018 return false;
4019
4020 if (!deIsPowerOfTwo32(mapVkFormat(format).getPixelSize()))
4021 return false;
4022
4023 switch (imageType)
4024 {
4025 case VK_IMAGE_TYPE_2D:
4026 return (deviceFeatures.sparseResidencyImage2D == VK_TRUE);
4027 case VK_IMAGE_TYPE_3D:
4028 return (deviceFeatures.sparseResidencyImage3D == VK_TRUE);
4029 default:
4030 return false;
4031 }
4032 }
4033
4034 return true;
4035 }
4036
getRequiredOptimalTilingSampleCounts(const VkPhysicalDeviceLimits & deviceLimits,const VkFormat format,const VkImageUsageFlags usageFlags)4037 VkSampleCountFlags getRequiredOptimalTilingSampleCounts (const VkPhysicalDeviceLimits& deviceLimits,
4038 const VkFormat format,
4039 const VkImageUsageFlags usageFlags)
4040 {
4041 if (isCompressedFormat(format))
4042 return VK_SAMPLE_COUNT_1_BIT;
4043
4044 bool hasDepthComp = false;
4045 bool hasStencilComp = false;
4046 const bool isYCbCr = isYCbCrFormat(format);
4047 if (!isYCbCr)
4048 {
4049 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
4050 hasDepthComp = (tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::DS);
4051 hasStencilComp = (tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS);
4052 }
4053
4054 const bool isColorFormat = !hasDepthComp && !hasStencilComp;
4055 VkSampleCountFlags sampleCounts = ~(VkSampleCountFlags)0;
4056
4057 DE_ASSERT((hasDepthComp || hasStencilComp) != isColorFormat);
4058
4059 if ((usageFlags & VK_IMAGE_USAGE_STORAGE_BIT) != 0)
4060 sampleCounts &= deviceLimits.storageImageSampleCounts;
4061
4062 if ((usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT) != 0)
4063 {
4064 if (hasDepthComp)
4065 sampleCounts &= deviceLimits.sampledImageDepthSampleCounts;
4066
4067 if (hasStencilComp)
4068 sampleCounts &= deviceLimits.sampledImageStencilSampleCounts;
4069
4070 if (isColorFormat)
4071 {
4072 if (isYCbCr)
4073 sampleCounts &= deviceLimits.sampledImageColorSampleCounts;
4074 else
4075 {
4076 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
4077 const tcu::TextureChannelClass chnClass = tcu::getTextureChannelClass(tcuFormat.type);
4078
4079 if (chnClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ||
4080 chnClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
4081 sampleCounts &= deviceLimits.sampledImageIntegerSampleCounts;
4082 else
4083 sampleCounts &= deviceLimits.sampledImageColorSampleCounts;
4084 }
4085 }
4086 }
4087
4088 if ((usageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) != 0)
4089 sampleCounts &= deviceLimits.framebufferColorSampleCounts;
4090
4091 if ((usageFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)
4092 {
4093 if (hasDepthComp)
4094 sampleCounts &= deviceLimits.framebufferDepthSampleCounts;
4095
4096 if (hasStencilComp)
4097 sampleCounts &= deviceLimits.framebufferStencilSampleCounts;
4098 }
4099
4100 // If there is no usage flag set that would have corresponding device limit,
4101 // only VK_SAMPLE_COUNT_1_BIT is required.
4102 if (sampleCounts == ~(VkSampleCountFlags)0)
4103 sampleCounts &= VK_SAMPLE_COUNT_1_BIT;
4104
4105 return sampleCounts;
4106 }
4107
4108 struct ImageFormatPropertyCase
4109 {
4110 typedef tcu::TestStatus (*Function) (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling);
4111
4112 Function testFunction;
4113 VkFormat format;
4114 VkImageType imageType;
4115 VkImageTiling tiling;
4116
ImageFormatPropertyCasevkt::api::__anona6c540bb0111::ImageFormatPropertyCase4117 ImageFormatPropertyCase (Function testFunction_, VkFormat format_, VkImageType imageType_, VkImageTiling tiling_)
4118 : testFunction (testFunction_)
4119 , format (format_)
4120 , imageType (imageType_)
4121 , tiling (tiling_)
4122 {}
4123
ImageFormatPropertyCasevkt::api::__anona6c540bb0111::ImageFormatPropertyCase4124 ImageFormatPropertyCase (void)
4125 : testFunction ((Function)DE_NULL)
4126 , format (VK_FORMAT_UNDEFINED)
4127 , imageType (VK_CORE_IMAGE_TYPE_LAST)
4128 , tiling (VK_CORE_IMAGE_TILING_LAST)
4129 {}
4130 };
4131
imageFormatProperties(Context & context,const VkFormat format,const VkImageType imageType,const VkImageTiling tiling)4132 tcu::TestStatus imageFormatProperties (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
4133 {
4134 if (isYCbCrFormat(format))
4135 // check if Ycbcr format enums are valid given the version and extensions
4136 checkYcbcrApiSupport(context);
4137
4138 TestLog& log = context.getTestContext().getLog();
4139 const VkPhysicalDeviceFeatures& deviceFeatures = context.getDeviceFeatures();
4140 const VkPhysicalDeviceLimits& deviceLimits = context.getDeviceProperties().limits;
4141 const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
4142 const bool hasKhrMaintenance1 = context.isDeviceFunctionalitySupported("VK_KHR_maintenance1");
4143
4144 const VkFormatFeatureFlags supportedFeatures = tiling == VK_IMAGE_TILING_LINEAR ? formatProperties.linearTilingFeatures : formatProperties.optimalTilingFeatures;
4145 const VkImageUsageFlags usageFlagSet = getValidImageUsageFlags(supportedFeatures, hasKhrMaintenance1);
4146
4147 tcu::ResultCollector results (log, "ERROR: ");
4148
4149 if (hasKhrMaintenance1 && (supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
4150 {
4151 results.check((supportedFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT|VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) != 0,
4152 "A sampled image format must have VK_FORMAT_FEATURE_TRANSFER_SRC_BIT and VK_FORMAT_FEATURE_TRANSFER_DST_BIT format feature flags set");
4153 }
4154
4155 if (isYcbcrConversionSupported(context) && (format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR || format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR))
4156 {
4157 VkFormatFeatureFlags requiredFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
4158 if (tiling == VK_IMAGE_TILING_OPTIMAL)
4159 requiredFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
4160
4161 results.check((supportedFeatures & requiredFeatures) == requiredFeatures,
4162 getFormatName(format) + string(" must support ") + de::toString(getFormatFeatureFlagsStr(requiredFeatures)));
4163 }
4164
4165 for (VkImageUsageFlags curUsageFlags = 0; curUsageFlags <= usageFlagSet; curUsageFlags++)
4166 {
4167 if ((curUsageFlags & ~usageFlagSet) != 0 ||
4168 !isValidImageUsageFlagCombination(curUsageFlags))
4169 continue;
4170
4171 const VkImageCreateFlags createFlagSet = getValidImageCreateFlags(deviceFeatures, format, supportedFeatures, imageType, curUsageFlags);
4172
4173 for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= createFlagSet; curCreateFlags++)
4174 {
4175 if ((curCreateFlags & ~createFlagSet) != 0 ||
4176 !isValidImageCreateFlagCombination(curCreateFlags))
4177 continue;
4178
4179 const bool isRequiredCombination = isRequiredImageParameterCombination(deviceFeatures,
4180 format,
4181 formatProperties,
4182 imageType,
4183 tiling,
4184 curUsageFlags,
4185 curCreateFlags);
4186 VkImageFormatProperties properties;
4187 VkResult queryResult;
4188
4189 log << TestLog::Message << "Testing " << getImageTypeStr(imageType) << ", "
4190 << getImageTilingStr(tiling) << ", "
4191 << getImageUsageFlagsStr(curUsageFlags) << ", "
4192 << getImageCreateFlagsStr(curCreateFlags)
4193 << TestLog::EndMessage;
4194
4195 // Set return value to known garbage
4196 deMemset(&properties, 0xcd, sizeof(properties));
4197
4198 queryResult = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(),
4199 format,
4200 imageType,
4201 tiling,
4202 curUsageFlags,
4203 curCreateFlags,
4204 &properties);
4205
4206 if (queryResult == VK_SUCCESS)
4207 {
4208 const deUint32 fullMipPyramidSize = de::max(de::max(deLog2Floor32(properties.maxExtent.width),
4209 deLog2Floor32(properties.maxExtent.height)),
4210 deLog2Floor32(properties.maxExtent.depth)) + 1;
4211
4212 log << TestLog::Message << properties << "\n" << TestLog::EndMessage;
4213
4214 results.check(imageType != VK_IMAGE_TYPE_1D || (properties.maxExtent.width >= 1 && properties.maxExtent.height == 1 && properties.maxExtent.depth == 1), "Invalid dimensions for 1D image");
4215 results.check(imageType != VK_IMAGE_TYPE_2D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth == 1), "Invalid dimensions for 2D image");
4216 results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth >= 1), "Invalid dimensions for 3D image");
4217 results.check(imageType != VK_IMAGE_TYPE_3D || properties.maxArrayLayers == 1, "Invalid maxArrayLayers for 3D image");
4218
4219 if (tiling == VK_IMAGE_TILING_OPTIMAL && imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
4220 (supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)))
4221 {
4222 const VkSampleCountFlags requiredSampleCounts = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
4223 results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
4224 }
4225 else
4226 results.check(properties.sampleCounts == VK_SAMPLE_COUNT_1_BIT, "sampleCounts != VK_SAMPLE_COUNT_1_BIT");
4227
4228 if (isRequiredCombination)
4229 {
4230 results.check(imageType != VK_IMAGE_TYPE_1D || (properties.maxExtent.width >= deviceLimits.maxImageDimension1D),
4231 "Reported dimensions smaller than device limits");
4232 results.check(imageType != VK_IMAGE_TYPE_2D || (properties.maxExtent.width >= deviceLimits.maxImageDimension2D &&
4233 properties.maxExtent.height >= deviceLimits.maxImageDimension2D),
4234 "Reported dimensions smaller than device limits");
4235 results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width >= deviceLimits.maxImageDimension3D &&
4236 properties.maxExtent.height >= deviceLimits.maxImageDimension3D &&
4237 properties.maxExtent.depth >= deviceLimits.maxImageDimension3D),
4238 "Reported dimensions smaller than device limits");
4239 results.check((isYCbCrFormat(format) && (properties.maxMipLevels == 1)) || properties.maxMipLevels == fullMipPyramidSize,
4240 "Invalid mip pyramid size");
4241 results.check((isYCbCrFormat(format) && (properties.maxArrayLayers == 1)) || imageType == VK_IMAGE_TYPE_3D ||
4242 properties.maxArrayLayers >= deviceLimits.maxImageArrayLayers, "Invalid maxArrayLayers");
4243 }
4244 else
4245 {
4246 results.check(properties.maxMipLevels == 1 || properties.maxMipLevels == fullMipPyramidSize, "Invalid mip pyramid size");
4247 results.check(properties.maxArrayLayers >= 1, "Invalid maxArrayLayers");
4248 }
4249
4250 results.check(properties.maxResourceSize >= (VkDeviceSize)MINIMUM_REQUIRED_IMAGE_RESOURCE_SIZE,
4251 "maxResourceSize smaller than minimum required size");
4252 }
4253 else if (queryResult == VK_ERROR_FORMAT_NOT_SUPPORTED)
4254 {
4255 log << TestLog::Message << "Got VK_ERROR_FORMAT_NOT_SUPPORTED" << TestLog::EndMessage;
4256
4257 if (isRequiredCombination)
4258 results.fail("VK_ERROR_FORMAT_NOT_SUPPORTED returned for required image parameter combination");
4259
4260 // Specification requires that all fields are set to 0
4261 results.check(properties.maxExtent.width == 0, "maxExtent.width != 0");
4262 results.check(properties.maxExtent.height == 0, "maxExtent.height != 0");
4263 results.check(properties.maxExtent.depth == 0, "maxExtent.depth != 0");
4264 results.check(properties.maxMipLevels == 0, "maxMipLevels != 0");
4265 results.check(properties.maxArrayLayers == 0, "maxArrayLayers != 0");
4266 results.check(properties.sampleCounts == 0, "sampleCounts != 0");
4267 results.check(properties.maxResourceSize == 0, "maxResourceSize != 0");
4268 }
4269 else
4270 {
4271 results.fail("Got unexpected error" + de::toString(queryResult));
4272 }
4273 }
4274 }
4275
4276 return tcu::TestStatus(results.getResult(), results.getMessage());
4277 }
4278
4279 // VK_KHR_get_physical_device_properties2
4280
toString(const VkPhysicalDevicePCIBusInfoPropertiesEXT & value)4281 string toString(const VkPhysicalDevicePCIBusInfoPropertiesEXT& value)
4282 {
4283 std::ostringstream s;
4284 s << "VkPhysicalDevicePCIBusInfoPropertiesEXT = {\n";
4285 s << "\tsType = " << value.sType << '\n';
4286 s << "\tpciDomain = " << value.pciDomain << '\n';
4287 s << "\tpciBus = " << value.pciBus << '\n';
4288 s << "\tpciDevice = " << value.pciDevice << '\n';
4289 s << "\tpciFunction = " << value.pciFunction << '\n';
4290 s << '}';
4291 return s.str();
4292 }
4293
checkExtension(vector<VkExtensionProperties> & properties,const char * extension)4294 bool checkExtension (vector<VkExtensionProperties>& properties, const char* extension)
4295 {
4296 for (size_t ndx = 0; ndx < properties.size(); ++ndx)
4297 {
4298 if (strncmp(properties[ndx].extensionName, extension, VK_MAX_EXTENSION_NAME_SIZE) == 0)
4299 return true;
4300 }
4301 return false;
4302 }
4303
4304 #include "vkDeviceFeatures2.inl"
4305
deviceFeatures2(Context & context)4306 tcu::TestStatus deviceFeatures2 (Context& context)
4307 {
4308 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
4309 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4310 const InstanceDriver& vki (instance.getDriver());
4311 TestLog& log = context.getTestContext().getLog();
4312 VkPhysicalDeviceFeatures coreFeatures;
4313 VkPhysicalDeviceFeatures2 extFeatures;
4314
4315 deMemset(&coreFeatures, 0xcd, sizeof(coreFeatures));
4316 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features));
4317 std::vector<std::string> instExtensions = context.getInstanceExtensions();
4318
4319 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
4320 extFeatures.pNext = DE_NULL;
4321
4322 vki.getPhysicalDeviceFeatures(physicalDevice, &coreFeatures);
4323 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
4324
4325 TCU_CHECK(extFeatures.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
4326 TCU_CHECK(extFeatures.pNext == DE_NULL);
4327
4328 if (deMemCmp(&coreFeatures, &extFeatures.features, sizeof(VkPhysicalDeviceFeatures)) != 0)
4329 TCU_FAIL("Mismatch between features reported by vkGetPhysicalDeviceFeatures and vkGetPhysicalDeviceFeatures2");
4330
4331 log << TestLog::Message << extFeatures << TestLog::EndMessage;
4332
4333 return tcu::TestStatus::pass("Querying device features succeeded");
4334 }
4335
deviceProperties2(Context & context)4336 tcu::TestStatus deviceProperties2 (Context& context)
4337 {
4338 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4339 const InstanceDriver& vki (instance.getDriver());
4340 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4341 TestLog& log = context.getTestContext().getLog();
4342 VkPhysicalDeviceProperties coreProperties;
4343 VkPhysicalDeviceProperties2 extProperties;
4344
4345 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
4346 extProperties.pNext = DE_NULL;
4347
4348 vki.getPhysicalDeviceProperties(physicalDevice, &coreProperties);
4349 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4350
4351 TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
4352 TCU_CHECK(extProperties.pNext == DE_NULL);
4353
4354 // We can't use memcmp() here because the structs may contain padding bytes that drivers may or may not
4355 // have written while writing the data and memcmp will compare them anyway, so we iterate through the
4356 // valid bytes for each field in the struct and compare only the valid bytes for each one.
4357 for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(s_physicalDevicePropertiesOffsetTable); propNdx++)
4358 {
4359 const size_t offset = s_physicalDevicePropertiesOffsetTable[propNdx].offset;
4360 const size_t size = s_physicalDevicePropertiesOffsetTable[propNdx].size;
4361
4362 const deUint8* corePropertyBytes = reinterpret_cast<deUint8*>(&coreProperties) + offset;
4363 const deUint8* extPropertyBytes = reinterpret_cast<deUint8*>(&extProperties.properties) + offset;
4364
4365 if (deMemCmp(corePropertyBytes, extPropertyBytes, size) != 0)
4366 TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceProperties and vkGetPhysicalDeviceProperties2");
4367 }
4368
4369 log << TestLog::Message << extProperties.properties << TestLog::EndMessage;
4370
4371 const int count = 2u;
4372
4373 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
4374 const bool khr_external_fence_capabilities = checkExtension(properties, "VK_KHR_external_fence_capabilities") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4375 const bool khr_external_memory_capabilities = checkExtension(properties, "VK_KHR_external_memory_capabilities") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4376 const bool khr_external_semaphore_capabilities = checkExtension(properties, "VK_KHR_external_semaphore_capabilities") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4377 const bool khr_multiview = checkExtension(properties, "VK_KHR_multiview") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4378 const bool khr_device_protected_memory = context.contextSupports(vk::ApiVersion(1, 1, 0));
4379 const bool khr_device_subgroup = context.contextSupports(vk::ApiVersion(1, 1, 0));
4380 const bool khr_maintenance2 = checkExtension(properties, "VK_KHR_maintenance2") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4381 const bool khr_maintenance3 = checkExtension(properties, "VK_KHR_maintenance3") || context.contextSupports(vk::ApiVersion(1, 1, 0));
4382 const bool khr_depth_stencil_resolve = checkExtension(properties, "VK_KHR_depth_stencil_resolve") || context.contextSupports(vk::ApiVersion(1, 2, 0));
4383 const bool khr_driver_properties = checkExtension(properties, "VK_KHR_driver_properties") || context.contextSupports(vk::ApiVersion(1, 2, 0));
4384 const bool khr_shader_float_controls = checkExtension(properties, "VK_KHR_shader_float_controls") || context.contextSupports(vk::ApiVersion(1, 2, 0));
4385 const bool khr_descriptor_indexing = checkExtension(properties, "VK_EXT_descriptor_indexing") || context.contextSupports(vk::ApiVersion(1, 2, 0));
4386 const bool khr_sampler_filter_minmax = checkExtension(properties, "VK_EXT_sampler_filter_minmax") || context.contextSupports(vk::ApiVersion(1, 2, 0));
4387 const bool khr_integer_dot_product = checkExtension(properties, "VK_KHR_shader_integer_dot_product") || context.contextSupports(vk::ApiVersion(1, 3, 0));
4388 const bool khr_inline_uniform_block = checkExtension(properties, "VK_EXT_inline_uniform_block") || context.contextSupports(vk::ApiVersion(1, 3, 0));
4389 const bool khr_maintenance4 = checkExtension(properties, "VK_KHR_maintenance4") || context.contextSupports(vk::ApiVersion(1, 3, 0));
4390 const bool khr_subgroup_size_control = checkExtension(properties, "VK_EXT_subgroup_size_control") || context.contextSupports(vk::ApiVersion(1, 3, 0));
4391 const bool khr_texel_buffer_alignment = checkExtension(properties, "VK_EXT_texel_buffer_alignment") || context.contextSupports(vk::ApiVersion(1, 3, 0));
4392
4393 VkPhysicalDeviceIDProperties idProperties[count];
4394 VkPhysicalDeviceMultiviewProperties multiviewProperties[count];
4395 VkPhysicalDeviceProtectedMemoryProperties protectedMemoryPropertiesKHR[count];
4396 VkPhysicalDeviceSubgroupProperties subgroupProperties[count];
4397 VkPhysicalDevicePointClippingProperties pointClippingProperties[count];
4398 VkPhysicalDeviceMaintenance3Properties maintenance3Properties[count];
4399 VkPhysicalDeviceDepthStencilResolveProperties depthStencilResolveProperties[count];
4400 VkPhysicalDeviceDriverProperties driverProperties[count];
4401 VkPhysicalDeviceFloatControlsProperties floatControlsProperties[count];
4402 VkPhysicalDeviceDescriptorIndexingProperties descriptorIndexingProperties[count];
4403 VkPhysicalDeviceSamplerFilterMinmaxProperties samplerFilterMinmaxProperties[count];
4404 VkPhysicalDeviceShaderIntegerDotProductProperties integerDotProductProperties[count];
4405 VkPhysicalDeviceInlineUniformBlockProperties inlineUniformBlockProperties[count];
4406 VkPhysicalDeviceMaintenance4Properties maintenance4Properties[count];
4407 VkPhysicalDeviceSubgroupSizeControlProperties subgroupSizeControlProperties[count];
4408 VkPhysicalDeviceTexelBufferAlignmentProperties texelBufferAlignmentProperties[count];
4409
4410 for (int ndx = 0; ndx < count; ++ndx)
4411 {
4412 deMemset(&idProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceIDProperties ));
4413 deMemset(&multiviewProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceMultiviewProperties ));
4414 deMemset(&protectedMemoryPropertiesKHR[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceProtectedMemoryProperties ));
4415 deMemset(&subgroupProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSubgroupProperties ));
4416 deMemset(&pointClippingProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDevicePointClippingProperties ));
4417 deMemset(&maintenance3Properties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceMaintenance3Properties ));
4418 deMemset(&depthStencilResolveProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceDepthStencilResolveProperties ));
4419 deMemset(&driverProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceDriverProperties ));
4420 deMemset(&floatControlsProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceFloatControlsProperties ));
4421 deMemset(&descriptorIndexingProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceDescriptorIndexingProperties ));
4422 deMemset(&samplerFilterMinmaxProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties ));
4423 deMemset(&integerDotProductProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR ));
4424 deMemset(&inlineUniformBlockProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceInlineUniformBlockProperties ));
4425 deMemset(&maintenance4Properties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceMaintenance4Properties ));
4426 deMemset(&subgroupSizeControlProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties ));
4427 deMemset(&texelBufferAlignmentProperties[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties ));
4428
4429 idProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
4430 idProperties[ndx].pNext = &multiviewProperties[ndx];
4431
4432 multiviewProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
4433 multiviewProperties[ndx].pNext = &protectedMemoryPropertiesKHR[ndx];
4434
4435 protectedMemoryPropertiesKHR[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
4436 protectedMemoryPropertiesKHR[ndx].pNext = &subgroupProperties[ndx];
4437
4438 subgroupProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
4439 subgroupProperties[ndx].pNext = &pointClippingProperties[ndx];
4440
4441 pointClippingProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
4442 pointClippingProperties[ndx].pNext = &maintenance3Properties[ndx];
4443
4444 maintenance3Properties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
4445 maintenance3Properties[ndx].pNext = &depthStencilResolveProperties[ndx];
4446
4447 depthStencilResolveProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
4448 depthStencilResolveProperties[ndx].pNext = &driverProperties[ndx];
4449
4450 driverProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
4451 driverProperties[ndx].pNext = &floatControlsProperties[ndx];
4452
4453 floatControlsProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
4454 floatControlsProperties[ndx].pNext = &descriptorIndexingProperties[ndx];
4455
4456 descriptorIndexingProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
4457 descriptorIndexingProperties[ndx].pNext = &samplerFilterMinmaxProperties[ndx];
4458
4459 samplerFilterMinmaxProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
4460 samplerFilterMinmaxProperties[ndx].pNext = &integerDotProductProperties[ndx];
4461
4462 integerDotProductProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR;
4463 integerDotProductProperties[ndx].pNext = &inlineUniformBlockProperties[ndx];
4464
4465 inlineUniformBlockProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
4466 inlineUniformBlockProperties[ndx].pNext = &maintenance4Properties[ndx];
4467
4468 maintenance4Properties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
4469 maintenance4Properties[ndx].pNext = &subgroupSizeControlProperties[ndx];
4470
4471 subgroupSizeControlProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
4472 subgroupSizeControlProperties[ndx].pNext = &texelBufferAlignmentProperties[ndx];
4473
4474 texelBufferAlignmentProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
4475 texelBufferAlignmentProperties[ndx].pNext = DE_NULL;
4476
4477 extProperties.pNext = &idProperties[ndx];
4478
4479 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4480 }
4481
4482 if ( khr_external_fence_capabilities || khr_external_memory_capabilities || khr_external_semaphore_capabilities )
4483 log << TestLog::Message << idProperties[0] << TestLog::EndMessage;
4484 if (khr_multiview)
4485 log << TestLog::Message << multiviewProperties[0] << TestLog::EndMessage;
4486 if (khr_device_protected_memory)
4487 log << TestLog::Message << protectedMemoryPropertiesKHR[0] << TestLog::EndMessage;
4488 if (khr_device_subgroup)
4489 log << TestLog::Message << subgroupProperties[0] << TestLog::EndMessage;
4490 if (khr_maintenance2)
4491 log << TestLog::Message << pointClippingProperties[0] << TestLog::EndMessage;
4492 if (khr_maintenance3)
4493 log << TestLog::Message << maintenance3Properties[0] << TestLog::EndMessage;
4494 if (khr_depth_stencil_resolve)
4495 log << TestLog::Message << depthStencilResolveProperties[0] << TestLog::EndMessage;
4496 if (khr_driver_properties)
4497 log << TestLog::Message << driverProperties[0] << TestLog::EndMessage;
4498 if (khr_shader_float_controls)
4499 log << TestLog::Message << floatControlsProperties[0] << TestLog::EndMessage;
4500 if (khr_descriptor_indexing)
4501 log << TestLog::Message << descriptorIndexingProperties[0] << TestLog::EndMessage;
4502 if (khr_sampler_filter_minmax)
4503 log << TestLog::Message << samplerFilterMinmaxProperties[0] << TestLog::EndMessage;
4504 if (khr_integer_dot_product)
4505 log << TestLog::Message << integerDotProductProperties[0] << TestLog::EndMessage;
4506 if (khr_inline_uniform_block)
4507 log << TestLog::Message << inlineUniformBlockProperties[0] << TestLog::EndMessage;
4508 if (khr_maintenance4)
4509 log << TestLog::Message << maintenance4Properties[0] << TestLog::EndMessage;
4510 if (khr_subgroup_size_control)
4511 log << TestLog::Message << subgroupSizeControlProperties[0] << TestLog::EndMessage;
4512 if (khr_texel_buffer_alignment)
4513 log << TestLog::Message << texelBufferAlignmentProperties[0] << TestLog::EndMessage;
4514
4515 if (khr_integer_dot_product)
4516 log << TestLog::Message << integerDotProductProperties[0] << TestLog::EndMessage;
4517
4518 if ( khr_external_fence_capabilities || khr_external_memory_capabilities || khr_external_semaphore_capabilities )
4519 {
4520 if ((deMemCmp(idProperties[0].deviceUUID, idProperties[1].deviceUUID, VK_UUID_SIZE) != 0) ||
4521 (deMemCmp(idProperties[0].driverUUID, idProperties[1].driverUUID, VK_UUID_SIZE) != 0) ||
4522 (idProperties[0].deviceLUIDValid != idProperties[1].deviceLUIDValid))
4523 {
4524 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties");
4525 }
4526 else if (idProperties[0].deviceLUIDValid)
4527 {
4528 // If deviceLUIDValid is VK_FALSE, the contents of deviceLUID and deviceNodeMask are undefined
4529 // so thay can only be compared when deviceLUIDValid is VK_TRUE.
4530 if ((deMemCmp(idProperties[0].deviceLUID, idProperties[1].deviceLUID, VK_LUID_SIZE) != 0) ||
4531 (idProperties[0].deviceNodeMask != idProperties[1].deviceNodeMask))
4532 {
4533 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties");
4534 }
4535 }
4536 }
4537 if (khr_multiview &&
4538 (multiviewProperties[0].maxMultiviewViewCount != multiviewProperties[1].maxMultiviewViewCount ||
4539 multiviewProperties[0].maxMultiviewInstanceIndex != multiviewProperties[1].maxMultiviewInstanceIndex))
4540 {
4541 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewProperties");
4542 }
4543 if (khr_device_protected_memory &&
4544 (protectedMemoryPropertiesKHR[0].protectedNoFault != protectedMemoryPropertiesKHR[1].protectedNoFault))
4545 {
4546 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties");
4547 }
4548 if (khr_device_subgroup &&
4549 (subgroupProperties[0].subgroupSize != subgroupProperties[1].subgroupSize ||
4550 subgroupProperties[0].supportedStages != subgroupProperties[1].supportedStages ||
4551 subgroupProperties[0].supportedOperations != subgroupProperties[1].supportedOperations ||
4552 subgroupProperties[0].quadOperationsInAllStages != subgroupProperties[1].quadOperationsInAllStages ))
4553 {
4554 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties");
4555 }
4556 if (khr_maintenance2 &&
4557 (pointClippingProperties[0].pointClippingBehavior != pointClippingProperties[1].pointClippingBehavior))
4558 {
4559 TCU_FAIL("Mismatch between VkPhysicalDevicePointClippingProperties");
4560 }
4561 if (khr_maintenance3 &&
4562 (maintenance3Properties[0].maxPerSetDescriptors != maintenance3Properties[1].maxPerSetDescriptors ||
4563 maintenance3Properties[0].maxMemoryAllocationSize != maintenance3Properties[1].maxMemoryAllocationSize))
4564 {
4565 if (protectedMemoryPropertiesKHR[0].protectedNoFault != protectedMemoryPropertiesKHR[1].protectedNoFault)
4566 {
4567 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties");
4568 }
4569 if ((subgroupProperties[0].subgroupSize != subgroupProperties[1].subgroupSize) ||
4570 (subgroupProperties[0].supportedStages != subgroupProperties[1].supportedStages) ||
4571 (subgroupProperties[0].supportedOperations != subgroupProperties[1].supportedOperations) ||
4572 (subgroupProperties[0].quadOperationsInAllStages != subgroupProperties[1].quadOperationsInAllStages))
4573 {
4574 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties");
4575 }
4576 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance3Properties");
4577 }
4578 if (khr_depth_stencil_resolve &&
4579 (depthStencilResolveProperties[0].supportedDepthResolveModes != depthStencilResolveProperties[1].supportedDepthResolveModes ||
4580 depthStencilResolveProperties[0].supportedStencilResolveModes != depthStencilResolveProperties[1].supportedStencilResolveModes ||
4581 depthStencilResolveProperties[0].independentResolveNone != depthStencilResolveProperties[1].independentResolveNone ||
4582 depthStencilResolveProperties[0].independentResolve != depthStencilResolveProperties[1].independentResolve))
4583 {
4584 TCU_FAIL("Mismatch between VkPhysicalDeviceDepthStencilResolveProperties");
4585 }
4586 if (khr_driver_properties &&
4587 (driverProperties[0].driverID != driverProperties[1].driverID ||
4588 strncmp(driverProperties[0].driverName, driverProperties[1].driverName, VK_MAX_DRIVER_NAME_SIZE) != 0 ||
4589 strncmp(driverProperties[0].driverInfo, driverProperties[1].driverInfo, VK_MAX_DRIVER_INFO_SIZE) != 0 ||
4590 driverProperties[0].conformanceVersion.major != driverProperties[1].conformanceVersion.major ||
4591 driverProperties[0].conformanceVersion.minor != driverProperties[1].conformanceVersion.minor ||
4592 driverProperties[0].conformanceVersion.subminor != driverProperties[1].conformanceVersion.subminor ||
4593 driverProperties[0].conformanceVersion.patch != driverProperties[1].conformanceVersion.patch))
4594 {
4595 TCU_FAIL("Mismatch between VkPhysicalDeviceDriverProperties");
4596 }
4597 if (khr_shader_float_controls &&
4598 (floatControlsProperties[0].denormBehaviorIndependence != floatControlsProperties[1].denormBehaviorIndependence ||
4599 floatControlsProperties[0].roundingModeIndependence != floatControlsProperties[1].roundingModeIndependence ||
4600 floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat16 != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat16 ||
4601 floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat32 != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat32 ||
4602 floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat64 != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat64 ||
4603 floatControlsProperties[0].shaderDenormPreserveFloat16 != floatControlsProperties[1].shaderDenormPreserveFloat16 ||
4604 floatControlsProperties[0].shaderDenormPreserveFloat32 != floatControlsProperties[1].shaderDenormPreserveFloat32 ||
4605 floatControlsProperties[0].shaderDenormPreserveFloat64 != floatControlsProperties[1].shaderDenormPreserveFloat64 ||
4606 floatControlsProperties[0].shaderDenormFlushToZeroFloat16 != floatControlsProperties[1].shaderDenormFlushToZeroFloat16 ||
4607 floatControlsProperties[0].shaderDenormFlushToZeroFloat32 != floatControlsProperties[1].shaderDenormFlushToZeroFloat32 ||
4608 floatControlsProperties[0].shaderDenormFlushToZeroFloat64 != floatControlsProperties[1].shaderDenormFlushToZeroFloat64 ||
4609 floatControlsProperties[0].shaderRoundingModeRTEFloat16 != floatControlsProperties[1].shaderRoundingModeRTEFloat16 ||
4610 floatControlsProperties[0].shaderRoundingModeRTEFloat32 != floatControlsProperties[1].shaderRoundingModeRTEFloat32 ||
4611 floatControlsProperties[0].shaderRoundingModeRTEFloat64 != floatControlsProperties[1].shaderRoundingModeRTEFloat64 ||
4612 floatControlsProperties[0].shaderRoundingModeRTZFloat16 != floatControlsProperties[1].shaderRoundingModeRTZFloat16 ||
4613 floatControlsProperties[0].shaderRoundingModeRTZFloat32 != floatControlsProperties[1].shaderRoundingModeRTZFloat32 ||
4614 floatControlsProperties[0].shaderRoundingModeRTZFloat64 != floatControlsProperties[1].shaderRoundingModeRTZFloat64 ))
4615 {
4616 TCU_FAIL("Mismatch between VkPhysicalDeviceFloatControlsProperties");
4617 }
4618 if (khr_descriptor_indexing &&
4619 (descriptorIndexingProperties[0].maxUpdateAfterBindDescriptorsInAllPools != descriptorIndexingProperties[1].maxUpdateAfterBindDescriptorsInAllPools ||
4620 descriptorIndexingProperties[0].shaderUniformBufferArrayNonUniformIndexingNative != descriptorIndexingProperties[1].shaderUniformBufferArrayNonUniformIndexingNative ||
4621 descriptorIndexingProperties[0].shaderSampledImageArrayNonUniformIndexingNative != descriptorIndexingProperties[1].shaderSampledImageArrayNonUniformIndexingNative ||
4622 descriptorIndexingProperties[0].shaderStorageBufferArrayNonUniformIndexingNative != descriptorIndexingProperties[1].shaderStorageBufferArrayNonUniformIndexingNative ||
4623 descriptorIndexingProperties[0].shaderStorageImageArrayNonUniformIndexingNative != descriptorIndexingProperties[1].shaderStorageImageArrayNonUniformIndexingNative ||
4624 descriptorIndexingProperties[0].shaderInputAttachmentArrayNonUniformIndexingNative != descriptorIndexingProperties[1].shaderInputAttachmentArrayNonUniformIndexingNative ||
4625 descriptorIndexingProperties[0].robustBufferAccessUpdateAfterBind != descriptorIndexingProperties[1].robustBufferAccessUpdateAfterBind ||
4626 descriptorIndexingProperties[0].quadDivergentImplicitLod != descriptorIndexingProperties[1].quadDivergentImplicitLod ||
4627 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindSamplers != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindSamplers ||
4628 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindUniformBuffers != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindUniformBuffers ||
4629 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindStorageBuffers != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindStorageBuffers ||
4630 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindSampledImages != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindSampledImages ||
4631 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindStorageImages != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindStorageImages ||
4632 descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindInputAttachments != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindInputAttachments ||
4633 descriptorIndexingProperties[0].maxPerStageUpdateAfterBindResources != descriptorIndexingProperties[1].maxPerStageUpdateAfterBindResources ||
4634 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindSamplers != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindSamplers ||
4635 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindUniformBuffers != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindUniformBuffers ||
4636 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindUniformBuffersDynamic != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ||
4637 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageBuffers != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageBuffers ||
4638 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageBuffersDynamic != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ||
4639 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindSampledImages != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindSampledImages ||
4640 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageImages != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageImages ||
4641 descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindInputAttachments != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindInputAttachments ))
4642 {
4643 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingProperties");
4644 }
4645 if (khr_sampler_filter_minmax &&
4646 (samplerFilterMinmaxProperties[0].filterMinmaxSingleComponentFormats != samplerFilterMinmaxProperties[1].filterMinmaxSingleComponentFormats ||
4647 samplerFilterMinmaxProperties[0].filterMinmaxImageComponentMapping != samplerFilterMinmaxProperties[1].filterMinmaxImageComponentMapping))
4648 {
4649 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerFilterMinmaxProperties");
4650 }
4651 if (khr_integer_dot_product &&
4652 (integerDotProductProperties[0].integerDotProduct8BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct8BitUnsignedAccelerated ||
4653 integerDotProductProperties[0].integerDotProduct8BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct8BitSignedAccelerated ||
4654 integerDotProductProperties[0].integerDotProduct8BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct8BitMixedSignednessAccelerated ||
4655 integerDotProductProperties[0].integerDotProduct4x8BitPackedUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedUnsignedAccelerated ||
4656 integerDotProductProperties[0].integerDotProduct4x8BitPackedSignedAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedSignedAccelerated ||
4657 integerDotProductProperties[0].integerDotProduct4x8BitPackedMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
4658 integerDotProductProperties[0].integerDotProduct16BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct16BitUnsignedAccelerated ||
4659 integerDotProductProperties[0].integerDotProduct16BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct16BitSignedAccelerated ||
4660 integerDotProductProperties[0].integerDotProduct16BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct16BitMixedSignednessAccelerated ||
4661 integerDotProductProperties[0].integerDotProduct32BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct32BitUnsignedAccelerated ||
4662 integerDotProductProperties[0].integerDotProduct32BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct32BitSignedAccelerated ||
4663 integerDotProductProperties[0].integerDotProduct32BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct32BitMixedSignednessAccelerated ||
4664 integerDotProductProperties[0].integerDotProduct64BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct64BitUnsignedAccelerated ||
4665 integerDotProductProperties[0].integerDotProduct64BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct64BitSignedAccelerated ||
4666 integerDotProductProperties[0].integerDotProduct64BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct64BitMixedSignednessAccelerated ||
4667 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
4668 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
4669 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
4670 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
4671 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
4672 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
4673 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
4674 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
4675 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
4676 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
4677 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
4678 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
4679 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
4680 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
4681 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))
4682 {
4683 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
4684 }
4685 if (khr_inline_uniform_block &&
4686 (inlineUniformBlockProperties[0].maxInlineUniformBlockSize != inlineUniformBlockProperties[1].maxInlineUniformBlockSize ||
4687 inlineUniformBlockProperties[0].maxPerStageDescriptorInlineUniformBlocks != inlineUniformBlockProperties[1].maxPerStageDescriptorInlineUniformBlocks ||
4688 inlineUniformBlockProperties[0].maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks != inlineUniformBlockProperties[1].maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ||
4689 inlineUniformBlockProperties[0].maxDescriptorSetInlineUniformBlocks != inlineUniformBlockProperties[1].maxDescriptorSetInlineUniformBlocks ||
4690 inlineUniformBlockProperties[0].maxDescriptorSetUpdateAfterBindInlineUniformBlocks != inlineUniformBlockProperties[1].maxDescriptorSetUpdateAfterBindInlineUniformBlocks))
4691 {
4692 TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockProperties");
4693 }
4694 if (khr_maintenance4 &&
4695 (maintenance4Properties[0].maxBufferSize != maintenance4Properties[1].maxBufferSize))
4696 {
4697 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Properties");
4698 }
4699 if (khr_subgroup_size_control &&
4700 (subgroupSizeControlProperties[0].minSubgroupSize != subgroupSizeControlProperties[1].minSubgroupSize ||
4701 subgroupSizeControlProperties[0].maxSubgroupSize != subgroupSizeControlProperties[1].maxSubgroupSize ||
4702 subgroupSizeControlProperties[0].maxComputeWorkgroupSubgroups != subgroupSizeControlProperties[1].maxComputeWorkgroupSubgroups ||
4703 subgroupSizeControlProperties[0].requiredSubgroupSizeStages != subgroupSizeControlProperties[1].requiredSubgroupSizeStages))
4704 {
4705 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlProperties");
4706 }
4707 if (khr_texel_buffer_alignment &&
4708 (texelBufferAlignmentProperties[0].storageTexelBufferOffsetAlignmentBytes != texelBufferAlignmentProperties[1].storageTexelBufferOffsetAlignmentBytes ||
4709 texelBufferAlignmentProperties[0].storageTexelBufferOffsetSingleTexelAlignment != texelBufferAlignmentProperties[1].storageTexelBufferOffsetSingleTexelAlignment ||
4710 texelBufferAlignmentProperties[0].uniformTexelBufferOffsetAlignmentBytes != texelBufferAlignmentProperties[1].uniformTexelBufferOffsetAlignmentBytes ||
4711 texelBufferAlignmentProperties[0].uniformTexelBufferOffsetSingleTexelAlignment != texelBufferAlignmentProperties[1].uniformTexelBufferOffsetSingleTexelAlignment))
4712 {
4713 TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentProperties");
4714 }
4715
4716 if (khr_integer_dot_product &&
4717 (integerDotProductProperties[0].integerDotProduct8BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct8BitUnsignedAccelerated ||
4718 integerDotProductProperties[0].integerDotProduct8BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct8BitSignedAccelerated ||
4719 integerDotProductProperties[0].integerDotProduct8BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct8BitMixedSignednessAccelerated ||
4720 integerDotProductProperties[0].integerDotProduct4x8BitPackedUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedUnsignedAccelerated ||
4721 integerDotProductProperties[0].integerDotProduct4x8BitPackedSignedAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedSignedAccelerated ||
4722 integerDotProductProperties[0].integerDotProduct4x8BitPackedMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
4723 integerDotProductProperties[0].integerDotProduct16BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct16BitUnsignedAccelerated ||
4724 integerDotProductProperties[0].integerDotProduct16BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct16BitSignedAccelerated ||
4725 integerDotProductProperties[0].integerDotProduct16BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct16BitMixedSignednessAccelerated ||
4726 integerDotProductProperties[0].integerDotProduct32BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct32BitUnsignedAccelerated ||
4727 integerDotProductProperties[0].integerDotProduct32BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct32BitSignedAccelerated ||
4728 integerDotProductProperties[0].integerDotProduct32BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct32BitMixedSignednessAccelerated ||
4729 integerDotProductProperties[0].integerDotProduct64BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProduct64BitUnsignedAccelerated ||
4730 integerDotProductProperties[0].integerDotProduct64BitSignedAccelerated != integerDotProductProperties[1].integerDotProduct64BitSignedAccelerated ||
4731 integerDotProductProperties[0].integerDotProduct64BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProduct64BitMixedSignednessAccelerated ||
4732 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
4733 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
4734 integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
4735 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
4736 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
4737 integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
4738 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
4739 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
4740 integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
4741 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
4742 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
4743 integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
4744 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
4745 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitSignedAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
4746 integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))
4747 {
4748 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
4749 }
4750
4751 if (isExtensionSupported(properties, RequiredExtension("VK_KHR_push_descriptor")))
4752 {
4753 VkPhysicalDevicePushDescriptorPropertiesKHR pushDescriptorProperties[count];
4754
4755 for (int ndx = 0; ndx < count; ++ndx)
4756 {
4757 deMemset(&pushDescriptorProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR));
4758
4759 pushDescriptorProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
4760 pushDescriptorProperties[ndx].pNext = DE_NULL;
4761
4762 extProperties.pNext = &pushDescriptorProperties[ndx];
4763
4764 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4765
4766 pushDescriptorProperties[ndx].pNext = DE_NULL;
4767 }
4768
4769 log << TestLog::Message << pushDescriptorProperties[0] << TestLog::EndMessage;
4770
4771 if ( pushDescriptorProperties[0].maxPushDescriptors != pushDescriptorProperties[1].maxPushDescriptors )
4772 {
4773 TCU_FAIL("Mismatch between VkPhysicalDevicePushDescriptorPropertiesKHR ");
4774 }
4775 if (pushDescriptorProperties[0].maxPushDescriptors < 32)
4776 {
4777 TCU_FAIL("VkPhysicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors must be at least 32");
4778 }
4779 }
4780
4781 if (isExtensionSupported(properties, RequiredExtension("VK_KHR_performance_query")))
4782 {
4783 VkPhysicalDevicePerformanceQueryPropertiesKHR performanceQueryProperties[count];
4784
4785 for (int ndx = 0; ndx < count; ++ndx)
4786 {
4787 deMemset(&performanceQueryProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR));
4788 performanceQueryProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
4789 performanceQueryProperties[ndx].pNext = DE_NULL;
4790
4791 extProperties.pNext = &performanceQueryProperties[ndx];
4792
4793 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4794 }
4795
4796 log << TestLog::Message << performanceQueryProperties[0] << TestLog::EndMessage;
4797
4798 if (performanceQueryProperties[0].allowCommandBufferQueryCopies != performanceQueryProperties[1].allowCommandBufferQueryCopies)
4799 {
4800 TCU_FAIL("Mismatch between VkPhysicalDevicePerformanceQueryPropertiesKHR");
4801 }
4802 }
4803
4804 if (isExtensionSupported(properties, RequiredExtension("VK_EXT_pci_bus_info", 2, 2)))
4805 {
4806 VkPhysicalDevicePCIBusInfoPropertiesEXT pciBusInfoProperties[count];
4807
4808 for (int ndx = 0; ndx < count; ++ndx)
4809 {
4810 // Each PCI device is identified by an 8-bit domain number, 5-bit
4811 // device number and 3-bit function number[1][2].
4812 //
4813 // In addition, because PCI systems can be interconnected and
4814 // divided in segments, Linux assigns a 16-bit number to the device
4815 // as the "domain". In Windows, the segment or domain is stored in
4816 // the higher 24-bit section of the bus number.
4817 //
4818 // This means the maximum unsigned 32-bit integer for these members
4819 // are invalid values and should change after querying properties.
4820 //
4821 // [1] https://en.wikipedia.org/wiki/PCI_configuration_space
4822 // [2] PCI Express Base Specification Revision 3.0, section 2.2.4.2.
4823 deMemset(pciBusInfoProperties + ndx, 0xFF * ndx, sizeof(pciBusInfoProperties[ndx]));
4824 pciBusInfoProperties[ndx].pciDomain = DEUINT32_MAX;
4825 pciBusInfoProperties[ndx].pciBus = DEUINT32_MAX;
4826 pciBusInfoProperties[ndx].pciDevice = DEUINT32_MAX;
4827 pciBusInfoProperties[ndx].pciFunction = DEUINT32_MAX;
4828
4829 pciBusInfoProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
4830 pciBusInfoProperties[ndx].pNext = DE_NULL;
4831
4832 extProperties.pNext = pciBusInfoProperties + ndx;
4833 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4834 }
4835
4836 log << TestLog::Message << toString(pciBusInfoProperties[0]) << TestLog::EndMessage;
4837
4838 if (pciBusInfoProperties[0].pciDomain != pciBusInfoProperties[1].pciDomain ||
4839 pciBusInfoProperties[0].pciBus != pciBusInfoProperties[1].pciBus ||
4840 pciBusInfoProperties[0].pciDevice != pciBusInfoProperties[1].pciDevice ||
4841 pciBusInfoProperties[0].pciFunction != pciBusInfoProperties[1].pciFunction)
4842 {
4843 TCU_FAIL("Mismatch between VkPhysicalDevicePCIBusInfoPropertiesEXT");
4844 }
4845 if (pciBusInfoProperties[0].pciDomain == DEUINT32_MAX ||
4846 pciBusInfoProperties[0].pciBus == DEUINT32_MAX ||
4847 pciBusInfoProperties[0].pciDevice == DEUINT32_MAX ||
4848 pciBusInfoProperties[0].pciFunction == DEUINT32_MAX)
4849 {
4850 TCU_FAIL("Invalid information in VkPhysicalDevicePCIBusInfoPropertiesEXT");
4851 }
4852 }
4853
4854 if (isExtensionSupported(properties, RequiredExtension("VK_KHR_portability_subset")))
4855 {
4856 VkPhysicalDevicePortabilitySubsetPropertiesKHR portabilitySubsetProperties[count];
4857
4858 for (int ndx = 0; ndx < count; ++ndx)
4859 {
4860 deMemset(&portabilitySubsetProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR));
4861 portabilitySubsetProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
4862 portabilitySubsetProperties[ndx].pNext = DE_NULL;
4863
4864 extProperties.pNext = &portabilitySubsetProperties[ndx];
4865
4866 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4867 }
4868
4869 log << TestLog::Message << portabilitySubsetProperties[0] << TestLog::EndMessage;
4870
4871 if (portabilitySubsetProperties[0].minVertexInputBindingStrideAlignment != portabilitySubsetProperties[1].minVertexInputBindingStrideAlignment)
4872 {
4873 TCU_FAIL("Mismatch between VkPhysicalDevicePortabilitySubsetPropertiesKHR");
4874 }
4875 }
4876
4877 return tcu::TestStatus::pass("Querying device properties succeeded");
4878 }
4879
toString(const VkFormatProperties2 & value)4880 string toString (const VkFormatProperties2& value)
4881 {
4882 std::ostringstream s;
4883 s << "VkFormatProperties2 = {\n";
4884 s << "\tsType = " << value.sType << '\n';
4885 s << "\tformatProperties = {\n";
4886 s << "\tlinearTilingFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.linearTilingFeatures) << '\n';
4887 s << "\toptimalTilingFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.optimalTilingFeatures) << '\n';
4888 s << "\tbufferFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.bufferFeatures) << '\n';
4889 s << "\t}";
4890 s << "}";
4891 return s.str();
4892 }
4893
deviceFormatProperties2(Context & context)4894 tcu::TestStatus deviceFormatProperties2 (Context& context)
4895 {
4896 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4897 const InstanceDriver& vki (instance.getDriver());
4898 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4899 TestLog& log = context.getTestContext().getLog();
4900
4901 for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; ++formatNdx)
4902 {
4903 const VkFormat format = (VkFormat)formatNdx;
4904 VkFormatProperties coreProperties;
4905 VkFormatProperties2 extProperties;
4906
4907 deMemset(&coreProperties, 0xcd, sizeof(VkFormatProperties));
4908 deMemset(&extProperties, 0xcd, sizeof(VkFormatProperties2));
4909
4910 extProperties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
4911 extProperties.pNext = DE_NULL;
4912
4913 vki.getPhysicalDeviceFormatProperties(physicalDevice, format, &coreProperties);
4914 vki.getPhysicalDeviceFormatProperties2(physicalDevice, format, &extProperties);
4915
4916 TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
4917 TCU_CHECK(extProperties.pNext == DE_NULL);
4918
4919 if (deMemCmp(&coreProperties, &extProperties.formatProperties, sizeof(VkFormatProperties)) != 0)
4920 TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceFormatProperties2");
4921
4922 log << TestLog::Message << toString (extProperties) << TestLog::EndMessage;
4923 }
4924
4925 return tcu::TestStatus::pass("Querying device format properties succeeded");
4926 }
4927
deviceQueueFamilyProperties2(Context & context)4928 tcu::TestStatus deviceQueueFamilyProperties2 (Context& context)
4929 {
4930 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4931 const InstanceDriver& vki (instance.getDriver());
4932 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4933 TestLog& log = context.getTestContext().getLog();
4934 deUint32 numCoreQueueFamilies = ~0u;
4935 deUint32 numExtQueueFamilies = ~0u;
4936
4937 vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, DE_NULL);
4938 vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, DE_NULL);
4939
4940 TCU_CHECK_MSG(numCoreQueueFamilies == numExtQueueFamilies, "Different number of queue family properties reported");
4941 TCU_CHECK(numCoreQueueFamilies > 0);
4942
4943 {
4944 std::vector<VkQueueFamilyProperties> coreProperties (numCoreQueueFamilies);
4945 std::vector<VkQueueFamilyProperties2> extProperties (numExtQueueFamilies);
4946
4947 deMemset(&coreProperties[0], 0xcd, sizeof(VkQueueFamilyProperties)*numCoreQueueFamilies);
4948 deMemset(&extProperties[0], 0xcd, sizeof(VkQueueFamilyProperties2)*numExtQueueFamilies);
4949
4950 for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
4951 {
4952 extProperties[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
4953 extProperties[ndx].pNext = DE_NULL;
4954 }
4955
4956 vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, &coreProperties[0]);
4957 vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, &extProperties[0]);
4958
4959 TCU_CHECK((size_t)numCoreQueueFamilies == coreProperties.size());
4960 TCU_CHECK((size_t)numExtQueueFamilies == extProperties.size());
4961 DE_ASSERT(numCoreQueueFamilies == numExtQueueFamilies);
4962
4963 for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
4964 {
4965 TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
4966 TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
4967
4968 if (deMemCmp(&coreProperties[ndx], &extProperties[ndx].queueFamilyProperties, sizeof(VkQueueFamilyProperties)) != 0)
4969 TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceQueueFamilyProperties and vkGetPhysicalDeviceQueueFamilyProperties2");
4970
4971 log << TestLog::Message << " queueFamilyNdx = " << ndx <<TestLog::EndMessage
4972 << TestLog::Message << extProperties[ndx] << TestLog::EndMessage;
4973 }
4974 }
4975
4976 return tcu::TestStatus::pass("Querying device queue family properties succeeded");
4977 }
4978
deviceMemoryProperties2(Context & context)4979 tcu::TestStatus deviceMemoryProperties2 (Context& context)
4980 {
4981 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4982 const InstanceDriver& vki (instance.getDriver());
4983 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4984 TestLog& log = context.getTestContext().getLog();
4985 VkPhysicalDeviceMemoryProperties coreProperties;
4986 VkPhysicalDeviceMemoryProperties2 extProperties;
4987
4988 deMemset(&coreProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties));
4989 deMemset(&extProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties2));
4990
4991 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
4992 extProperties.pNext = DE_NULL;
4993
4994 vki.getPhysicalDeviceMemoryProperties(physicalDevice, &coreProperties);
4995 vki.getPhysicalDeviceMemoryProperties2(physicalDevice, &extProperties);
4996
4997 TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
4998 TCU_CHECK(extProperties.pNext == DE_NULL);
4999
5000 if (coreProperties.memoryTypeCount != extProperties.memoryProperties.memoryTypeCount)
5001 TCU_FAIL("Mismatch between memoryTypeCount reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5002 if (coreProperties.memoryHeapCount != extProperties.memoryProperties.memoryHeapCount)
5003 TCU_FAIL("Mismatch between memoryHeapCount reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5004 for (deUint32 i = 0; i < coreProperties.memoryTypeCount; i++) {
5005 const VkMemoryType *coreType = &coreProperties.memoryTypes[i];
5006 const VkMemoryType *extType = &extProperties.memoryProperties.memoryTypes[i];
5007 if (coreType->propertyFlags != extType->propertyFlags || coreType->heapIndex != extType->heapIndex)
5008 TCU_FAIL("Mismatch between memoryTypes reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5009 }
5010 for (deUint32 i = 0; i < coreProperties.memoryHeapCount; i++) {
5011 const VkMemoryHeap *coreHeap = &coreProperties.memoryHeaps[i];
5012 const VkMemoryHeap *extHeap = &extProperties.memoryProperties.memoryHeaps[i];
5013 if (coreHeap->size != extHeap->size || coreHeap->flags != extHeap->flags)
5014 TCU_FAIL("Mismatch between memoryHeaps reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5015 }
5016
5017 log << TestLog::Message << extProperties << TestLog::EndMessage;
5018
5019 return tcu::TestStatus::pass("Querying device memory properties succeeded");
5020 }
5021
deviceFeaturesVulkan12(Context & context)5022 tcu::TestStatus deviceFeaturesVulkan12 (Context& context)
5023 {
5024 using namespace ValidateQueryBits;
5025
5026 const QueryMemberTableEntry feature11OffsetTable[] =
5027 {
5028 // VkPhysicalDevice16BitStorageFeatures
5029 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storageBuffer16BitAccess),
5030 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, uniformAndStorageBuffer16BitAccess),
5031 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storagePushConstant16),
5032 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storageInputOutput16),
5033
5034 // VkPhysicalDeviceMultiviewFeatures
5035 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiview),
5036 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiviewGeometryShader),
5037 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiviewTessellationShader),
5038
5039 // VkPhysicalDeviceVariablePointersFeatures
5040 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, variablePointersStorageBuffer),
5041 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, variablePointers),
5042
5043 // VkPhysicalDeviceProtectedMemoryFeatures
5044 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, protectedMemory),
5045
5046 // VkPhysicalDeviceSamplerYcbcrConversionFeatures
5047 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, samplerYcbcrConversion),
5048
5049 // VkPhysicalDeviceShaderDrawParametersFeatures
5050 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, shaderDrawParameters),
5051 { 0, 0 }
5052 };
5053 const QueryMemberTableEntry feature12OffsetTable[] =
5054 {
5055 // None
5056 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, samplerMirrorClampToEdge),
5057 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, drawIndirectCount),
5058
5059 // VkPhysicalDevice8BitStorageFeatures
5060 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, storageBuffer8BitAccess),
5061 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, uniformAndStorageBuffer8BitAccess),
5062 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, storagePushConstant8),
5063
5064 // VkPhysicalDeviceShaderAtomicInt64Features
5065 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderBufferInt64Atomics),
5066 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSharedInt64Atomics),
5067
5068 // VkPhysicalDeviceShaderFloat16Int8Features
5069 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderFloat16),
5070 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInt8),
5071
5072 // VkPhysicalDeviceDescriptorIndexingFeatures
5073 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorIndexing),
5074 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInputAttachmentArrayDynamicIndexing),
5075 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformTexelBufferArrayDynamicIndexing),
5076 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageTexelBufferArrayDynamicIndexing),
5077 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformBufferArrayNonUniformIndexing),
5078 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSampledImageArrayNonUniformIndexing),
5079 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageBufferArrayNonUniformIndexing),
5080 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageImageArrayNonUniformIndexing),
5081 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInputAttachmentArrayNonUniformIndexing),
5082 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformTexelBufferArrayNonUniformIndexing),
5083 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageTexelBufferArrayNonUniformIndexing),
5084 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUniformBufferUpdateAfterBind),
5085 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingSampledImageUpdateAfterBind),
5086 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageImageUpdateAfterBind),
5087 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageBufferUpdateAfterBind),
5088 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUniformTexelBufferUpdateAfterBind),
5089 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageTexelBufferUpdateAfterBind),
5090 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUpdateUnusedWhilePending),
5091 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingPartiallyBound),
5092 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingVariableDescriptorCount),
5093 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, runtimeDescriptorArray),
5094
5095 // None
5096 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, samplerFilterMinmax),
5097
5098 // VkPhysicalDeviceScalarBlockLayoutFeatures
5099 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, scalarBlockLayout),
5100
5101 // VkPhysicalDeviceImagelessFramebufferFeatures
5102 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, imagelessFramebuffer),
5103
5104 // VkPhysicalDeviceUniformBufferStandardLayoutFeatures
5105 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, uniformBufferStandardLayout),
5106
5107 // VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
5108 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSubgroupExtendedTypes),
5109
5110 // VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
5111 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, separateDepthStencilLayouts),
5112
5113 // VkPhysicalDeviceHostQueryResetFeatures
5114 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, hostQueryReset),
5115
5116 // VkPhysicalDeviceTimelineSemaphoreFeatures
5117 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, timelineSemaphore),
5118
5119 // VkPhysicalDeviceBufferDeviceAddressFeatures
5120 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddress),
5121 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddressCaptureReplay),
5122 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddressMultiDevice),
5123
5124 // VkPhysicalDeviceVulkanMemoryModelFeatures
5125 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModel),
5126 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModelDeviceScope),
5127 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModelAvailabilityVisibilityChains),
5128
5129 // None
5130 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderOutputViewportIndex),
5131 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderOutputLayer),
5132 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, subgroupBroadcastDynamicId),
5133 { 0, 0 }
5134 };
5135 TestLog& log = context.getTestContext().getLog();
5136 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5137 const InstanceDriver& vki = instance.getDriver();
5138 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5139 const deUint32 vulkan11FeaturesBufferSize = sizeof(VkPhysicalDeviceVulkan11Features) + GUARD_SIZE;
5140 const deUint32 vulkan12FeaturesBufferSize = sizeof(VkPhysicalDeviceVulkan12Features) + GUARD_SIZE;
5141 VkPhysicalDeviceFeatures2 extFeatures;
5142 deUint8 buffer11a[vulkan11FeaturesBufferSize];
5143 deUint8 buffer11b[vulkan11FeaturesBufferSize];
5144 deUint8 buffer12a[vulkan12FeaturesBufferSize];
5145 deUint8 buffer12b[vulkan12FeaturesBufferSize];
5146 const int count = 2u;
5147 VkPhysicalDeviceVulkan11Features* vulkan11Features[count] = { (VkPhysicalDeviceVulkan11Features*)(buffer11a), (VkPhysicalDeviceVulkan11Features*)(buffer11b)};
5148 VkPhysicalDeviceVulkan12Features* vulkan12Features[count] = { (VkPhysicalDeviceVulkan12Features*)(buffer12a), (VkPhysicalDeviceVulkan12Features*)(buffer12b)};
5149
5150 if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5151 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5152
5153 deMemset(buffer11b, GUARD_VALUE, sizeof(buffer11b));
5154 deMemset(buffer12a, GUARD_VALUE, sizeof(buffer12a));
5155 deMemset(buffer12b, GUARD_VALUE, sizeof(buffer12b));
5156 deMemset(buffer11a, GUARD_VALUE, sizeof(buffer11a));
5157
5158 // Validate all fields initialized
5159 for (int ndx = 0; ndx < count; ++ndx)
5160 {
5161 deMemset(&extFeatures.features, 0x00, sizeof(extFeatures.features));
5162 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
5163 extFeatures.pNext = vulkan11Features[ndx];
5164
5165 deMemset(vulkan11Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan11Features));
5166 vulkan11Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
5167 vulkan11Features[ndx]->pNext = vulkan12Features[ndx];
5168
5169 deMemset(vulkan12Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan12Features));
5170 vulkan12Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
5171 vulkan12Features[ndx]->pNext = DE_NULL;
5172
5173 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5174 }
5175
5176 log << TestLog::Message << *vulkan11Features[0] << TestLog::EndMessage;
5177 log << TestLog::Message << *vulkan12Features[0] << TestLog::EndMessage;
5178
5179 if (!validateStructsWithGuard(feature11OffsetTable, vulkan11Features, GUARD_VALUE, GUARD_SIZE))
5180 {
5181 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan11Features initialization failure" << TestLog::EndMessage;
5182
5183 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan11Features initialization failure");
5184 }
5185
5186 if (!validateStructsWithGuard(feature12OffsetTable, vulkan12Features, GUARD_VALUE, GUARD_SIZE))
5187 {
5188 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan12Features initialization failure" << TestLog::EndMessage;
5189
5190 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan12Features initialization failure");
5191 }
5192
5193 return tcu::TestStatus::pass("Querying Vulkan 1.2 device features succeeded");
5194 }
5195
deviceFeaturesVulkan13(Context & context)5196 tcu::TestStatus deviceFeaturesVulkan13 (Context& context)
5197 {
5198 using namespace ValidateQueryBits;
5199
5200 const QueryMemberTableEntry feature13OffsetTable[] =
5201 {
5202 // VkPhysicalDeviceImageRobustnessFeatures
5203 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, robustImageAccess),
5204
5205 // VkPhysicalDeviceInlineUniformBlockFeatures
5206 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, inlineUniformBlock),
5207 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, descriptorBindingInlineUniformBlockUpdateAfterBind),
5208
5209 // VkPhysicalDevicePipelineCreationCacheControlFeatures
5210 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, pipelineCreationCacheControl),
5211
5212 // VkPhysicalDevicePrivateDataFeatures
5213 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, privateData),
5214
5215 // VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures
5216 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderDemoteToHelperInvocation),
5217
5218 // VkPhysicalDeviceShaderTerminateInvocationFeatures
5219 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderTerminateInvocation),
5220
5221 // VkPhysicalDeviceSubgroupSizeControlFeatures
5222 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, subgroupSizeControl),
5223 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, computeFullSubgroups),
5224
5225 // VkPhysicalDeviceSynchronization2Features
5226 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, synchronization2),
5227
5228 // VkPhysicalDeviceTextureCompressionASTCHDRFeatures
5229 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, textureCompressionASTC_HDR),
5230
5231 // VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
5232 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderZeroInitializeWorkgroupMemory),
5233
5234 // VkPhysicalDeviceDynamicRenderingFeatures
5235 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, dynamicRendering),
5236
5237 // VkPhysicalDeviceShaderIntegerDotProductFeatures
5238 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderIntegerDotProduct),
5239
5240 // VkPhysicalDeviceMaintenance4Features
5241 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, maintenance4),
5242 { 0, 0 }
5243 };
5244 TestLog& log = context.getTestContext().getLog();
5245 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
5246 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5247 const InstanceDriver& vki = instance.getDriver();
5248 const deUint32 vulkan13FeaturesBufferSize = sizeof(VkPhysicalDeviceVulkan13Features) + GUARD_SIZE;
5249 VkPhysicalDeviceFeatures2 extFeatures;
5250 deUint8 buffer13a[vulkan13FeaturesBufferSize];
5251 deUint8 buffer13b[vulkan13FeaturesBufferSize];
5252 const int count = 2u;
5253 VkPhysicalDeviceVulkan13Features* vulkan13Features[count] = { (VkPhysicalDeviceVulkan13Features*)(buffer13a), (VkPhysicalDeviceVulkan13Features*)(buffer13b)};
5254
5255 if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5256 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5257
5258 deMemset(buffer13a, GUARD_VALUE, sizeof(buffer13a));
5259 deMemset(buffer13b, GUARD_VALUE, sizeof(buffer13b));
5260
5261 // Validate all fields initialized
5262 for (int ndx = 0; ndx < count; ++ndx)
5263 {
5264 deMemset(&extFeatures.features, 0x00, sizeof(extFeatures.features));
5265 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
5266 extFeatures.pNext = vulkan13Features[ndx];
5267
5268 deMemset(vulkan13Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan13Features));
5269 vulkan13Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
5270 vulkan13Features[ndx]->pNext = DE_NULL;
5271
5272 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5273 }
5274
5275 log << TestLog::Message << *vulkan13Features[0] << TestLog::EndMessage;
5276
5277 if (!validateStructsWithGuard(feature13OffsetTable, vulkan13Features, GUARD_VALUE, GUARD_SIZE))
5278 {
5279 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan13Features initialization failure" << TestLog::EndMessage;
5280
5281 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan13Features initialization failure");
5282 }
5283
5284 return tcu::TestStatus::pass("Querying Vulkan 1.3 device features succeeded");
5285 }
5286
devicePropertiesVulkan12(Context & context)5287 tcu::TestStatus devicePropertiesVulkan12 (Context& context)
5288 {
5289 using namespace ValidateQueryBits;
5290
5291 const QueryMemberTableEntry properties11OffsetTable[] =
5292 {
5293 // VkPhysicalDeviceIDProperties
5294 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceUUID),
5295 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, driverUUID),
5296 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceLUID),
5297 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceNodeMask),
5298 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceLUIDValid),
5299
5300 // VkPhysicalDeviceSubgroupProperties
5301 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSize),
5302 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSupportedStages),
5303 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSupportedOperations),
5304 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupQuadOperationsInAllStages),
5305
5306 // VkPhysicalDevicePointClippingProperties
5307 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, pointClippingBehavior),
5308
5309 // VkPhysicalDeviceMultiviewProperties
5310 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMultiviewViewCount),
5311 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMultiviewInstanceIndex),
5312
5313 // VkPhysicalDeviceProtectedMemoryProperties
5314 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, protectedNoFault),
5315
5316 // VkPhysicalDeviceMaintenance3Properties
5317 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxPerSetDescriptors),
5318 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMemoryAllocationSize),
5319 { 0, 0 }
5320 };
5321 const QueryMemberTableEntry properties12OffsetTable[] =
5322 {
5323 // VkPhysicalDeviceDriverProperties
5324 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, driverID),
5325 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, conformanceVersion),
5326
5327 // VkPhysicalDeviceFloatControlsProperties
5328 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, denormBehaviorIndependence),
5329 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, roundingModeIndependence),
5330 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat16),
5331 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat32),
5332 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat64),
5333 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat16),
5334 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat32),
5335 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat64),
5336 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat16),
5337 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat32),
5338 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat64),
5339 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat16),
5340 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat32),
5341 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat64),
5342 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat16),
5343 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat32),
5344 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat64),
5345
5346 // VkPhysicalDeviceDescriptorIndexingProperties
5347 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxUpdateAfterBindDescriptorsInAllPools),
5348 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderUniformBufferArrayNonUniformIndexingNative),
5349 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSampledImageArrayNonUniformIndexingNative),
5350 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderStorageBufferArrayNonUniformIndexingNative),
5351 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderStorageImageArrayNonUniformIndexingNative),
5352 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderInputAttachmentArrayNonUniformIndexingNative),
5353 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, robustBufferAccessUpdateAfterBind),
5354 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, quadDivergentImplicitLod),
5355 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindSamplers),
5356 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindUniformBuffers),
5357 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindStorageBuffers),
5358 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindSampledImages),
5359 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindStorageImages),
5360 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindInputAttachments),
5361 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageUpdateAfterBindResources),
5362 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindSamplers),
5363 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindUniformBuffers),
5364 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
5365 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageBuffers),
5366 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
5367 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindSampledImages),
5368 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageImages),
5369 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindInputAttachments),
5370
5371 // VkPhysicalDeviceDepthStencilResolveProperties
5372 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, supportedDepthResolveModes),
5373 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, supportedStencilResolveModes),
5374 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, independentResolveNone),
5375 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, independentResolve),
5376
5377 // VkPhysicalDeviceSamplerFilterMinmaxProperties
5378 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, filterMinmaxSingleComponentFormats),
5379 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, filterMinmaxImageComponentMapping),
5380
5381 // VkPhysicalDeviceTimelineSemaphoreProperties
5382 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxTimelineSemaphoreValueDifference),
5383
5384 // None
5385 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, framebufferIntegerColorSampleCounts),
5386 { 0, 0 }
5387 };
5388 TestLog& log = context.getTestContext().getLog();
5389 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5390 const InstanceDriver& vki = instance.getDriver();
5391 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5392 const deUint32 vulkan11PropertiesBufferSize = sizeof(VkPhysicalDeviceVulkan11Properties) + GUARD_SIZE;
5393 const deUint32 vulkan12PropertiesBufferSize = sizeof(VkPhysicalDeviceVulkan12Properties) + GUARD_SIZE;
5394 VkPhysicalDeviceProperties2 extProperties;
5395 deUint8 buffer11a[vulkan11PropertiesBufferSize];
5396 deUint8 buffer11b[vulkan11PropertiesBufferSize];
5397 deUint8 buffer12a[vulkan12PropertiesBufferSize];
5398 deUint8 buffer12b[vulkan12PropertiesBufferSize];
5399 const int count = 2u;
5400 VkPhysicalDeviceVulkan11Properties* vulkan11Properties[count] = { (VkPhysicalDeviceVulkan11Properties*)(buffer11a), (VkPhysicalDeviceVulkan11Properties*)(buffer11b)};
5401 VkPhysicalDeviceVulkan12Properties* vulkan12Properties[count] = { (VkPhysicalDeviceVulkan12Properties*)(buffer12a), (VkPhysicalDeviceVulkan12Properties*)(buffer12b)};
5402
5403 if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5404 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5405
5406 deMemset(buffer11a, GUARD_VALUE, sizeof(buffer11a));
5407 deMemset(buffer11b, GUARD_VALUE, sizeof(buffer11b));
5408 deMemset(buffer12a, GUARD_VALUE, sizeof(buffer12a));
5409 deMemset(buffer12b, GUARD_VALUE, sizeof(buffer12b));
5410
5411 for (int ndx = 0; ndx < count; ++ndx)
5412 {
5413 deMemset(&extProperties.properties, 0x00, sizeof(extProperties.properties));
5414 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
5415 extProperties.pNext = vulkan11Properties[ndx];
5416
5417 deMemset(vulkan11Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan11Properties));
5418 vulkan11Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
5419 vulkan11Properties[ndx]->pNext = vulkan12Properties[ndx];
5420
5421 deMemset(vulkan12Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan12Properties));
5422 vulkan12Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
5423 vulkan12Properties[ndx]->pNext = DE_NULL;
5424
5425 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5426 }
5427
5428 log << TestLog::Message << *vulkan11Properties[0] << TestLog::EndMessage;
5429 log << TestLog::Message << *vulkan12Properties[0] << TestLog::EndMessage;
5430
5431 if (!validateStructsWithGuard(properties11OffsetTable, vulkan11Properties, GUARD_VALUE, GUARD_SIZE))
5432 {
5433 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan11Properties initialization failure" << TestLog::EndMessage;
5434
5435 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan11Properties initialization failure");
5436 }
5437
5438 if (!validateStructsWithGuard(properties12OffsetTable, vulkan12Properties, GUARD_VALUE, GUARD_SIZE) ||
5439 strncmp(vulkan12Properties[0]->driverName, vulkan12Properties[1]->driverName, VK_MAX_DRIVER_NAME_SIZE) != 0 ||
5440 strncmp(vulkan12Properties[0]->driverInfo, vulkan12Properties[1]->driverInfo, VK_MAX_DRIVER_INFO_SIZE) != 0 )
5441 {
5442 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan12Properties initialization failure" << TestLog::EndMessage;
5443
5444 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan12Properties initialization failure");
5445 }
5446
5447 return tcu::TestStatus::pass("Querying Vulkan 1.2 device properties succeeded");
5448 }
5449
devicePropertiesVulkan13(Context & context)5450 tcu::TestStatus devicePropertiesVulkan13 (Context& context)
5451 {
5452 using namespace ValidateQueryBits;
5453
5454 const QueryMemberTableEntry properties13OffsetTable[] =
5455 {
5456 // VkPhysicalDeviceSubgroupSizeControlProperties
5457 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, minSubgroupSize),
5458 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxSubgroupSize),
5459 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxComputeWorkgroupSubgroups),
5460 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, requiredSubgroupSizeStages),
5461
5462 // VkPhysicalDeviceInlineUniformBlockProperties
5463 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxInlineUniformBlockSize),
5464 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxPerStageDescriptorInlineUniformBlocks),
5465 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
5466 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxDescriptorSetInlineUniformBlocks),
5467 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxDescriptorSetUpdateAfterBindInlineUniformBlocks),
5468
5469 // None
5470 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxInlineUniformTotalSize),
5471
5472 // VkPhysicalDeviceShaderIntegerDotProductProperties
5473 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitUnsignedAccelerated),
5474 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitSignedAccelerated),
5475 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitMixedSignednessAccelerated),
5476 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedUnsignedAccelerated),
5477 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedSignedAccelerated),
5478 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedMixedSignednessAccelerated),
5479 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitUnsignedAccelerated),
5480 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitSignedAccelerated),
5481 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitMixedSignednessAccelerated),
5482 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitUnsignedAccelerated),
5483 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitSignedAccelerated),
5484 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitMixedSignednessAccelerated),
5485 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitUnsignedAccelerated),
5486 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitSignedAccelerated),
5487 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitMixedSignednessAccelerated),
5488 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),
5489 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitSignedAccelerated),
5490 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),
5491 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),
5492 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),
5493 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),
5494 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),
5495 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitSignedAccelerated),
5496 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),
5497 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),
5498 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitSignedAccelerated),
5499 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),
5500 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),
5501 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitSignedAccelerated),
5502 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated),
5503
5504 // VkPhysicalDeviceTexelBufferAlignmentProperties
5505 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, storageTexelBufferOffsetAlignmentBytes),
5506 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, storageTexelBufferOffsetSingleTexelAlignment),
5507 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, uniformTexelBufferOffsetAlignmentBytes),
5508 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, uniformTexelBufferOffsetSingleTexelAlignment),
5509
5510 // VkPhysicalDeviceMaintenance4Properties
5511 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxBufferSize),
5512 { 0, 0 }
5513 };
5514
5515 TestLog& log = context.getTestContext().getLog();
5516 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
5517 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5518 const InstanceDriver& vki = instance.getDriver();
5519 const deUint32 vulkan13PropertiesBufferSize = sizeof(VkPhysicalDeviceVulkan13Properties) + GUARD_SIZE;
5520 VkPhysicalDeviceProperties2 extProperties;
5521 deUint8 buffer13a[vulkan13PropertiesBufferSize];
5522 deUint8 buffer13b[vulkan13PropertiesBufferSize];
5523 const int count = 2u;
5524 VkPhysicalDeviceVulkan13Properties* vulkan13Properties[count] = { (VkPhysicalDeviceVulkan13Properties*)(buffer13a), (VkPhysicalDeviceVulkan13Properties*)(buffer13b)};
5525
5526 if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5527 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5528
5529 deMemset(buffer13a, GUARD_VALUE, sizeof(buffer13a));
5530 deMemset(buffer13b, GUARD_VALUE, sizeof(buffer13b));
5531
5532 for (int ndx = 0; ndx < count; ++ndx)
5533 {
5534 deMemset(&extProperties.properties, 0x00, sizeof(extProperties.properties));
5535 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
5536 extProperties.pNext = vulkan13Properties[ndx];
5537
5538 deMemset(vulkan13Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan13Properties));
5539 vulkan13Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
5540 vulkan13Properties[ndx]->pNext = DE_NULL;
5541
5542 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5543 }
5544
5545 log << TestLog::Message << *vulkan13Properties[0] << TestLog::EndMessage;
5546
5547 if (!validateStructsWithGuard(properties13OffsetTable, vulkan13Properties, GUARD_VALUE, GUARD_SIZE))
5548 {
5549 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan13Properties initialization failure" << TestLog::EndMessage;
5550
5551 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan13Properties initialization failure");
5552 }
5553
5554 return tcu::TestStatus::pass("Querying Vulkan 1.3 device properties succeeded");
5555 }
5556
deviceFeatureExtensionsConsistencyVulkan12(Context & context)5557 tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan12(Context& context)
5558 {
5559 TestLog& log = context.getTestContext().getLog();
5560 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5561 const InstanceDriver& vki = instance.getDriver();
5562 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5563
5564 if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5565 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5566
5567 VkPhysicalDeviceVulkan12Features vulkan12Features = initVulkanStructure();
5568 VkPhysicalDeviceVulkan11Features vulkan11Features = initVulkanStructure(&vulkan12Features);
5569 VkPhysicalDeviceFeatures2 extFeatures = initVulkanStructure(&vulkan11Features);
5570
5571 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5572
5573 log << TestLog::Message << vulkan11Features << TestLog::EndMessage;
5574 log << TestLog::Message << vulkan12Features << TestLog::EndMessage;
5575
5576 // Validate if proper VkPhysicalDeviceVulkanXXFeatures fields are set when corresponding extensions are present
5577 std::pair<std::pair<const char*,const char*>, VkBool32> extensions2validate[] =
5578 {
5579 { { "VK_KHR_sampler_mirror_clamp_to_edge", "VkPhysicalDeviceVulkan12Features.samplerMirrorClampToEdge" }, vulkan12Features.samplerMirrorClampToEdge },
5580 { { "VK_KHR_draw_indirect_count", "VkPhysicalDeviceVulkan12Features.drawIndirectCount" }, vulkan12Features.drawIndirectCount },
5581 { { "VK_EXT_descriptor_indexing", "VkPhysicalDeviceVulkan12Features.descriptorIndexing" }, vulkan12Features.descriptorIndexing },
5582 { { "VK_EXT_sampler_filter_minmax", "VkPhysicalDeviceVulkan12Features.samplerFilterMinmax" }, vulkan12Features.samplerFilterMinmax },
5583 { { "VK_EXT_shader_viewport_index_layer", "VkPhysicalDeviceVulkan12Features.shaderOutputViewportIndex" }, vulkan12Features.shaderOutputViewportIndex },
5584 { { "VK_EXT_shader_viewport_index_layer", "VkPhysicalDeviceVulkan12Features.shaderOutputLayer" }, vulkan12Features.shaderOutputLayer }
5585 };
5586 vector<VkExtensionProperties> extensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
5587 for (const auto& ext : extensions2validate)
5588 if (checkExtension(extensionProperties, ext.first.first) && !ext.second)
5589 TCU_FAIL(string("Mismatch between extension ") + ext.first.first + " and " + ext.first.second);
5590
5591 // collect all extension features
5592 {
5593 VkPhysicalDevice16BitStorageFeatures device16BitStorageFeatures = initVulkanStructure();
5594 VkPhysicalDeviceMultiviewFeatures deviceMultiviewFeatures = initVulkanStructure(&device16BitStorageFeatures);
5595 VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeatures = initVulkanStructure(&deviceMultiviewFeatures);
5596 VkPhysicalDeviceSamplerYcbcrConversionFeatures samplerYcbcrConversionFeatures = initVulkanStructure(&protectedMemoryFeatures);
5597 VkPhysicalDeviceShaderDrawParametersFeatures shaderDrawParametersFeatures = initVulkanStructure(&samplerYcbcrConversionFeatures);
5598 VkPhysicalDeviceVariablePointersFeatures variablePointerFeatures = initVulkanStructure(&shaderDrawParametersFeatures);
5599 VkPhysicalDevice8BitStorageFeatures device8BitStorageFeatures = initVulkanStructure(&variablePointerFeatures);
5600 VkPhysicalDeviceShaderAtomicInt64Features shaderAtomicInt64Features = initVulkanStructure(&device8BitStorageFeatures);
5601 VkPhysicalDeviceShaderFloat16Int8Features shaderFloat16Int8Features = initVulkanStructure(&shaderAtomicInt64Features);
5602 VkPhysicalDeviceDescriptorIndexingFeatures descriptorIndexingFeatures = initVulkanStructure(&shaderFloat16Int8Features);
5603 VkPhysicalDeviceScalarBlockLayoutFeatures scalarBlockLayoutFeatures = initVulkanStructure(&descriptorIndexingFeatures);
5604 VkPhysicalDeviceImagelessFramebufferFeatures imagelessFramebufferFeatures = initVulkanStructure(&scalarBlockLayoutFeatures);
5605 VkPhysicalDeviceUniformBufferStandardLayoutFeatures uniformBufferStandardLayoutFeatures = initVulkanStructure(&imagelessFramebufferFeatures);
5606 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures shaderSubgroupExtendedTypesFeatures = initVulkanStructure(&uniformBufferStandardLayoutFeatures);
5607 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures separateDepthStencilLayoutsFeatures = initVulkanStructure(&shaderSubgroupExtendedTypesFeatures);
5608 VkPhysicalDeviceHostQueryResetFeatures hostQueryResetFeatures = initVulkanStructure(&separateDepthStencilLayoutsFeatures);
5609 VkPhysicalDeviceTimelineSemaphoreFeatures timelineSemaphoreFeatures = initVulkanStructure(&hostQueryResetFeatures);
5610 VkPhysicalDeviceBufferDeviceAddressFeatures bufferDeviceAddressFeatures = initVulkanStructure(&timelineSemaphoreFeatures);
5611 VkPhysicalDeviceVulkanMemoryModelFeatures vulkanMemoryModelFeatures = initVulkanStructure(&bufferDeviceAddressFeatures);
5612 extFeatures = initVulkanStructure(&vulkanMemoryModelFeatures);
5613
5614 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5615
5616 log << TestLog::Message << extFeatures << TestLog::EndMessage;
5617 log << TestLog::Message << device16BitStorageFeatures << TestLog::EndMessage;
5618 log << TestLog::Message << deviceMultiviewFeatures << TestLog::EndMessage;
5619 log << TestLog::Message << protectedMemoryFeatures << TestLog::EndMessage;
5620 log << TestLog::Message << samplerYcbcrConversionFeatures << TestLog::EndMessage;
5621 log << TestLog::Message << shaderDrawParametersFeatures << TestLog::EndMessage;
5622 log << TestLog::Message << variablePointerFeatures << TestLog::EndMessage;
5623 log << TestLog::Message << device8BitStorageFeatures << TestLog::EndMessage;
5624 log << TestLog::Message << shaderAtomicInt64Features << TestLog::EndMessage;
5625 log << TestLog::Message << shaderFloat16Int8Features << TestLog::EndMessage;
5626 log << TestLog::Message << descriptorIndexingFeatures << TestLog::EndMessage;
5627 log << TestLog::Message << scalarBlockLayoutFeatures << TestLog::EndMessage;
5628 log << TestLog::Message << imagelessFramebufferFeatures << TestLog::EndMessage;
5629 log << TestLog::Message << uniformBufferStandardLayoutFeatures << TestLog::EndMessage;
5630 log << TestLog::Message << shaderSubgroupExtendedTypesFeatures << TestLog::EndMessage;
5631 log << TestLog::Message << separateDepthStencilLayoutsFeatures << TestLog::EndMessage;
5632 log << TestLog::Message << hostQueryResetFeatures << TestLog::EndMessage;
5633 log << TestLog::Message << timelineSemaphoreFeatures << TestLog::EndMessage;
5634 log << TestLog::Message << bufferDeviceAddressFeatures << TestLog::EndMessage;
5635 log << TestLog::Message << vulkanMemoryModelFeatures << TestLog::EndMessage;
5636
5637 if (( device16BitStorageFeatures.storageBuffer16BitAccess != vulkan11Features.storageBuffer16BitAccess ||
5638 device16BitStorageFeatures.uniformAndStorageBuffer16BitAccess != vulkan11Features.uniformAndStorageBuffer16BitAccess ||
5639 device16BitStorageFeatures.storagePushConstant16 != vulkan11Features.storagePushConstant16 ||
5640 device16BitStorageFeatures.storageInputOutput16 != vulkan11Features.storageInputOutput16 ))
5641 {
5642 TCU_FAIL("Mismatch between VkPhysicalDevice16BitStorageFeatures and VkPhysicalDeviceVulkan11Features");
5643 }
5644
5645 if (( deviceMultiviewFeatures.multiview != vulkan11Features.multiview ||
5646 deviceMultiviewFeatures.multiviewGeometryShader != vulkan11Features.multiviewGeometryShader ||
5647 deviceMultiviewFeatures.multiviewTessellationShader != vulkan11Features.multiviewTessellationShader ))
5648 {
5649 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewFeatures and VkPhysicalDeviceVulkan11Features");
5650 }
5651
5652 if ( (protectedMemoryFeatures.protectedMemory != vulkan11Features.protectedMemory ))
5653 {
5654 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryFeatures and VkPhysicalDeviceVulkan11Features");
5655 }
5656
5657 if ( (samplerYcbcrConversionFeatures.samplerYcbcrConversion != vulkan11Features.samplerYcbcrConversion ))
5658 {
5659 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerYcbcrConversionFeatures and VkPhysicalDeviceVulkan11Features");
5660 }
5661
5662 if ( (shaderDrawParametersFeatures.shaderDrawParameters != vulkan11Features.shaderDrawParameters ))
5663 {
5664 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDrawParametersFeatures and VkPhysicalDeviceVulkan11Features");
5665 }
5666
5667 if (( variablePointerFeatures.variablePointersStorageBuffer != vulkan11Features.variablePointersStorageBuffer ||
5668 variablePointerFeatures.variablePointers != vulkan11Features.variablePointers))
5669 {
5670 TCU_FAIL("Mismatch between VkPhysicalDeviceVariablePointersFeatures and VkPhysicalDeviceVulkan11Features");
5671 }
5672
5673 if (( device8BitStorageFeatures.storageBuffer8BitAccess != vulkan12Features.storageBuffer8BitAccess ||
5674 device8BitStorageFeatures.uniformAndStorageBuffer8BitAccess != vulkan12Features.uniformAndStorageBuffer8BitAccess ||
5675 device8BitStorageFeatures.storagePushConstant8 != vulkan12Features.storagePushConstant8 ))
5676 {
5677 TCU_FAIL("Mismatch between VkPhysicalDevice8BitStorageFeatures and VkPhysicalDeviceVulkan12Features");
5678 }
5679
5680 if (( shaderAtomicInt64Features.shaderBufferInt64Atomics != vulkan12Features.shaderBufferInt64Atomics ||
5681 shaderAtomicInt64Features.shaderSharedInt64Atomics != vulkan12Features.shaderSharedInt64Atomics ))
5682 {
5683 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicInt64Features and VkPhysicalDeviceVulkan12Features");
5684 }
5685
5686 if (( shaderFloat16Int8Features.shaderFloat16 != vulkan12Features.shaderFloat16 ||
5687 shaderFloat16Int8Features.shaderInt8 != vulkan12Features.shaderInt8 ))
5688 {
5689 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderFloat16Int8Features and VkPhysicalDeviceVulkan12Features");
5690 }
5691
5692 if ((vulkan12Features.descriptorIndexing) &&
5693 ( descriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing != vulkan12Features.shaderInputAttachmentArrayDynamicIndexing ||
5694 descriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing != vulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ||
5695 descriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing != vulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ||
5696 descriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing != vulkan12Features.shaderUniformBufferArrayNonUniformIndexing ||
5697 descriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing != vulkan12Features.shaderSampledImageArrayNonUniformIndexing ||
5698 descriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing != vulkan12Features.shaderStorageBufferArrayNonUniformIndexing ||
5699 descriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing != vulkan12Features.shaderStorageImageArrayNonUniformIndexing ||
5700 descriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing != vulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ||
5701 descriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing != vulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ||
5702 descriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing != vulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ||
5703 descriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind != vulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ||
5704 descriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind != vulkan12Features.descriptorBindingSampledImageUpdateAfterBind ||
5705 descriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind != vulkan12Features.descriptorBindingStorageImageUpdateAfterBind ||
5706 descriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind != vulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ||
5707 descriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind != vulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ||
5708 descriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind != vulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ||
5709 descriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending != vulkan12Features.descriptorBindingUpdateUnusedWhilePending ||
5710 descriptorIndexingFeatures.descriptorBindingPartiallyBound != vulkan12Features.descriptorBindingPartiallyBound ||
5711 descriptorIndexingFeatures.descriptorBindingVariableDescriptorCount != vulkan12Features.descriptorBindingVariableDescriptorCount ||
5712 descriptorIndexingFeatures.runtimeDescriptorArray != vulkan12Features.runtimeDescriptorArray ))
5713 {
5714 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingFeatures and VkPhysicalDeviceVulkan12Features");
5715 }
5716
5717 if (( scalarBlockLayoutFeatures.scalarBlockLayout != vulkan12Features.scalarBlockLayout ))
5718 {
5719 TCU_FAIL("Mismatch between VkPhysicalDeviceScalarBlockLayoutFeatures and VkPhysicalDeviceVulkan12Features");
5720 }
5721
5722 if (( imagelessFramebufferFeatures.imagelessFramebuffer != vulkan12Features.imagelessFramebuffer ))
5723 {
5724 TCU_FAIL("Mismatch between VkPhysicalDeviceImagelessFramebufferFeatures and VkPhysicalDeviceVulkan12Features");
5725 }
5726
5727 if (( uniformBufferStandardLayoutFeatures.uniformBufferStandardLayout != vulkan12Features.uniformBufferStandardLayout ))
5728 {
5729 TCU_FAIL("Mismatch between VkPhysicalDeviceUniformBufferStandardLayoutFeatures and VkPhysicalDeviceVulkan12Features");
5730 }
5731
5732 if (( shaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes != vulkan12Features.shaderSubgroupExtendedTypes ))
5733 {
5734 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures and VkPhysicalDeviceVulkan12Features");
5735 }
5736
5737 if (( separateDepthStencilLayoutsFeatures.separateDepthStencilLayouts != vulkan12Features.separateDepthStencilLayouts ))
5738 {
5739 TCU_FAIL("Mismatch between VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures and VkPhysicalDeviceVulkan12Features");
5740 }
5741
5742 if (( hostQueryResetFeatures.hostQueryReset != vulkan12Features.hostQueryReset ))
5743 {
5744 TCU_FAIL("Mismatch between VkPhysicalDeviceHostQueryResetFeatures and VkPhysicalDeviceVulkan12Features");
5745 }
5746
5747 if (( timelineSemaphoreFeatures.timelineSemaphore != vulkan12Features.timelineSemaphore ))
5748 {
5749 TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreFeatures and VkPhysicalDeviceVulkan12Features");
5750 }
5751
5752 if (( bufferDeviceAddressFeatures.bufferDeviceAddress != vulkan12Features.bufferDeviceAddress ||
5753 bufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay != vulkan12Features.bufferDeviceAddressCaptureReplay ||
5754 bufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice != vulkan12Features.bufferDeviceAddressMultiDevice ))
5755 {
5756 TCU_FAIL("Mismatch between VkPhysicalDeviceBufferDeviceAddressFeatures and VkPhysicalDeviceVulkan12Features");
5757 }
5758
5759 if (( vulkanMemoryModelFeatures.vulkanMemoryModel != vulkan12Features.vulkanMemoryModel ||
5760 vulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope != vulkan12Features.vulkanMemoryModelDeviceScope ||
5761 vulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains != vulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ))
5762 {
5763 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkanMemoryModelFeatures and VkPhysicalDeviceVulkan12Features");
5764 }
5765 }
5766
5767 return tcu::TestStatus::pass("Vulkan 1.2 device features are consistent with extensions");
5768 }
5769
deviceFeatureExtensionsConsistencyVulkan13(Context & context)5770 tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan13(Context& context)
5771 {
5772 TestLog& log = context.getTestContext().getLog();
5773 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
5774 const CustomInstance instance = createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2");
5775 const InstanceDriver& vki = instance.getDriver();
5776
5777 if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5778 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5779
5780 VkPhysicalDeviceVulkan13Features vulkan13Features = initVulkanStructure();
5781 VkPhysicalDeviceFeatures2 extFeatures = initVulkanStructure(&vulkan13Features);
5782
5783 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5784
5785 log << TestLog::Message << vulkan13Features << TestLog::EndMessage;
5786
5787 // Validate if required VkPhysicalDeviceVulkan13Features fields are set
5788 std::pair<const char*, VkBool32> features2validate[]
5789 {
5790 { { "VkPhysicalDeviceVulkan13Features.robustImageAccess" }, vulkan13Features.robustImageAccess },
5791 { { "VkPhysicalDeviceVulkan13Features.inlineUniformBlock" }, vulkan13Features.inlineUniformBlock },
5792 { { "VkPhysicalDeviceVulkan13Features.pipelineCreationCacheControl" }, vulkan13Features.pipelineCreationCacheControl },
5793 { { "VkPhysicalDeviceVulkan13Features.privateData" }, vulkan13Features.privateData },
5794 { { "VkPhysicalDeviceVulkan13Features.shaderDemoteToHelperInvocation" }, vulkan13Features.shaderDemoteToHelperInvocation },
5795 { { "VkPhysicalDeviceVulkan13Features.shaderTerminateInvocation" }, vulkan13Features.shaderTerminateInvocation },
5796 { { "VkPhysicalDeviceVulkan13Features.subgroupSizeControl" }, vulkan13Features.subgroupSizeControl },
5797 { { "VkPhysicalDeviceVulkan13Features.computeFullSubgroups" }, vulkan13Features.computeFullSubgroups },
5798 { { "VkPhysicalDeviceVulkan13Features.synchronization2" }, vulkan13Features.synchronization2 },
5799 { { "VkPhysicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory" }, vulkan13Features.shaderZeroInitializeWorkgroupMemory },
5800 { { "VkPhysicalDeviceVulkan13Features.dynamicRendering" }, vulkan13Features.dynamicRendering },
5801 { { "VkPhysicalDeviceVulkan13Features.shaderIntegerDotProduct" }, vulkan13Features.shaderIntegerDotProduct },
5802 { { "VkPhysicalDeviceVulkan13Features.maintenance4" }, vulkan13Features.maintenance4 },
5803 };
5804 for (const auto& feature : features2validate)
5805 {
5806 if (!feature.second)
5807 TCU_FAIL(string("Required feature ") + feature.first + " is not set");
5808 }
5809
5810 // collect all extension features
5811 {
5812 VkPhysicalDeviceImageRobustnessFeatures imageRobustnessFeatures = initVulkanStructure();
5813 VkPhysicalDeviceInlineUniformBlockFeatures inlineUniformBlockFeatures = initVulkanStructure(&imageRobustnessFeatures);
5814 VkPhysicalDevicePipelineCreationCacheControlFeatures pipelineCreationCacheControlFeatures = initVulkanStructure(&inlineUniformBlockFeatures);
5815 VkPhysicalDevicePrivateDataFeatures privateDataFeatures = initVulkanStructure(&pipelineCreationCacheControlFeatures);
5816 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures shaderDemoteToHelperInvocationFeatures = initVulkanStructure(&privateDataFeatures);
5817 VkPhysicalDeviceShaderTerminateInvocationFeatures shaderTerminateInvocationFeatures = initVulkanStructure(&shaderDemoteToHelperInvocationFeatures);
5818 VkPhysicalDeviceSubgroupSizeControlFeatures subgroupSizeControlFeatures = initVulkanStructure(&shaderTerminateInvocationFeatures);
5819 VkPhysicalDeviceSynchronization2Features synchronization2Features = initVulkanStructure(&subgroupSizeControlFeatures);
5820 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures zeroInitializeWorkgroupMemoryFeatures = initVulkanStructure(&synchronization2Features);
5821 VkPhysicalDeviceDynamicRenderingFeatures dynamicRenderingFeatures = initVulkanStructure(&zeroInitializeWorkgroupMemoryFeatures);
5822 VkPhysicalDeviceShaderIntegerDotProductFeatures shaderIntegerDotProductFeatures = initVulkanStructure(&dynamicRenderingFeatures);
5823 VkPhysicalDeviceMaintenance4Features maintenance4Features = initVulkanStructure(&shaderIntegerDotProductFeatures);
5824
5825 // those two structures are part of extensions promoted in vk1.2 but now in 1.3 have required features
5826 VkPhysicalDeviceVulkanMemoryModelFeatures vulkanMemoryModelFeatures = initVulkanStructure(&maintenance4Features);
5827 VkPhysicalDeviceBufferDeviceAddressFeatures bufferDeviceAddressFeatures = initVulkanStructure(&vulkanMemoryModelFeatures);
5828
5829 extFeatures = initVulkanStructure(&bufferDeviceAddressFeatures);
5830
5831 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5832
5833 log << TestLog::Message << extFeatures << TestLog::EndMessage;
5834 log << TestLog::Message << imageRobustnessFeatures << TestLog::EndMessage;
5835 log << TestLog::Message << inlineUniformBlockFeatures << TestLog::EndMessage;
5836 log << TestLog::Message << pipelineCreationCacheControlFeatures << TestLog::EndMessage;
5837 log << TestLog::Message << privateDataFeatures << TestLog::EndMessage;
5838 log << TestLog::Message << shaderDemoteToHelperInvocationFeatures << TestLog::EndMessage;
5839 log << TestLog::Message << shaderTerminateInvocationFeatures << TestLog::EndMessage;
5840 log << TestLog::Message << subgroupSizeControlFeatures << TestLog::EndMessage;
5841 log << TestLog::Message << synchronization2Features << TestLog::EndMessage;
5842 log << TestLog::Message << zeroInitializeWorkgroupMemoryFeatures << TestLog::EndMessage;
5843 log << TestLog::Message << dynamicRenderingFeatures << TestLog::EndMessage;
5844 log << TestLog::Message << shaderIntegerDotProductFeatures << TestLog::EndMessage;
5845 log << TestLog::Message << maintenance4Features << TestLog::EndMessage;
5846
5847 if (imageRobustnessFeatures.robustImageAccess != vulkan13Features.robustImageAccess)
5848 TCU_FAIL("Mismatch between VkPhysicalDeviceImageRobustnessFeatures and VkPhysicalDeviceVulkan13Features");
5849
5850 if ((inlineUniformBlockFeatures.inlineUniformBlock != vulkan13Features.inlineUniformBlock) ||
5851 (inlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind != vulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind))
5852 {
5853 TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockFeatures and VkPhysicalDeviceVulkan13Features");
5854 }
5855
5856 if (pipelineCreationCacheControlFeatures.pipelineCreationCacheControl != vulkan13Features.pipelineCreationCacheControl)
5857 TCU_FAIL("Mismatch between VkPhysicalDevicePipelineCreationCacheControlFeatures and VkPhysicalDeviceVulkan13Features");
5858
5859 if (privateDataFeatures.privateData != vulkan13Features.privateData)
5860 TCU_FAIL("Mismatch between VkPhysicalDevicePrivateDataFeatures and VkPhysicalDeviceVulkan13Features");
5861
5862 if (shaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation != vulkan13Features.shaderDemoteToHelperInvocation)
5863 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures and VkPhysicalDeviceVulkan13Features");
5864
5865 if (shaderTerminateInvocationFeatures.shaderTerminateInvocation != vulkan13Features.shaderTerminateInvocation)
5866 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderTerminateInvocationFeatures and VkPhysicalDeviceVulkan13Features");
5867
5868 if ((subgroupSizeControlFeatures.subgroupSizeControl != vulkan13Features.subgroupSizeControl) ||
5869 (subgroupSizeControlFeatures.computeFullSubgroups != vulkan13Features.computeFullSubgroups))
5870 {
5871 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlFeatures and VkPhysicalDeviceVulkan13Features");
5872 }
5873
5874 if (synchronization2Features.synchronization2 != vulkan13Features.synchronization2)
5875 TCU_FAIL("Mismatch between VkPhysicalDeviceSynchronization2Features and VkPhysicalDeviceVulkan13Features");
5876
5877 if (zeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory != vulkan13Features.shaderZeroInitializeWorkgroupMemory)
5878 TCU_FAIL("Mismatch between VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures and VkPhysicalDeviceVulkan13Features");
5879
5880 if (dynamicRenderingFeatures.dynamicRendering != vulkan13Features.dynamicRendering)
5881 TCU_FAIL("Mismatch between VkPhysicalDeviceDynamicRenderingFeatures and VkPhysicalDeviceVulkan13Features");
5882
5883 if (shaderIntegerDotProductFeatures.shaderIntegerDotProduct != vulkan13Features.shaderIntegerDotProduct)
5884 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductFeatures and VkPhysicalDeviceVulkan13Features");
5885
5886 if (maintenance4Features.maintenance4 != vulkan13Features.maintenance4)
5887 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Features and VkPhysicalDeviceVulkan13Features");
5888
5889 // check required features from extensions that were promoted in earlier vulkan version
5890 if (!vulkanMemoryModelFeatures.vulkanMemoryModel)
5891 TCU_FAIL("vulkanMemoryModel feature from VkPhysicalDeviceVulkanMemoryModelFeatures is required");
5892 if (!vulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope)
5893 TCU_FAIL("vulkanMemoryModelDeviceScope feature from VkPhysicalDeviceVulkanMemoryModelFeatures is required");
5894 if (!bufferDeviceAddressFeatures.bufferDeviceAddress)
5895 TCU_FAIL("bufferDeviceAddress feature from VkPhysicalDeviceBufferDeviceAddressFeatures is required");
5896 }
5897
5898 return tcu::TestStatus::pass("Vulkan 1.3 device features are consistent with extensions");
5899 }
5900
devicePropertyExtensionsConsistencyVulkan12(Context & context)5901 tcu::TestStatus devicePropertyExtensionsConsistencyVulkan12(Context& context)
5902 {
5903 TestLog& log = context.getTestContext().getLog();
5904 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5905 const InstanceDriver& vki = instance.getDriver();
5906 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5907
5908 if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5909 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5910
5911 VkPhysicalDeviceVulkan12Properties vulkan12Properties = initVulkanStructure();
5912 VkPhysicalDeviceVulkan11Properties vulkan11Properties = initVulkanStructure(&vulkan12Properties);
5913 VkPhysicalDeviceProperties2 extProperties = initVulkanStructure(&vulkan11Properties);
5914
5915 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5916
5917 log << TestLog::Message << vulkan11Properties << TestLog::EndMessage;
5918 log << TestLog::Message << vulkan12Properties << TestLog::EndMessage;
5919
5920 // Validate all fields initialized matching to extension structures
5921 {
5922 VkPhysicalDeviceIDProperties idProperties = initVulkanStructure();
5923 VkPhysicalDeviceSubgroupProperties subgroupProperties = initVulkanStructure(&idProperties);
5924 VkPhysicalDevicePointClippingProperties pointClippingProperties = initVulkanStructure(&subgroupProperties);
5925 VkPhysicalDeviceMultiviewProperties multiviewProperties = initVulkanStructure(&pointClippingProperties);
5926 VkPhysicalDeviceProtectedMemoryProperties protectedMemoryPropertiesKHR = initVulkanStructure(&multiviewProperties);
5927 VkPhysicalDeviceMaintenance3Properties maintenance3Properties = initVulkanStructure(&protectedMemoryPropertiesKHR);
5928 VkPhysicalDeviceDriverProperties driverProperties = initVulkanStructure(&maintenance3Properties);
5929 VkPhysicalDeviceFloatControlsProperties floatControlsProperties = initVulkanStructure(&driverProperties);
5930 VkPhysicalDeviceDescriptorIndexingProperties descriptorIndexingProperties = initVulkanStructure(&floatControlsProperties);
5931 VkPhysicalDeviceDepthStencilResolveProperties depthStencilResolveProperties = initVulkanStructure(&descriptorIndexingProperties);
5932 VkPhysicalDeviceSamplerFilterMinmaxProperties samplerFilterMinmaxProperties = initVulkanStructure(&depthStencilResolveProperties);
5933 VkPhysicalDeviceTimelineSemaphoreProperties timelineSemaphoreProperties = initVulkanStructure(&samplerFilterMinmaxProperties);
5934 extProperties = initVulkanStructure(&timelineSemaphoreProperties);
5935
5936 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5937
5938 if ((deMemCmp(idProperties.deviceUUID, vulkan11Properties.deviceUUID, VK_UUID_SIZE) != 0) ||
5939 (deMemCmp(idProperties.driverUUID, vulkan11Properties.driverUUID, VK_UUID_SIZE) != 0) ||
5940 (idProperties.deviceLUIDValid != vulkan11Properties.deviceLUIDValid))
5941 {
5942 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties and VkPhysicalDeviceVulkan11Properties");
5943 }
5944 else if (idProperties.deviceLUIDValid)
5945 {
5946 // If deviceLUIDValid is VK_FALSE, the contents of deviceLUID and deviceNodeMask are undefined
5947 // so thay can only be compared when deviceLUIDValid is VK_TRUE.
5948 if ((deMemCmp(idProperties.deviceLUID, vulkan11Properties.deviceLUID, VK_LUID_SIZE) != 0) ||
5949 (idProperties.deviceNodeMask != vulkan11Properties.deviceNodeMask))
5950 {
5951 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties and VkPhysicalDeviceVulkan11Properties");
5952 }
5953 }
5954
5955 if ((subgroupProperties.subgroupSize != vulkan11Properties.subgroupSize ||
5956 subgroupProperties.supportedStages != vulkan11Properties.subgroupSupportedStages ||
5957 subgroupProperties.supportedOperations != vulkan11Properties.subgroupSupportedOperations ||
5958 subgroupProperties.quadOperationsInAllStages != vulkan11Properties.subgroupQuadOperationsInAllStages))
5959 {
5960 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties and VkPhysicalDeviceVulkan11Properties");
5961 }
5962
5963 if ((pointClippingProperties.pointClippingBehavior != vulkan11Properties.pointClippingBehavior))
5964 {
5965 TCU_FAIL("Mismatch between VkPhysicalDevicePointClippingProperties and VkPhysicalDeviceVulkan11Properties");
5966 }
5967
5968 if ((multiviewProperties.maxMultiviewViewCount != vulkan11Properties.maxMultiviewViewCount ||
5969 multiviewProperties.maxMultiviewInstanceIndex != vulkan11Properties.maxMultiviewInstanceIndex))
5970 {
5971 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewProperties and VkPhysicalDeviceVulkan11Properties");
5972 }
5973
5974 if ((protectedMemoryPropertiesKHR.protectedNoFault != vulkan11Properties.protectedNoFault))
5975 {
5976 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties and VkPhysicalDeviceVulkan11Properties");
5977 }
5978
5979 if ((maintenance3Properties.maxPerSetDescriptors != vulkan11Properties.maxPerSetDescriptors ||
5980 maintenance3Properties.maxMemoryAllocationSize != vulkan11Properties.maxMemoryAllocationSize))
5981 {
5982 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance3Properties and VkPhysicalDeviceVulkan11Properties");
5983 }
5984
5985 if ((driverProperties.driverID != vulkan12Properties.driverID ||
5986 strncmp(driverProperties.driverName, vulkan12Properties.driverName, VK_MAX_DRIVER_NAME_SIZE) != 0 ||
5987 strncmp(driverProperties.driverInfo, vulkan12Properties.driverInfo, VK_MAX_DRIVER_INFO_SIZE) != 0 ||
5988 driverProperties.conformanceVersion.major != vulkan12Properties.conformanceVersion.major ||
5989 driverProperties.conformanceVersion.minor != vulkan12Properties.conformanceVersion.minor ||
5990 driverProperties.conformanceVersion.subminor != vulkan12Properties.conformanceVersion.subminor ||
5991 driverProperties.conformanceVersion.patch != vulkan12Properties.conformanceVersion.patch))
5992 {
5993 TCU_FAIL("Mismatch between VkPhysicalDeviceDriverProperties and VkPhysicalDeviceVulkan12Properties");
5994 }
5995
5996 if ((floatControlsProperties.denormBehaviorIndependence != vulkan12Properties.denormBehaviorIndependence ||
5997 floatControlsProperties.roundingModeIndependence != vulkan12Properties.roundingModeIndependence ||
5998 floatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ||
5999 floatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ||
6000 floatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ||
6001 floatControlsProperties.shaderDenormPreserveFloat16 != vulkan12Properties.shaderDenormPreserveFloat16 ||
6002 floatControlsProperties.shaderDenormPreserveFloat32 != vulkan12Properties.shaderDenormPreserveFloat32 ||
6003 floatControlsProperties.shaderDenormPreserveFloat64 != vulkan12Properties.shaderDenormPreserveFloat64 ||
6004 floatControlsProperties.shaderDenormFlushToZeroFloat16 != vulkan12Properties.shaderDenormFlushToZeroFloat16 ||
6005 floatControlsProperties.shaderDenormFlushToZeroFloat32 != vulkan12Properties.shaderDenormFlushToZeroFloat32 ||
6006 floatControlsProperties.shaderDenormFlushToZeroFloat64 != vulkan12Properties.shaderDenormFlushToZeroFloat64 ||
6007 floatControlsProperties.shaderRoundingModeRTEFloat16 != vulkan12Properties.shaderRoundingModeRTEFloat16 ||
6008 floatControlsProperties.shaderRoundingModeRTEFloat32 != vulkan12Properties.shaderRoundingModeRTEFloat32 ||
6009 floatControlsProperties.shaderRoundingModeRTEFloat64 != vulkan12Properties.shaderRoundingModeRTEFloat64 ||
6010 floatControlsProperties.shaderRoundingModeRTZFloat16 != vulkan12Properties.shaderRoundingModeRTZFloat16 ||
6011 floatControlsProperties.shaderRoundingModeRTZFloat32 != vulkan12Properties.shaderRoundingModeRTZFloat32 ||
6012 floatControlsProperties.shaderRoundingModeRTZFloat64 != vulkan12Properties.shaderRoundingModeRTZFloat64 ))
6013 {
6014 TCU_FAIL("Mismatch between VkPhysicalDeviceFloatControlsProperties and VkPhysicalDeviceVulkan12Properties");
6015 }
6016
6017 if ((descriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools != vulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ||
6018 descriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative != vulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ||
6019 descriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative != vulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ||
6020 descriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative != vulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ||
6021 descriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative != vulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ||
6022 descriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative != vulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ||
6023 descriptorIndexingProperties.robustBufferAccessUpdateAfterBind != vulkan12Properties.robustBufferAccessUpdateAfterBind ||
6024 descriptorIndexingProperties.quadDivergentImplicitLod != vulkan12Properties.quadDivergentImplicitLod ||
6025 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ||
6026 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ||
6027 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ||
6028 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ||
6029 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ||
6030 descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ||
6031 descriptorIndexingProperties.maxPerStageUpdateAfterBindResources != vulkan12Properties.maxPerStageUpdateAfterBindResources ||
6032 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers != vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ||
6033 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers != vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ||
6034 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic != vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ||
6035 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ||
6036 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ||
6037 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages != vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ||
6038 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ||
6039 descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments != vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ))
6040 {
6041 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingProperties and VkPhysicalDeviceVulkan12Properties");
6042 }
6043
6044 if ((depthStencilResolveProperties.supportedDepthResolveModes != vulkan12Properties.supportedDepthResolveModes ||
6045 depthStencilResolveProperties.supportedStencilResolveModes != vulkan12Properties.supportedStencilResolveModes ||
6046 depthStencilResolveProperties.independentResolveNone != vulkan12Properties.independentResolveNone ||
6047 depthStencilResolveProperties.independentResolve != vulkan12Properties.independentResolve))
6048 {
6049 TCU_FAIL("Mismatch between VkPhysicalDeviceDepthStencilResolveProperties and VkPhysicalDeviceVulkan12Properties");
6050 }
6051
6052 if ((samplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats != vulkan12Properties.filterMinmaxSingleComponentFormats ||
6053 samplerFilterMinmaxProperties.filterMinmaxImageComponentMapping != vulkan12Properties.filterMinmaxImageComponentMapping))
6054 {
6055 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerFilterMinmaxProperties and VkPhysicalDeviceVulkan12Properties");
6056 }
6057
6058 if ((timelineSemaphoreProperties.maxTimelineSemaphoreValueDifference != vulkan12Properties.maxTimelineSemaphoreValueDifference))
6059 {
6060 TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreProperties and VkPhysicalDeviceVulkan12Properties");
6061 }
6062 }
6063
6064 return tcu::TestStatus::pass("Vulkan 1.2 device properties are consistent with extension properties");
6065 }
6066
devicePropertyExtensionsConsistencyVulkan13(Context & context)6067 tcu::TestStatus devicePropertyExtensionsConsistencyVulkan13(Context& context)
6068 {
6069 TestLog& log = context.getTestContext().getLog();
6070 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
6071 const CustomInstance instance = createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2");
6072 const InstanceDriver& vki = instance.getDriver();
6073
6074 if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
6075 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
6076
6077 VkPhysicalDeviceVulkan13Properties vulkan13Properties = initVulkanStructure();
6078 VkPhysicalDeviceProperties2 extProperties = initVulkanStructure(&vulkan13Properties);
6079
6080 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
6081
6082 log << TestLog::Message << vulkan13Properties << TestLog::EndMessage;
6083
6084 // Validate all fields initialized matching to extension structures
6085 {
6086 VkPhysicalDeviceSubgroupSizeControlProperties subgroupSizeControlProperties = initVulkanStructure();
6087 VkPhysicalDeviceInlineUniformBlockProperties inlineUniformBlockProperties = initVulkanStructure(&subgroupSizeControlProperties);
6088 VkPhysicalDeviceShaderIntegerDotProductProperties shaderIntegerDotProductProperties = initVulkanStructure(&inlineUniformBlockProperties);
6089 VkPhysicalDeviceTexelBufferAlignmentProperties texelBufferAlignmentProperties = initVulkanStructure(&shaderIntegerDotProductProperties);
6090 VkPhysicalDeviceMaintenance4Properties maintenance4Properties = initVulkanStructure(&texelBufferAlignmentProperties);
6091 extProperties = initVulkanStructure(&maintenance4Properties);
6092
6093 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
6094
6095 if (subgroupSizeControlProperties.minSubgroupSize != vulkan13Properties.minSubgroupSize ||
6096 subgroupSizeControlProperties.maxSubgroupSize != vulkan13Properties.maxSubgroupSize ||
6097 subgroupSizeControlProperties.maxComputeWorkgroupSubgroups != vulkan13Properties.maxComputeWorkgroupSubgroups ||
6098 subgroupSizeControlProperties.requiredSubgroupSizeStages != vulkan13Properties.requiredSubgroupSizeStages)
6099 {
6100 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlProperties and VkPhysicalDeviceVulkan13Properties");
6101 }
6102
6103 if (inlineUniformBlockProperties.maxInlineUniformBlockSize != vulkan13Properties.maxInlineUniformBlockSize ||
6104 inlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks != vulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ||
6105 inlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks != vulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ||
6106 inlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks != vulkan13Properties.maxDescriptorSetInlineUniformBlocks ||
6107 inlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks != vulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks)
6108 {
6109 TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockProperties and VkPhysicalDeviceVulkan13Properties");
6110 }
6111
6112 if (shaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated != vulkan13Properties.integerDotProduct8BitUnsignedAccelerated ||
6113 shaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated != vulkan13Properties.integerDotProduct8BitSignedAccelerated ||
6114 shaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated != vulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ||
6115 shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated != vulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ||
6116 shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated != vulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ||
6117 shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated != vulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
6118 shaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated != vulkan13Properties.integerDotProduct16BitUnsignedAccelerated ||
6119 shaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated != vulkan13Properties.integerDotProduct16BitSignedAccelerated ||
6120 shaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated != vulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ||
6121 shaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated != vulkan13Properties.integerDotProduct32BitUnsignedAccelerated ||
6122 shaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated != vulkan13Properties.integerDotProduct32BitSignedAccelerated ||
6123 shaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated != vulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ||
6124 shaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated != vulkan13Properties.integerDotProduct64BitUnsignedAccelerated ||
6125 shaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated != vulkan13Properties.integerDotProduct64BitSignedAccelerated ||
6126 shaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated != vulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ||
6127 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
6128 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
6129 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
6130 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
6131 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
6132 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
6133 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
6134 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
6135 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
6136 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
6137 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
6138 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
6139 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
6140 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
6141 shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated != vulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)
6142 {
6143 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductProperties and VkPhysicalDeviceVulkan13Properties");
6144 }
6145
6146 if (texelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes != vulkan13Properties.storageTexelBufferOffsetAlignmentBytes ||
6147 texelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment != vulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ||
6148 texelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes != vulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ||
6149 texelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment != vulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment)
6150 {
6151 TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentProperties and VkPhysicalDeviceVulkan13Properties");
6152 }
6153
6154 if (maintenance4Properties.maxBufferSize != vulkan13Properties.maxBufferSize)
6155 {
6156 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Properties and VkPhysicalDeviceVulkan13Properties");
6157 }
6158 }
6159
6160 return tcu::TestStatus::pass("Vulkan 1.3 device properties are consistent with extension properties");
6161 }
6162
imageFormatProperties2(Context & context,const VkFormat format,const VkImageType imageType,const VkImageTiling tiling)6163 tcu::TestStatus imageFormatProperties2 (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
6164 {
6165 if (isYCbCrFormat(format))
6166 // check if Ycbcr format enums are valid given the version and extensions
6167 checkYcbcrApiSupport(context);
6168
6169 TestLog& log = context.getTestContext().getLog();
6170
6171 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
6172 const InstanceDriver& vki (instance.getDriver());
6173 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
6174
6175 const VkImageCreateFlags ycbcrFlags = isYCbCrFormat(format) ? (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (VkImageCreateFlags)0u;
6176 const VkImageUsageFlags allUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
6177 | VK_IMAGE_USAGE_TRANSFER_DST_BIT
6178 | VK_IMAGE_USAGE_SAMPLED_BIT
6179 | VK_IMAGE_USAGE_STORAGE_BIT
6180 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
6181 | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
6182 | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
6183 | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
6184 const VkImageCreateFlags allCreateFlags = VK_IMAGE_CREATE_SPARSE_BINDING_BIT
6185 | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
6186 | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
6187 | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
6188 | VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
6189 | ycbcrFlags;
6190
6191 for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
6192 {
6193 if (!isValidImageUsageFlagCombination(curUsageFlags))
6194 continue;
6195
6196 for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= allCreateFlags; curCreateFlags++)
6197 {
6198 const VkPhysicalDeviceImageFormatInfo2 imageFormatInfo =
6199 {
6200 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
6201 DE_NULL,
6202 format,
6203 imageType,
6204 tiling,
6205 curUsageFlags,
6206 curCreateFlags
6207 };
6208
6209 VkImageFormatProperties coreProperties;
6210 VkImageFormatProperties2 extProperties;
6211 VkResult coreResult;
6212 VkResult extResult;
6213
6214 deMemset(&coreProperties, 0xcd, sizeof(VkImageFormatProperties));
6215 deMemset(&extProperties, 0xcd, sizeof(VkImageFormatProperties2));
6216
6217 extProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
6218 extProperties.pNext = DE_NULL;
6219
6220 coreResult = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.tiling, imageFormatInfo.usage, imageFormatInfo.flags, &coreProperties);
6221 extResult = vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &extProperties);
6222
6223 TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
6224 TCU_CHECK(extProperties.pNext == DE_NULL);
6225
6226 if ((coreResult != extResult) ||
6227 (deMemCmp(&coreProperties, &extProperties.imageFormatProperties, sizeof(VkImageFormatProperties)) != 0))
6228 {
6229 log << TestLog::Message << "ERROR: device mismatch with query " << imageFormatInfo << TestLog::EndMessage
6230 << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties() returned " << coreResult << ", " << coreProperties << TestLog::EndMessage
6231 << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties2() returned " << extResult << ", " << extProperties << TestLog::EndMessage;
6232 TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceImageFormatProperties and vkGetPhysicalDeviceImageFormatProperties2");
6233 }
6234 }
6235 }
6236
6237 return tcu::TestStatus::pass("Querying image format properties succeeded");
6238 }
6239
sparseImageFormatProperties2(Context & context,const VkFormat format,const VkImageType imageType,const VkImageTiling tiling)6240 tcu::TestStatus sparseImageFormatProperties2 (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
6241 {
6242 TestLog& log = context.getTestContext().getLog();
6243
6244 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
6245 const InstanceDriver& vki (instance.getDriver());
6246 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
6247
6248 const VkImageUsageFlags allUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
6249 | VK_IMAGE_USAGE_TRANSFER_DST_BIT
6250 | VK_IMAGE_USAGE_SAMPLED_BIT
6251 | VK_IMAGE_USAGE_STORAGE_BIT
6252 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
6253 | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
6254 | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
6255 | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
6256
6257 for (deUint32 sampleCountBit = VK_SAMPLE_COUNT_1_BIT; sampleCountBit <= VK_SAMPLE_COUNT_64_BIT; sampleCountBit = (sampleCountBit << 1u))
6258 {
6259 for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
6260 {
6261 if (!isValidImageUsageFlagCombination(curUsageFlags))
6262 continue;
6263
6264 const VkPhysicalDeviceSparseImageFormatInfo2 imageFormatInfo =
6265 {
6266 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
6267 DE_NULL,
6268 format,
6269 imageType,
6270 (VkSampleCountFlagBits)sampleCountBit,
6271 curUsageFlags,
6272 tiling,
6273 };
6274
6275 deUint32 numCoreProperties = 0u;
6276 deUint32 numExtProperties = 0u;
6277
6278 // Query count
6279 vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, DE_NULL);
6280 vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, DE_NULL);
6281
6282 if (numCoreProperties != numExtProperties)
6283 {
6284 log << TestLog::Message << "ERROR: different number of properties reported for " << imageFormatInfo << TestLog::EndMessage;
6285 TCU_FAIL("Mismatch in reported property count");
6286 }
6287
6288 if (!context.getDeviceFeatures().sparseBinding)
6289 {
6290 // There is no support for sparse binding, getPhysicalDeviceSparseImageFormatProperties* MUST report no properties
6291 // Only have to check one of the entrypoints as a mismatch in count is already caught.
6292 if (numCoreProperties > 0)
6293 {
6294 log << TestLog::Message << "ERROR: device does not support sparse binding but claims support for " << numCoreProperties << " properties in vkGetPhysicalDeviceSparseImageFormatProperties with parameters " << imageFormatInfo << TestLog::EndMessage;
6295 TCU_FAIL("Claimed format properties inconsistent with overall sparseBinding feature");
6296 }
6297 }
6298
6299 if (numCoreProperties > 0)
6300 {
6301 std::vector<VkSparseImageFormatProperties> coreProperties (numCoreProperties);
6302 std::vector<VkSparseImageFormatProperties2> extProperties (numExtProperties);
6303
6304 deMemset(&coreProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties)*numCoreProperties);
6305 deMemset(&extProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties2)*numExtProperties);
6306
6307 for (deUint32 ndx = 0; ndx < numExtProperties; ++ndx)
6308 {
6309 extProperties[ndx].sType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
6310 extProperties[ndx].pNext = DE_NULL;
6311 }
6312
6313 vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, &coreProperties[0]);
6314 vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, &extProperties[0]);
6315
6316 TCU_CHECK((size_t)numCoreProperties == coreProperties.size());
6317 TCU_CHECK((size_t)numExtProperties == extProperties.size());
6318
6319 for (deUint32 ndx = 0; ndx < numCoreProperties; ++ndx)
6320 {
6321 TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
6322 TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
6323
6324 if ((deMemCmp(&coreProperties[ndx], &extProperties[ndx].properties, sizeof(VkSparseImageFormatProperties)) != 0))
6325 {
6326 log << TestLog::Message << "ERROR: device mismatch with query " << imageFormatInfo << " property " << ndx << TestLog::EndMessage
6327 << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties() returned " << coreProperties[ndx] << TestLog::EndMessage
6328 << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties2() returned " << extProperties[ndx] << TestLog::EndMessage;
6329 TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceSparseImageFormatProperties and vkGetPhysicalDeviceSparseImageFormatProperties2");
6330 }
6331 }
6332 }
6333 }
6334 }
6335
6336 return tcu::TestStatus::pass("Querying sparse image format properties succeeded");
6337 }
6338
execImageFormatTest(Context & context,ImageFormatPropertyCase testCase)6339 tcu::TestStatus execImageFormatTest (Context& context, ImageFormatPropertyCase testCase)
6340 {
6341 return testCase.testFunction(context, testCase.format, testCase.imageType, testCase.tiling);
6342 }
6343
createImageFormatTypeTilingTests(tcu::TestCaseGroup * testGroup,ImageFormatPropertyCase params)6344 void createImageFormatTypeTilingTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase params)
6345 {
6346 DE_ASSERT(params.format == VK_FORMAT_UNDEFINED);
6347
6348 static const struct
6349 {
6350 VkFormat begin;
6351 VkFormat end;
6352 ImageFormatPropertyCase params;
6353 } s_formatRanges[] =
6354 {
6355 // core formats
6356 { (VkFormat)(VK_FORMAT_UNDEFINED + 1), VK_CORE_FORMAT_LAST, params },
6357
6358 // YCbCr formats
6359 { VK_FORMAT_G8B8G8R8_422_UNORM_KHR, (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR + 1), params },
6360
6361 // YCbCr extended formats
6362 { VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, (VkFormat)(VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT+1), params },
6363 };
6364
6365 for (int rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(s_formatRanges); ++rangeNdx)
6366 {
6367 const VkFormat rangeBegin = s_formatRanges[rangeNdx].begin;
6368 const VkFormat rangeEnd = s_formatRanges[rangeNdx].end;
6369
6370 for (VkFormat format = rangeBegin; format != rangeEnd; format = (VkFormat)(format+1))
6371 {
6372 const bool isYCbCr = isYCbCrFormat(format);
6373 const bool isSparse = (params.testFunction == sparseImageFormatProperties2);
6374
6375 if (isYCbCr && isSparse)
6376 continue;
6377
6378 if (isYCbCr && params.imageType != VK_IMAGE_TYPE_2D)
6379 continue;
6380
6381 const char* const enumName = getFormatName(format);
6382 const string caseName = de::toLower(string(enumName).substr(10));
6383
6384 params.format = format;
6385
6386 addFunctionCase(testGroup, caseName, enumName, execImageFormatTest, params);
6387 }
6388 }
6389 }
6390
createImageFormatTypeTests(tcu::TestCaseGroup * testGroup,ImageFormatPropertyCase params)6391 void createImageFormatTypeTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase params)
6392 {
6393 DE_ASSERT(params.tiling == VK_CORE_IMAGE_TILING_LAST);
6394
6395 testGroup->addChild(createTestGroup(testGroup->getTestContext(), "optimal", "", createImageFormatTypeTilingTests, ImageFormatPropertyCase(params.testFunction, VK_FORMAT_UNDEFINED, params.imageType, VK_IMAGE_TILING_OPTIMAL)));
6396 testGroup->addChild(createTestGroup(testGroup->getTestContext(), "linear", "", createImageFormatTypeTilingTests, ImageFormatPropertyCase(params.testFunction, VK_FORMAT_UNDEFINED, params.imageType, VK_IMAGE_TILING_LINEAR)));
6397 }
6398
createImageFormatTests(tcu::TestCaseGroup * testGroup,ImageFormatPropertyCase::Function testFunction)6399 void createImageFormatTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase::Function testFunction)
6400 {
6401 testGroup->addChild(createTestGroup(testGroup->getTestContext(), "1d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_1D, VK_CORE_IMAGE_TILING_LAST)));
6402 testGroup->addChild(createTestGroup(testGroup->getTestContext(), "2d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_2D, VK_CORE_IMAGE_TILING_LAST)));
6403 testGroup->addChild(createTestGroup(testGroup->getTestContext(), "3d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_3D, VK_CORE_IMAGE_TILING_LAST)));
6404 }
6405
6406
6407 // Android CTS -specific tests
6408
6409 namespace android
6410 {
6411
checkExtensions(tcu::ResultCollector & results,const set<string> & allowedExtensions,const vector<VkExtensionProperties> & reportedExtensions)6412 void checkExtensions (tcu::ResultCollector& results, const set<string>& allowedExtensions, const vector<VkExtensionProperties>& reportedExtensions)
6413 {
6414 for (vector<VkExtensionProperties>::const_iterator extension = reportedExtensions.begin(); extension != reportedExtensions.end(); ++extension)
6415 {
6416 const string extensionName (extension->extensionName);
6417 const bool mustBeKnown = de::beginsWith(extensionName, "VK_GOOGLE_") ||
6418 de::beginsWith(extensionName, "VK_ANDROID_");
6419
6420 if (mustBeKnown && !de::contains(allowedExtensions, extensionName))
6421 results.fail("Unknown extension: " + extensionName);
6422 }
6423 }
6424
testNoUnknownExtensions(Context & context)6425 tcu::TestStatus testNoUnknownExtensions (Context& context)
6426 {
6427 TestLog& log = context.getTestContext().getLog();
6428 tcu::ResultCollector results (log);
6429 set<string> allowedInstanceExtensions;
6430 set<string> allowedDeviceExtensions;
6431
6432 // All known extensions should be added to allowedExtensions:
6433 // allowedExtensions.insert("VK_GOOGLE_extension1");
6434 allowedDeviceExtensions.insert("VK_ANDROID_external_memory_android_hardware_buffer");
6435 allowedDeviceExtensions.insert("VK_GOOGLE_display_timing");
6436 allowedDeviceExtensions.insert("VK_GOOGLE_decorate_string");
6437 allowedDeviceExtensions.insert("VK_GOOGLE_hlsl_functionality1");
6438 allowedInstanceExtensions.insert("VK_GOOGLE_surfaceless_query");
6439
6440 // Instance extensions
6441 checkExtensions(results,
6442 allowedInstanceExtensions,
6443 enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL));
6444
6445 // Extensions exposed by instance layers
6446 {
6447 const vector<VkLayerProperties> layers = enumerateInstanceLayerProperties(context.getPlatformInterface());
6448
6449 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6450 {
6451 checkExtensions(results,
6452 allowedInstanceExtensions,
6453 enumerateInstanceExtensionProperties(context.getPlatformInterface(), layer->layerName));
6454 }
6455 }
6456
6457 // Device extensions
6458 checkExtensions(results,
6459 allowedDeviceExtensions,
6460 enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL));
6461
6462 // Extensions exposed by device layers
6463 {
6464 const vector<VkLayerProperties> layers = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
6465
6466 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6467 {
6468 checkExtensions(results,
6469 allowedDeviceExtensions,
6470 enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), layer->layerName));
6471 }
6472 }
6473
6474 return tcu::TestStatus(results.getResult(), results.getMessage());
6475 }
6476
testNoLayers(Context & context)6477 tcu::TestStatus testNoLayers (Context& context)
6478 {
6479 TestLog& log = context.getTestContext().getLog();
6480 tcu::ResultCollector results (log);
6481
6482 {
6483 const vector<VkLayerProperties> layers = enumerateInstanceLayerProperties(context.getPlatformInterface());
6484
6485 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6486 results.fail(string("Instance layer enumerated: ") + layer->layerName);
6487 }
6488
6489 {
6490 const vector<VkLayerProperties> layers = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
6491
6492 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6493 results.fail(string("Device layer enumerated: ") + layer->layerName);
6494 }
6495
6496 return tcu::TestStatus(results.getResult(), results.getMessage());
6497 }
6498
testMandatoryExtensions(Context & context)6499 tcu::TestStatus testMandatoryExtensions (Context& context)
6500 {
6501 TestLog& log = context.getTestContext().getLog();
6502 tcu::ResultCollector results (log);
6503
6504 // Instance extensions
6505 {
6506 static const string mandatoryExtensions[] =
6507 {
6508 "VK_KHR_get_physical_device_properties2",
6509 };
6510
6511 for (const auto &ext : mandatoryExtensions)
6512 {
6513 if (!context.isInstanceFunctionalitySupported(ext))
6514 results.fail(ext + " is not supported");
6515 }
6516 }
6517
6518 // Device extensions
6519 {
6520 static const string mandatoryExtensions[] =
6521 {
6522 "VK_KHR_maintenance1",
6523 };
6524
6525 for (const auto &ext : mandatoryExtensions)
6526 {
6527 if (!context.isDeviceFunctionalitySupported(ext))
6528 results.fail(ext + " is not supported");
6529 }
6530 }
6531
6532 return tcu::TestStatus(results.getResult(), results.getMessage());
6533 }
6534
6535 } // android
6536
6537 } // anonymous
6538
addFunctionCaseInNewSubgroup(tcu::TestContext & testCtx,tcu::TestCaseGroup * group,const std::string & subgroupName,const std::string & subgroupDescription,FunctionInstance0::Function testFunc)6539 static inline void addFunctionCaseInNewSubgroup (
6540 tcu::TestContext& testCtx,
6541 tcu::TestCaseGroup* group,
6542 const std::string& subgroupName,
6543 const std::string& subgroupDescription,
6544 FunctionInstance0::Function testFunc)
6545 {
6546 de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, subgroupName.c_str(), subgroupDescription.c_str()));
6547 addFunctionCase(subgroup.get(), "basic", "", testFunc);
6548 group->addChild(subgroup.release());
6549 }
6550
createFeatureInfoTests(tcu::TestContext & testCtx)6551 tcu::TestCaseGroup* createFeatureInfoTests (tcu::TestContext& testCtx)
6552 {
6553 de::MovePtr<tcu::TestCaseGroup> infoTests (new tcu::TestCaseGroup(testCtx, "info", "Platform Information Tests"));
6554
6555 infoTests->addChild(createTestGroup(testCtx, "format_properties", "VkGetPhysicalDeviceFormatProperties() Tests", createFormatTests));
6556 infoTests->addChild(createTestGroup(testCtx, "image_format_properties", "VkGetPhysicalDeviceImageFormatProperties() Tests", createImageFormatTests, imageFormatProperties));
6557
6558 {
6559 de::MovePtr<tcu::TestCaseGroup> extCoreVersionGrp (new tcu::TestCaseGroup(testCtx, "extension_core_versions", "Tests checking extension required core versions"));
6560
6561 addFunctionCase(extCoreVersionGrp.get(), "extension_core_versions", "", extensionCoreVersions);
6562
6563 infoTests->addChild(extCoreVersionGrp.release());
6564 }
6565
6566 {
6567 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "get_physical_device_properties2", "VK_KHR_get_physical_device_properties2"));
6568
6569 {
6570 de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, "features", ""));
6571 addFunctionCase(subgroup.get(), "core", "Extended Device Features", deviceFeatures2);
6572 addSeparateFeatureTests(subgroup.get());
6573 extendedPropertiesTests->addChild(subgroup.release());
6574 }
6575 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "properties", "Extended Device Properties", deviceProperties2);
6576 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "format_properties", "Extended Device Format Properties", deviceFormatProperties2);
6577 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "queue_family_properties", "Extended Device Queue Family Properties", deviceQueueFamilyProperties2);
6578 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "memory_properties", "Extended Device Memory Properties", deviceMemoryProperties2);
6579
6580 infoTests->addChild(extendedPropertiesTests.release());
6581 }
6582
6583 {
6584 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "vulkan1p2", "Vulkan 1.2 related tests"));
6585
6586 addFunctionCase(extendedPropertiesTests.get(), "features", "Extended Vulkan 1.2 Device Features", deviceFeaturesVulkan12);
6587 addFunctionCase(extendedPropertiesTests.get(), "properties", "Extended Vulkan 1.2 Device Properties", devicePropertiesVulkan12);
6588 addFunctionCase(extendedPropertiesTests.get(), "feature_extensions_consistency", "Vulkan 1.2 consistency between Features and Extensions", deviceFeatureExtensionsConsistencyVulkan12);
6589 addFunctionCase(extendedPropertiesTests.get(), "property_extensions_consistency", "Vulkan 1.2 consistency between Properties and Extensions", devicePropertyExtensionsConsistencyVulkan12);
6590 addFunctionCase(extendedPropertiesTests.get(), "feature_bits_influence", "Validate feature bits influence on feature activation", checkApiVersionSupport<1,2>, featureBitInfluenceOnDeviceCreate<VK_API_VERSION_1_2>);
6591
6592 infoTests->addChild(extendedPropertiesTests.release());
6593 }
6594
6595 {
6596 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "vulkan1p3", "Vulkan 1.3 related tests"));
6597
6598 addFunctionCase(extendedPropertiesTests.get(), "features", "Extended Vulkan 1.3 Device Features", deviceFeaturesVulkan13);
6599 addFunctionCase(extendedPropertiesTests.get(), "properties", "Extended Vulkan 1.3 Device Properties", devicePropertiesVulkan13);
6600 addFunctionCase(extendedPropertiesTests.get(), "feature_extensions_consistency", "Vulkan 1.3 consistency between Features and Extensions", deviceFeatureExtensionsConsistencyVulkan13);
6601 addFunctionCase(extendedPropertiesTests.get(), "property_extensions_consistency", "Vulkan 1.3 consistency between Properties and Extensions", devicePropertyExtensionsConsistencyVulkan13);
6602 addFunctionCase(extendedPropertiesTests.get(), "feature_bits_influence", "Validate feature bits influence on feature activation", checkApiVersionSupport<1, 3>, featureBitInfluenceOnDeviceCreate<VK_API_VERSION_1_3>);
6603
6604 infoTests->addChild(extendedPropertiesTests.release());
6605 }
6606
6607 {
6608 de::MovePtr<tcu::TestCaseGroup> limitsValidationTests (new tcu::TestCaseGroup(testCtx, "vulkan1p2_limits_validation", "Vulkan 1.2 and core extensions limits validation"));
6609
6610 addFunctionCase(limitsValidationTests.get(), "general", "Vulkan 1.2 Limit validation", checkApiVersionSupport<1, 2>, validateLimits12);
6611 addFunctionCase(limitsValidationTests.get(), "khr_push_descriptor", "VK_KHR_push_descriptor limit validation", checkSupportKhrPushDescriptor, validateLimitsKhrPushDescriptor);
6612 addFunctionCase(limitsValidationTests.get(), "khr_multiview", "VK_KHR_multiview limit validation", checkSupportKhrMultiview, validateLimitsKhrMultiview);
6613 addFunctionCase(limitsValidationTests.get(), "ext_discard_rectangles", "VK_EXT_discard_rectangles limit validation", checkSupportExtDiscardRectangles, validateLimitsExtDiscardRectangles);
6614 addFunctionCase(limitsValidationTests.get(), "ext_sample_locations", "VK_EXT_sample_locations limit validation", checkSupportExtSampleLocations, validateLimitsExtSampleLocations);
6615 addFunctionCase(limitsValidationTests.get(), "ext_external_memory_host", "VK_EXT_external_memory_host limit validation", checkSupportExtExternalMemoryHost, validateLimitsExtExternalMemoryHost);
6616 addFunctionCase(limitsValidationTests.get(), "ext_blend_operation_advanced", "VK_EXT_blend_operation_advanced limit validation", checkSupportExtBlendOperationAdvanced, validateLimitsExtBlendOperationAdvanced);
6617 addFunctionCase(limitsValidationTests.get(), "khr_maintenance_3", "VK_KHR_maintenance3 limit validation", checkSupportKhrMaintenance3, validateLimitsKhrMaintenance3);
6618 addFunctionCase(limitsValidationTests.get(), "ext_conservative_rasterization", "VK_EXT_conservative_rasterization limit validation", checkSupportExtConservativeRasterization, validateLimitsExtConservativeRasterization);
6619 addFunctionCase(limitsValidationTests.get(), "ext_descriptor_indexing", "VK_EXT_descriptor_indexing limit validation", checkSupportExtDescriptorIndexing, validateLimitsExtDescriptorIndexing);
6620 addFunctionCase(limitsValidationTests.get(), "ext_inline_uniform_block", "VK_EXT_inline_uniform_block limit validation", checkSupportExtInlineUniformBlock, validateLimitsExtInlineUniformBlock);
6621 addFunctionCase(limitsValidationTests.get(), "ext_vertex_attribute_divisor", "VK_EXT_vertex_attribute_divisor limit validation", checkSupportExtVertexAttributeDivisor, validateLimitsExtVertexAttributeDivisor);
6622 addFunctionCase(limitsValidationTests.get(), "nv_mesh_shader", "VK_NV_mesh_shader limit validation", checkSupportNvMeshShader, validateLimitsNvMeshShader);
6623 addFunctionCase(limitsValidationTests.get(), "ext_transform_feedback", "VK_EXT_transform_feedback limit validation", checkSupportExtTransformFeedback, validateLimitsExtTransformFeedback);
6624 addFunctionCase(limitsValidationTests.get(), "fragment_density_map", "VK_EXT_fragment_density_map limit validation", checkSupportExtFragmentDensityMap, validateLimitsExtFragmentDensityMap);
6625 addFunctionCase(limitsValidationTests.get(), "nv_ray_tracing", "VK_NV_ray_tracing limit validation", checkSupportNvRayTracing, validateLimitsNvRayTracing);
6626 addFunctionCase(limitsValidationTests.get(), "timeline_semaphore", "VK_KHR_timeline_semaphore limit validation", checkSupportKhrTimelineSemaphore, validateLimitsKhrTimelineSemaphore);
6627 addFunctionCase(limitsValidationTests.get(), "ext_line_rasterization", "VK_EXT_line_rasterization limit validation", checkSupportExtLineRasterization, validateLimitsExtLineRasterization);
6628
6629 infoTests->addChild(limitsValidationTests.release());
6630 }
6631
6632 {
6633 de::MovePtr<tcu::TestCaseGroup> limitsValidationTests(new tcu::TestCaseGroup(testCtx, "vulkan1p3_limits_validation", "Vulkan 1.3 and core extensions limits validation"));
6634
6635 addFunctionCase(limitsValidationTests.get(), "khr_maintenance4", "VK_KHR_maintenance4", checkSupportKhrMaintenance4, validateLimitsKhrMaintenance4);
6636 addFunctionCase(limitsValidationTests.get(), "max_inline_uniform_total_size", "maxInlineUniformTotalSize limit validation", checkApiVersionSupport<1, 3>, validateLimitsMaxInlineUniformTotalSize);
6637
6638 infoTests->addChild(limitsValidationTests.release());
6639 }
6640
6641 infoTests->addChild(createTestGroup(testCtx, "image_format_properties2", "VkGetPhysicalDeviceImageFormatProperties2() Tests", createImageFormatTests, imageFormatProperties2));
6642 infoTests->addChild(createTestGroup(testCtx, "sparse_image_format_properties2", "VkGetPhysicalDeviceSparseImageFormatProperties2() Tests", createImageFormatTests, sparseImageFormatProperties2));
6643
6644 {
6645 de::MovePtr<tcu::TestCaseGroup> profilesValidationTests(new tcu::TestCaseGroup(testCtx, "profiles", "Profiles limits and features validation"));
6646
6647 addFunctionCase(profilesValidationTests.get(), "roadmap_2022", "Limits and features check for roadmap 2022", checkApiVersionSupport<1, 3>, validateRoadmap2022);
6648
6649 infoTests->addChild(profilesValidationTests.release());
6650 }
6651
6652 {
6653 de::MovePtr<tcu::TestCaseGroup> androidTests (new tcu::TestCaseGroup(testCtx, "android", "Android CTS Tests"));
6654
6655 addFunctionCase(androidTests.get(), "mandatory_extensions", "Test that all mandatory extensions are supported", android::testMandatoryExtensions);
6656 addFunctionCase(androidTests.get(), "no_unknown_extensions", "Test for unknown device or instance extensions", android::testNoUnknownExtensions);
6657 addFunctionCase(androidTests.get(), "no_layers", "Test that no layers are enumerated", android::testNoLayers);
6658
6659 infoTests->addChild(androidTests.release());
6660 }
6661
6662 return infoTests.release();
6663 }
6664
createFeatureInfoInstanceTests(tcu::TestCaseGroup * testGroup)6665 void createFeatureInfoInstanceTests(tcu::TestCaseGroup* testGroup)
6666 {
6667 addFunctionCase(testGroup, "physical_devices", "Physical devices", enumeratePhysicalDevices);
6668 addFunctionCase(testGroup, "physical_device_groups", "Physical devices Groups", enumeratePhysicalDeviceGroups);
6669 addFunctionCase(testGroup, "instance_layers", "Layers", enumerateInstanceLayers);
6670 addFunctionCase(testGroup, "instance_extensions", "Extensions", enumerateInstanceExtensions);
6671 }
6672
createFeatureInfoDeviceTests(tcu::TestCaseGroup * testGroup)6673 void createFeatureInfoDeviceTests(tcu::TestCaseGroup* testGroup)
6674 {
6675 addFunctionCase(testGroup, "device_features", "Device Features", deviceFeatures);
6676 addFunctionCase(testGroup, "device_properties", "Device Properties", deviceProperties);
6677 addFunctionCase(testGroup, "device_queue_family_properties", "Queue family properties", deviceQueueFamilyProperties);
6678 addFunctionCase(testGroup, "device_memory_properties", "Memory properties", deviceMemoryProperties);
6679 addFunctionCase(testGroup, "device_layers", "Layers", enumerateDeviceLayers);
6680 addFunctionCase(testGroup, "device_extensions", "Extensions", enumerateDeviceExtensions);
6681 addFunctionCase(testGroup, "device_no_khx_extensions", "KHX extensions", testNoKhxExtensions);
6682 addFunctionCase(testGroup, "device_memory_budget", "Memory budget", deviceMemoryBudgetProperties);
6683 addFunctionCase(testGroup, "device_mandatory_features", "Mandatory features", deviceMandatoryFeatures);
6684 }
6685
createFeatureInfoDeviceGroupTests(tcu::TestCaseGroup * testGroup)6686 void createFeatureInfoDeviceGroupTests(tcu::TestCaseGroup* testGroup)
6687 {
6688 addFunctionCase(testGroup, "device_group_peer_memory_features", "Device Group peer memory features", deviceGroupPeerMemoryFeatures);
6689 }
6690
6691 } // api
6692 } // vkt
6693