1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2019 Advanced Micro Devices, Inc.
6 * Copyright (c) 2019 The Khronos Group Inc.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief VK_EXT_tooling_info tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktCustomInstancesDevices.hpp"
26 #include "vkDeviceUtil.hpp"
27 #include "vktApiToolingInfoTests.hpp"
28 #include "vktTestGroupUtil.hpp"
29 #include "vktTestCaseUtil.hpp"
30 #include "vkQueryUtil.hpp"
31 #include "vkStrUtil.hpp"
32 #include "vkTypeUtil.hpp"
33 #include "tcuTestLog.hpp"
34 #include "tcuCommandLine.hpp"
35 #include <iostream>
36 #include <string>
37 #include <vector>
38
39 #include <string.h>
40
41 using namespace vk;
42
43 namespace vkt
44 {
45 namespace api
46 {
47 namespace
48 {
49
validateToolPurposeFlagBits(const VkToolPurposeFlagsEXT purposes)50 bool validateToolPurposeFlagBits (const VkToolPurposeFlagsEXT purposes)
51 {
52 const VkToolPurposeFlagsEXT validPurposes = VK_TOOL_PURPOSE_VALIDATION_BIT_EXT |
53 VK_TOOL_PURPOSE_PROFILING_BIT_EXT |
54 VK_TOOL_PURPOSE_TRACING_BIT_EXT |
55 VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT |
56 VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT |
57 VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT |
58 VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT;
59 return (purposes | validPurposes) == validPurposes;
60 }
61
checkSupport(Context & context)62 void checkSupport (Context& context)
63 {
64 context.requireDeviceFunctionality("VK_EXT_tooling_info");
65 }
66
createCustomInstance(Context & context,bool allowLayers)67 CustomInstance createCustomInstance (Context& context, bool allowLayers)
68 {
69 return createCustomInstanceFromContext(context, nullptr, allowLayers);
70 }
71
checkToolsProperties(Context & context,const std::vector<VkPhysicalDeviceToolPropertiesEXT> & deviceToolPropertiesEXTArray)72 bool checkToolsProperties (Context& context, const std::vector<VkPhysicalDeviceToolPropertiesEXT>& deviceToolPropertiesEXTArray)
73 {
74 tcu::TestLog& testLog = context.getTestContext().getLog();
75 bool result = true;
76
77 for (size_t i = 0; i < deviceToolPropertiesEXTArray.size(); ++i)
78 {
79 size_t nameSize = strnlen(deviceToolPropertiesEXTArray[i].name, VK_MAX_EXTENSION_NAME_SIZE);
80 size_t versionSize = strnlen(deviceToolPropertiesEXTArray[i].version, VK_MAX_EXTENSION_NAME_SIZE);
81 size_t descSize = strnlen(deviceToolPropertiesEXTArray[i].description, VK_MAX_DESCRIPTION_SIZE);
82 size_t layerSize = strnlen(deviceToolPropertiesEXTArray[i].layer, VK_MAX_EXTENSION_NAME_SIZE);
83
84 result = result && (deviceToolPropertiesEXTArray[i].sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT);
85 result = result && validateToolPurposeFlagBits(deviceToolPropertiesEXTArray[i].purposes);
86 result = result && ((nameSize > 0) && (nameSize < VK_MAX_EXTENSION_NAME_SIZE));
87 result = result && ((versionSize > 0) && (versionSize < VK_MAX_EXTENSION_NAME_SIZE));
88 result = result && ((descSize > 0) && (descSize < VK_MAX_DESCRIPTION_SIZE));
89 result = result && ((layerSize == 0) || (layerSize < VK_MAX_EXTENSION_NAME_SIZE));
90
91 if (result == false)
92 {
93 testLog << tcu::TestLog::Message << "Tool validation failed" << tcu::TestLog::EndMessage;
94 testLog << tcu::TestLog::Message << "Tool name: " << deviceToolPropertiesEXTArray[i].name << tcu::TestLog::EndMessage;
95 testLog << tcu::TestLog::Message << "Version: " << deviceToolPropertiesEXTArray[i].version << tcu::TestLog::EndMessage;
96 testLog << tcu::TestLog::Message << "Description: " << deviceToolPropertiesEXTArray[i].description << tcu::TestLog::EndMessage;
97 testLog << tcu::TestLog::Message << "Purposes: " << getToolPurposeFlagsEXTStr(deviceToolPropertiesEXTArray[i].purposes) << tcu::TestLog::EndMessage;
98 if (layerSize > 0)
99 {
100 testLog << tcu::TestLog::Message << "Corresponding Layer: " << deviceToolPropertiesEXTArray[i].layer << tcu::TestLog::EndMessage;
101 }
102
103 break;
104 }
105 }
106 return result;
107 }
108
validateGetter(Context & context)109 tcu::TestStatus validateGetter (Context& context)
110 {
111 tcu::TestLog& testLog = context.getTestContext().getLog();
112
113 VkResult result = VK_SUCCESS;
114 deUint32 toolCount = 0;
115
116 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, DE_NULL);
117
118 if(result != VK_SUCCESS)
119 {
120 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
121 return tcu::TestStatus::fail("Fail");
122 }
123
124 if (toolCount > 0)
125 {
126 deUint32 toolCountSecondCall = toolCount;
127
128 std::vector<VkPhysicalDeviceToolPropertiesEXT> deviceToolPropertiesEXTArray(toolCountSecondCall);
129
130 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
131
132 if (result != VK_SUCCESS)
133 {
134 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
135 return tcu::TestStatus::fail("Fail");
136 }
137
138 if (toolCountSecondCall != toolCount)
139 {
140 testLog << tcu::TestLog::Message << "Got different tools count on the second call" << tcu::TestLog::EndMessage;
141 return tcu::TestStatus::fail("Fail");
142 }
143
144 toolCountSecondCall++;
145
146 deviceToolPropertiesEXTArray.resize(toolCountSecondCall);
147
148 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
149
150 if (result != VK_SUCCESS)
151 {
152 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
153 return tcu::TestStatus::fail("Fail");
154 }
155
156 if (toolCountSecondCall != toolCount)
157 {
158 testLog << tcu::TestLog::Message << "Bigger array causes an error" << tcu::TestLog::EndMessage;
159 return tcu::TestStatus::fail("Fail");
160 }
161
162 toolCountSecondCall = 0;
163
164 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
165
166 if (result != VK_INCOMPLETE)
167 {
168 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
169 return tcu::TestStatus::fail("Fail");
170 }
171
172 if (toolCountSecondCall != 0)
173 {
174 testLog << tcu::TestLog::Message << "Zero array causes an error" << tcu::TestLog::EndMessage;
175 return tcu::TestStatus::fail("Fail");
176 }
177 }
178
179 if (toolCount > 1)
180 {
181 deUint32 toolCountSecondCall = toolCount / 2;
182
183 std::vector<VkPhysicalDeviceToolPropertiesEXT> deviceToolPropertiesEXTArray(toolCountSecondCall);
184
185 result = context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCountSecondCall, &deviceToolPropertiesEXTArray[0]);
186
187 if (result != VK_INCOMPLETE)
188 {
189 testLog << tcu::TestLog::Message << "getPhysicalDeviceToolPropertiesEXT wrong result code" << tcu::TestLog::EndMessage;
190 return tcu::TestStatus::fail("Fail");
191 }
192
193 if (toolCountSecondCall != (toolCount / 2))
194 {
195 testLog << tcu::TestLog::Message << "Smaller array causes an error" << tcu::TestLog::EndMessage;
196 return tcu::TestStatus::fail("Fail");
197 }
198 }
199
200 return tcu::TestStatus::pass("Pass");
201 }
202
validateToolsProperties(Context & context)203 tcu::TestStatus validateToolsProperties (Context& context)
204 {
205 deUint32 toolCount = 0;
206
207 VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, DE_NULL));
208
209 if (toolCount > 0)
210 {
211 std::vector<VkPhysicalDeviceToolPropertiesEXT> deviceToolPropertiesEXTArray(toolCount);
212
213 VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(context.getPhysicalDevice(), &toolCount, &deviceToolPropertiesEXTArray[0]));
214
215 if (checkToolsProperties(context, deviceToolPropertiesEXTArray) == false)
216 return tcu::TestStatus::fail("Fail");
217 }
218
219 return tcu::TestStatus::pass("Pass");
220 }
221
validateInstanceLayers(Context & context)222 tcu::TestStatus validateInstanceLayers (Context& context)
223 {
224 const std::vector<const char*> layers = getValidationLayers(context.getPlatformInterface());
225 bool qualityWarning = false;
226
227 {
228 deUint32 toolCount = 0;
229 CustomInstance instance (createCustomInstance(context, true));
230 VkPhysicalDevice physicalDevice = chooseDevice(instance.getDriver(), instance, context.getTestContext().getCommandLine());
231
232 VK_CHECK(instance.getDriver().getPhysicalDeviceToolPropertiesEXT(physicalDevice, &toolCount, DE_NULL));
233
234 if (toolCount < layers.size())
235 qualityWarning = true;
236
237 if (toolCount > 0)
238 {
239 std::vector<VkPhysicalDeviceToolPropertiesEXT> deviceToolPropertiesEXTArray(toolCount);
240
241 VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(physicalDevice, &toolCount, &deviceToolPropertiesEXTArray[0]));
242
243 if (checkToolsProperties(context, deviceToolPropertiesEXTArray) == false)
244 return tcu::TestStatus::fail("Fail");
245
246 for (size_t layerNdx = 0; layerNdx < layers.size(); ++layerNdx)
247 {
248 deUint32 count = 0u;
249
250 for (deUint32 toolNdx = 0; toolNdx < toolCount; ++toolNdx)
251 {
252 if (strcmp(layers[layerNdx], deviceToolPropertiesEXTArray[toolNdx].layer) == 0)
253 count++;
254 }
255
256 if (count != 1)
257 {
258 qualityWarning = true;
259 break;
260 }
261 }
262 }
263 }
264
265 {
266 deUint32 toolCount = 0;
267 CustomInstance instance (createCustomInstance(context, false));
268 VkPhysicalDevice physicalDevice = chooseDevice(instance.getDriver(), instance, context.getTestContext().getCommandLine());
269
270 VK_CHECK(instance.getDriver().getPhysicalDeviceToolPropertiesEXT(physicalDevice, &toolCount, DE_NULL));
271
272 if (toolCount > 0)
273 {
274 std::vector<VkPhysicalDeviceToolPropertiesEXT> deviceToolPropertiesEXTArray(toolCount);
275
276 VK_CHECK(context.getInstanceInterface().getPhysicalDeviceToolPropertiesEXT(physicalDevice, &toolCount, &deviceToolPropertiesEXTArray[0]));
277
278 if (checkToolsProperties(context, deviceToolPropertiesEXTArray) == false)
279 return tcu::TestStatus::fail("Fail");
280
281 for (size_t layerNdx = 0; layerNdx < layers.size(); ++layerNdx)
282 {
283 for (deUint32 toolNdx = 0; toolNdx < toolCount; ++toolNdx)
284 {
285 if (strcmp(layers[layerNdx], deviceToolPropertiesEXTArray[toolNdx].layer) == 0)
286 {
287 qualityWarning = true;
288 layerNdx = layers.size();
289 break;
290 }
291 }
292 }
293 }
294 }
295
296 if (qualityWarning)
297 {
298 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Layers have been reported wrong");
299 }
300 else
301 {
302 return tcu::TestStatus::pass("Pass");
303 }
304 }
305
createTestCases(tcu::TestCaseGroup * group)306 void createTestCases (tcu::TestCaseGroup* group)
307 {
308 addFunctionCase(group, "validate_getter", "Validate getPhysicalDeviceToolPropertiesEXT", checkSupport, validateGetter);
309 addFunctionCase(group, "validate_tools_properties","Validate tools properties", checkSupport, validateToolsProperties);
310 addFunctionCase(group, "validate_instance_layers", "Validate instance layers", checkSupport, validateInstanceLayers);
311 }
312
313 } // anonymous
314
createToolingInfoTests(tcu::TestContext & testCtx)315 tcu::TestCaseGroup* createToolingInfoTests (tcu::TestContext& testCtx)
316 {
317 return createTestGroup(testCtx, "tooling_info", "VK_EXT_tooling_info tests", createTestCases);
318 }
319
320 } // api
321 } // vkt
322