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