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 Device Initialization Tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktApiDeviceInitializationTests.hpp"
25 #include "vktTestCaseUtil.hpp"
26
27 #include "vkDefs.hpp"
28 #include "vkPlatform.hpp"
29 #include "vkStrUtil.hpp"
30 #include "vkRef.hpp"
31 #include "vkRefUtil.hpp"
32 #include "vkQueryUtil.hpp"
33 #include "vkMemUtil.hpp"
34 #include "vkDeviceUtil.hpp"
35 #include "vkApiVersion.hpp"
36
37 #include "tcuTestLog.hpp"
38 #include "tcuResultCollector.hpp"
39
40 #include "deUniquePtr.hpp"
41 #include "deStringUtil.hpp"
42
43 #include <vector>
44
45 namespace vkt
46 {
47 namespace api
48 {
49
50 namespace
51 {
52
53 using namespace vk;
54 using namespace std;
55 using std::vector;
56 using tcu::TestLog;
57
createInstanceTest(Context & context)58 tcu::TestStatus createInstanceTest (Context& context)
59 {
60 tcu::TestLog& log = context.getTestContext().getLog();
61 tcu::ResultCollector resultCollector (log);
62 const char* appNames[] = { "appName", DE_NULL, "", "app, name", "app(\"name\"", "app~!@#$%^&*()_+name", "app\nName", "app\r\nName" };
63 const char* engineNames[] = { "engineName", DE_NULL, "", "engine. name", "engine\"(name)", "eng~!@#$%^&*()_+name", "engine\nName", "engine\r\nName" };
64 const int patchNumbers[] = { 0, 1, 2, 3, 4, 5, 13, 4094, 4095 };
65 const deUint32 appVersions[] = { 0, 1, (deUint32)-1 };
66 const deUint32 engineVersions[] = { 0, 1, (deUint32)-1 };
67 const PlatformInterface& platformInterface = context.getPlatformInterface();
68 vector<VkApplicationInfo> appInfos;
69
70 // test over appName
71 for (int appNameNdx = 0; appNameNdx < DE_LENGTH_OF_ARRAY(appNames); appNameNdx++)
72 {
73 const VkApplicationInfo appInfo =
74 {
75 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
76 DE_NULL, // const void* pNext;
77 appNames[appNameNdx], // const char* pAppName;
78 0u, // deUint32 appVersion;
79 "engineName", // const char* pEngineName;
80 0u, // deUint32 engineVersion;
81 VK_API_VERSION, // deUint32 apiVersion;
82 };
83
84 appInfos.push_back(appInfo);
85 }
86
87 // test over engineName
88 for (int engineNameNdx = 0; engineNameNdx < DE_LENGTH_OF_ARRAY(engineNames); engineNameNdx++)
89 {
90 const VkApplicationInfo appInfo =
91 {
92 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
93 DE_NULL, // const void* pNext;
94 "appName", // const char* pAppName;
95 0u, // deUint32 appVersion;
96 engineNames[engineNameNdx], // const char* pEngineName;
97 0u, // deUint32 engineVersion;
98 VK_API_VERSION, // deUint32 apiVersion;
99 };
100
101 appInfos.push_back(appInfo);
102 }
103
104 // test over appVersion
105 for (int appVersionNdx = 0; appVersionNdx < DE_LENGTH_OF_ARRAY(appVersions); appVersionNdx++)
106 {
107 const VkApplicationInfo appInfo =
108 {
109 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
110 DE_NULL, // const void* pNext;
111 "appName", // const char* pAppName;
112 appVersions[appVersionNdx], // deUint32 appVersion;
113 "engineName", // const char* pEngineName;
114 0u, // deUint32 engineVersion;
115 VK_API_VERSION, // deUint32 apiVersion;
116 };
117
118 appInfos.push_back(appInfo);
119 }
120
121 // test over engineVersion
122 for (int engineVersionNdx = 0; engineVersionNdx < DE_LENGTH_OF_ARRAY(engineVersions); engineVersionNdx++)
123 {
124 const VkApplicationInfo appInfo =
125 {
126 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
127 DE_NULL, // const void* pNext;
128 "appName", // const char* pAppName;
129 0u, // deUint32 appVersion;
130 "engineName", // const char* pEngineName;
131 engineVersions[engineVersionNdx], // deUint32 engineVersion;
132 VK_API_VERSION, // deUint32 apiVersion;
133 };
134
135 appInfos.push_back(appInfo);
136 }
137 // patch component of api version checking (should be ignored by implementation)
138 for (int patchVersion = 0; patchVersion < DE_LENGTH_OF_ARRAY(patchNumbers); patchVersion++)
139 {
140 const VkApplicationInfo appInfo =
141 {
142 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
143 DE_NULL, // const void* pNext;
144 "appName", // const char* pAppName;
145 0u, // deUint32 appVersion;
146 "engineName", // const char* pEngineName;
147 0u, // deUint32 engineVersion;
148 VK_MAKE_VERSION(1, 0, patchNumbers[patchVersion]), // deUint32 apiVersion;
149 };
150
151 appInfos.push_back(appInfo);
152 }
153
154 // test when apiVersion is 0
155 {
156 const VkApplicationInfo appInfo =
157 {
158 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
159 DE_NULL, // const void* pNext;
160 "appName", // const char* pAppName;
161 0u, // deUint32 appVersion;
162 "engineName", // const char* pEngineName;
163 0u, // deUint32 engineVersion;
164 0u, // deUint32 apiVersion;
165 };
166
167 appInfos.push_back(appInfo);
168 }
169
170 // run the tests!
171 for (size_t appInfoNdx = 0; appInfoNdx < appInfos.size(); ++appInfoNdx)
172 {
173 const VkApplicationInfo& appInfo = appInfos[appInfoNdx];
174 const VkInstanceCreateInfo instanceCreateInfo =
175 {
176 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
177 DE_NULL, // const void* pNext;
178 (VkInstanceCreateFlags)0u, // VkInstanceCreateFlags flags;
179 &appInfo, // const VkApplicationInfo* pAppInfo;
180 0u, // deUint32 layerCount;
181 DE_NULL, // const char*const* ppEnabledLayernames;
182 0u, // deUint32 extensionCount;
183 DE_NULL, // const char*const* ppEnabledExtensionNames;
184 };
185
186 log << TestLog::Message << "Creating instance with appInfo: " << appInfo << TestLog::EndMessage;
187
188 try
189 {
190 const Unique<VkInstance> instance(createInstance(platformInterface, &instanceCreateInfo));
191 log << TestLog::Message << "Succeeded" << TestLog::EndMessage;
192 }
193 catch (const vk::Error& err)
194 {
195 resultCollector.fail("Failed, Error code: " + de::toString(err.getMessage()));
196 }
197 }
198
199 return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
200 }
201
createInstanceWithInvalidApiVersionTest(Context & context)202 tcu::TestStatus createInstanceWithInvalidApiVersionTest (Context& context)
203 {
204 tcu::TestLog& log = context.getTestContext().getLog();
205 tcu::ResultCollector resultCollector (log);
206 const PlatformInterface& platformInterface = context.getPlatformInterface();
207 const ApiVersion apiVersion = unpackVersion(VK_API_VERSION);
208 const deUint32 invalidMajorVersion = (1 << 10) - 1;
209 const deUint32 invalidMinorVersion = (1 << 10) - 1;
210 vector<ApiVersion> invalidApiVersions;
211
212 invalidApiVersions.push_back(ApiVersion(invalidMajorVersion, apiVersion.minorNum, apiVersion.patchNum));
213 invalidApiVersions.push_back(ApiVersion(apiVersion.majorNum, invalidMinorVersion, apiVersion.patchNum));
214
215 for (size_t apiVersionNdx = 0; apiVersionNdx < invalidApiVersions.size(); apiVersionNdx++)
216 {
217 const VkApplicationInfo appInfo =
218 {
219 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
220 DE_NULL, // const void* pNext;
221 "appName", // const char* pAppName;
222 0u, // deUint32 appVersion;
223 "engineName", // const char* pEngineName;
224 0u, // deUint32 engineVersion;
225 pack(invalidApiVersions[apiVersionNdx]), // deUint32 apiVersion;
226 };
227 const VkInstanceCreateInfo instanceCreateInfo =
228 {
229 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
230 DE_NULL, // const void* pNext;
231 (VkInstanceCreateFlags)0u, // VkInstanceCreateFlags flags;
232 &appInfo, // const VkApplicationInfo* pAppInfo;
233 0u, // deUint32 layerCount;
234 DE_NULL, // const char*const* ppEnabledLayernames;
235 0u, // deUint32 extensionCount;
236 DE_NULL, // const char*const* ppEnabledExtensionNames;
237 };
238
239
240 log << TestLog::Message
241 <<"VK_API_VERSION defined in vulkan.h: " << apiVersion
242 << ", api version used to create instance: " << invalidApiVersions[apiVersionNdx]
243 << TestLog::EndMessage;
244
245 {
246 VkInstance instance = (VkInstance)0;
247 const VkResult result = platformInterface.createInstance(&instanceCreateInfo, DE_NULL/*pAllocator*/, &instance);
248 const bool gotInstance = !!instance;
249
250 if (instance)
251 {
252 const InstanceDriver instanceIface (platformInterface, instance);
253 instanceIface.destroyInstance(instance, DE_NULL/*pAllocator*/);
254 }
255
256 if (result == VK_ERROR_INCOMPATIBLE_DRIVER)
257 {
258 TCU_CHECK(!gotInstance);
259 log << TestLog::Message << "Pass, instance creation with invalid apiVersion is rejected" << TestLog::EndMessage;
260 }
261 else
262 resultCollector.fail("Fail, instance creation with invalid apiVersion is not rejected");
263 }
264 }
265
266 return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
267 }
268
createInstanceWithNullApplicationInfoTest(Context & context)269 tcu::TestStatus createInstanceWithNullApplicationInfoTest (Context& context)
270 {
271 tcu::TestLog& log = context.getTestContext().getLog();
272 tcu::ResultCollector resultCollector (log);
273 const PlatformInterface& platformInterface = context.getPlatformInterface();
274
275 const VkInstanceCreateInfo instanceCreateInfo =
276 {
277 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
278 DE_NULL, // const void* pNext;
279 (VkInstanceCreateFlags)0u, // VkInstanceCreateFlags flags;
280 DE_NULL, // const VkApplicationInfo* pAppInfo;
281 0u, // deUint32 layerCount;
282 DE_NULL, // const char*const* ppEnabledLayernames;
283 0u, // deUint32 extensionCount;
284 DE_NULL, // const char*const* ppEnabledExtensionNames;
285 };
286
287 log << TestLog::Message << "Creating instance with NULL pApplicationInfo" << TestLog::EndMessage;
288
289 try
290 {
291 const Unique<VkInstance> instance(createInstance(platformInterface, &instanceCreateInfo));
292 log << TestLog::Message << "Succeeded" << TestLog::EndMessage;
293 }
294 catch (const vk::Error& err)
295 {
296 resultCollector.fail("Failed, Error code: " + de::toString(err.getMessage()));
297 }
298
299 return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
300 }
301
createInstanceWithUnsupportedExtensionsTest(Context & context)302 tcu::TestStatus createInstanceWithUnsupportedExtensionsTest (Context& context)
303 {
304 tcu::TestLog& log = context.getTestContext().getLog();
305 const PlatformInterface& platformInterface = context.getPlatformInterface();
306 const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION"};
307 const VkApplicationInfo appInfo =
308 {
309 VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
310 DE_NULL, // const void* pNext;
311 "appName", // const char* pAppName;
312 0u, // deUint32 appVersion;
313 "engineName", // const char* pEngineName;
314 0u, // deUint32 engineVersion;
315 VK_API_VERSION, // deUint32 apiVersion;
316 };
317 const VkInstanceCreateInfo instanceCreateInfo =
318 {
319 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
320 DE_NULL, // const void* pNext;
321 (VkInstanceCreateFlags)0u, // VkInstanceCreateFlags flags;
322 &appInfo, // const VkApplicationInfo* pAppInfo;
323 0u, // deUint32 layerCount;
324 DE_NULL, // const char*const* ppEnabledLayernames;
325 DE_LENGTH_OF_ARRAY(enabledExtensions), // deUint32 extensionCount;
326 enabledExtensions, // const char*const* ppEnabledExtensionNames;
327 };
328
329 log << TestLog::Message << "Enabled extensions are: " << TestLog::EndMessage;
330
331 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(enabledExtensions); ndx++)
332 log << TestLog::Message << enabledExtensions[ndx] << TestLog::EndMessage;
333
334 {
335 VkInstance instance = (VkInstance)0;
336 const VkResult result = platformInterface.createInstance(&instanceCreateInfo, DE_NULL/*pAllocator*/, &instance);
337 const bool gotInstance = !!instance;
338
339 if (instance)
340 {
341 const InstanceDriver instanceIface (platformInterface, instance);
342 instanceIface.destroyInstance(instance, DE_NULL/*pAllocator*/);
343 }
344
345 if (result == VK_ERROR_EXTENSION_NOT_PRESENT)
346 {
347 TCU_CHECK(!gotInstance);
348 return tcu::TestStatus::pass("Pass, creating instance with unsupported extension was rejected.");
349 }
350 else
351 return tcu::TestStatus::fail("Fail, creating instance with unsupported extensions succeeded.");
352 }
353 }
354
createDeviceTest(Context & context)355 tcu::TestStatus createDeviceTest (Context& context)
356 {
357 const PlatformInterface& platformInterface = context.getPlatformInterface();
358 const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
359 const InstanceDriver instanceDriver (platformInterface, instance.get());
360 const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
361 const deUint32 queueFamilyIndex = 0;
362 const deUint32 queueCount = 1;
363 const deUint32 queueIndex = 0;
364 const float queuePriority = 1.0f;
365 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
366 {
367 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
368 DE_NULL,
369 (VkDeviceQueueCreateFlags)0u,
370 queueFamilyIndex, //queueFamilyIndex;
371 queueCount, //queueCount;
372 &queuePriority, //pQueuePriorities;
373 };
374 const VkDeviceCreateInfo deviceCreateInfo =
375 {
376 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
377 DE_NULL, //pNext;
378 (VkDeviceCreateFlags)0u,
379 1, //queueRecordCount;
380 &deviceQueueCreateInfo, //pRequestedQueues;
381 0, //layerCount;
382 DE_NULL, //ppEnabledLayerNames;
383 0, //extensionCount;
384 DE_NULL, //ppEnabledExtensionNames;
385 DE_NULL, //pEnabledFeatures;
386 };
387
388 const Unique<VkDevice> device (createDevice(instanceDriver, physicalDevice, &deviceCreateInfo));
389 const DeviceDriver deviceDriver (instanceDriver, device.get());
390 VkQueue queue;
391
392 deviceDriver.getDeviceQueue(device.get(), queueFamilyIndex, queueIndex, &queue);
393 VK_CHECK(deviceDriver.queueWaitIdle(queue));
394
395 return tcu::TestStatus::pass("Pass");
396 }
397
createMultipleDevicesTest(Context & context)398 tcu::TestStatus createMultipleDevicesTest (Context& context)
399 {
400 tcu::TestLog& log = context.getTestContext().getLog();
401 tcu::ResultCollector resultCollector (log);
402 const int numDevices = 5;
403 const PlatformInterface& platformInterface = context.getPlatformInterface();
404 const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
405 const InstanceDriver instanceDriver (platformInterface, instance.get());
406 const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
407 const deUint32 queueFamilyIndex = 0;
408 const deUint32 queueCount = 1;
409 const deUint32 queueIndex = 0;
410 const float queuePriority = 1.0f;
411 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
412 {
413 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
414 DE_NULL,
415 (VkDeviceQueueCreateFlags)0u, //flags;
416 queueFamilyIndex, //queueFamilyIndex;
417 queueCount, //queueCount;
418 &queuePriority, //pQueuePriorities;
419 };
420 const VkDeviceCreateInfo deviceCreateInfo =
421 {
422 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
423 DE_NULL, //pNext;
424 (VkDeviceCreateFlags)0u,
425 1, //queueRecordCount;
426 &deviceQueueCreateInfo, //pRequestedQueues;
427 0, //layerCount;
428 DE_NULL, //ppEnabledLayerNames;
429 0, //extensionCount;
430 DE_NULL, //ppEnabledExtensionNames;
431 DE_NULL, //pEnabledFeatures;
432 };
433 vector<VkDevice> devices(numDevices, (VkDevice)DE_NULL);
434
435 try
436 {
437 for (int deviceNdx = 0; deviceNdx < numDevices; deviceNdx++)
438 {
439 const VkResult result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &devices[deviceNdx]);
440
441 if (result != VK_SUCCESS)
442 {
443 resultCollector.fail("Failed to create Device No." + de::toString(deviceNdx) + ", Error Code: " + de::toString(result));
444 break;
445 }
446
447 {
448 const DeviceDriver deviceDriver(instanceDriver, devices[deviceNdx]);
449 VkQueue queue;
450
451 DE_ASSERT(queueIndex < queueCount);
452 deviceDriver.getDeviceQueue(devices[deviceNdx], queueFamilyIndex, queueIndex, &queue);
453 VK_CHECK(deviceDriver.queueWaitIdle(queue));
454 }
455 }
456 }
457 catch (const vk::Error& error)
458 {
459 resultCollector.fail(de::toString(error.getError()));
460 }
461 catch (...)
462 {
463 for (int deviceNdx = (int)devices.size()-1; deviceNdx >= 0; deviceNdx--)
464 {
465 if (devices[deviceNdx] != (VkDevice)DE_NULL)
466 {
467 DeviceDriver deviceDriver(instanceDriver, devices[deviceNdx]);
468 deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
469 }
470 }
471
472 throw;
473 }
474
475 for (int deviceNdx = (int)devices.size()-1; deviceNdx >= 0; deviceNdx--)
476 {
477 if (devices[deviceNdx] != (VkDevice)DE_NULL)
478 {
479 DeviceDriver deviceDriver(instanceDriver, devices[deviceNdx]);
480 deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
481 }
482 }
483
484 return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
485 }
486
createDeviceWithUnsupportedExtensionsTest(Context & context)487 tcu::TestStatus createDeviceWithUnsupportedExtensionsTest (Context& context)
488 {
489 tcu::TestLog& log = context.getTestContext().getLog();
490 const PlatformInterface& platformInterface = context.getPlatformInterface();
491 const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
492 const InstanceDriver instanceDriver (platformInterface, instance.get());
493 const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION", "VK_DONT_SUPPORT_ME"};
494 const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
495 const float queuePriority = 1.0f;
496 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
497 {
498 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
499 DE_NULL,
500 (VkDeviceQueueCreateFlags)0u,
501 0, //queueFamiliIndex;
502 1, //queueCount;
503 &queuePriority, //pQueuePriorities;
504 };
505 const VkDeviceCreateInfo deviceCreateInfo =
506 {
507 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
508 DE_NULL, //pNext;
509 (VkDeviceCreateFlags)0u,
510 1, //queueRecordCount;
511 &deviceQueueCreateInfo, //pRequestedQueues;
512 0, //layerCount;
513 DE_NULL, //ppEnabledLayerNames;
514 DE_LENGTH_OF_ARRAY(enabledExtensions), //extensionCount;
515 enabledExtensions, //ppEnabledExtensionNames;
516 DE_NULL, //pEnabledFeatures;
517 };
518
519 log << TestLog::Message << "Enabled extensions are: " << TestLog::EndMessage;
520
521 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(enabledExtensions); ndx++)
522 log << TestLog::Message << enabledExtensions[ndx] << TestLog::EndMessage;
523
524 {
525 VkDevice device = (VkDevice)0;
526 const VkResult result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &device);
527 const bool gotDevice = !!device;
528
529 if (device)
530 {
531 const DeviceDriver deviceIface (instanceDriver, device);
532 deviceIface.destroyDevice(device, DE_NULL/*pAllocator*/);
533 }
534
535 if (result == VK_ERROR_EXTENSION_NOT_PRESENT)
536 {
537 TCU_CHECK(!gotDevice);
538 return tcu::TestStatus::pass("Pass, create device with unsupported extension is rejected.");
539 }
540 else
541 return tcu::TestStatus::fail("Fail, create device with unsupported extension but succeed.");
542 }
543 }
544
getGlobalMaxQueueCount(const vector<VkQueueFamilyProperties> & queueFamilyProperties)545 deUint32 getGlobalMaxQueueCount(const vector<VkQueueFamilyProperties>& queueFamilyProperties)
546 {
547 deUint32 maxQueueCount = 0;
548
549 for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < (deUint32)queueFamilyProperties.size(); queueFamilyNdx++)
550 {
551 maxQueueCount = de::max(maxQueueCount, queueFamilyProperties[queueFamilyNdx].queueCount);
552 }
553
554 return maxQueueCount;
555 }
556
createDeviceWithVariousQueueCountsTest(Context & context)557 tcu::TestStatus createDeviceWithVariousQueueCountsTest (Context& context)
558 {
559 tcu::TestLog& log = context.getTestContext().getLog();
560 const int queueCountDiff = 1;
561 const PlatformInterface& platformInterface = context.getPlatformInterface();
562 const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
563 const InstanceDriver instanceDriver (platformInterface, instance.get());
564 const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
565 const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
566 const vector<float> queuePriorities (getGlobalMaxQueueCount(queueFamilyProperties), 1.0f);
567 vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
568
569 for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < (deUint32)queueFamilyProperties.size(); queueFamilyNdx++)
570 {
571 const deUint32 maxQueueCount = queueFamilyProperties[queueFamilyNdx].queueCount;
572
573 for (deUint32 queueCount = 1; queueCount <= maxQueueCount; queueCount += queueCountDiff)
574 {
575 const VkDeviceQueueCreateInfo queueCreateInfo =
576 {
577 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
578 DE_NULL,
579 (VkDeviceQueueCreateFlags)0u,
580 queueFamilyNdx,
581 queueCount,
582 queuePriorities.data()
583 };
584
585 deviceQueueCreateInfos.push_back(queueCreateInfo);
586 }
587 }
588
589 for (size_t testNdx = 0; testNdx < deviceQueueCreateInfos.size(); testNdx++)
590 {
591 const VkDeviceQueueCreateInfo& queueCreateInfo = deviceQueueCreateInfos[testNdx];
592 const VkDeviceCreateInfo deviceCreateInfo =
593 {
594 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
595 DE_NULL, //pNext;
596 (VkDeviceCreateFlags)0u,
597 1, //queueRecordCount;
598 &queueCreateInfo, //pRequestedQueues;
599 0, //layerCount;
600 DE_NULL, //ppEnabledLayerNames;
601 0, //extensionCount;
602 DE_NULL, //ppEnabledExtensionNames;
603 DE_NULL, //pEnabledFeatures;
604 };
605 const Unique<VkDevice> device (createDevice(instanceDriver, physicalDevice, &deviceCreateInfo));
606 const DeviceDriver deviceDriver (instanceDriver, device.get());
607 const deUint32 queueFamilyIndex = deviceCreateInfo.pQueueCreateInfos->queueFamilyIndex;
608 const deUint32 queueCount = deviceCreateInfo.pQueueCreateInfos->queueCount;
609
610 for (deUint32 queueIndex = 0; queueIndex < queueCount; queueIndex++)
611 {
612 VkQueue queue;
613 VkResult result;
614
615 deviceDriver.getDeviceQueue(device.get(), queueFamilyIndex, queueIndex, &queue);
616 TCU_CHECK(!!queue);
617
618 result = deviceDriver.queueWaitIdle(queue);
619 if (result != VK_SUCCESS)
620 {
621 log << TestLog::Message
622 << "vkQueueWaitIdle failed"
623 << ", queueIndex = " << queueIndex
624 << ", queueCreateInfo " << queueCreateInfo
625 << ", Error Code: " << result
626 << TestLog::EndMessage;
627 return tcu::TestStatus::fail("Fail");
628 }
629 }
630 }
631 return tcu::TestStatus::pass("Pass");
632 }
633
createInstanceWithExtension(const PlatformInterface & vkp,const char * extensionName)634 Move<VkInstance> createInstanceWithExtension (const PlatformInterface& vkp, const char* extensionName)
635 {
636 const vector<VkExtensionProperties> instanceExts = enumerateInstanceExtensionProperties(vkp, DE_NULL);
637 vector<string> enabledExts;
638
639 if (!isExtensionSupported(instanceExts, RequiredExtension(extensionName)))
640 TCU_THROW(NotSupportedError, (string(extensionName) + " is not supported").c_str());
641
642 enabledExts.push_back(extensionName);
643
644 return createDefaultInstance(vkp, vector<string>() /* layers */, enabledExts);
645 }
646
createDeviceFeatures2Test(Context & context)647 tcu::TestStatus createDeviceFeatures2Test (Context& context)
648 {
649 const PlatformInterface& vkp = context.getPlatformInterface();
650 const Unique<VkInstance> instance (createInstanceWithExtension(vkp, "VK_KHR_get_physical_device_properties2"));
651 const InstanceDriver vki (vkp, instance.get());
652 const VkPhysicalDevice physicalDevice = chooseDevice(vki, instance.get(), context.getTestContext().getCommandLine());
653 const deUint32 queueFamilyIndex = 0;
654 const deUint32 queueCount = 1;
655 const deUint32 queueIndex = 0;
656 const float queuePriority = 1.0f;
657
658 VkPhysicalDeviceFeatures2KHR enabledFeatures;
659 const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
660 {
661 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
662 DE_NULL,
663 (VkDeviceQueueCreateFlags)0u,
664 queueFamilyIndex,
665 queueCount,
666 &queuePriority,
667 };
668 const VkDeviceCreateInfo deviceCreateInfo =
669 {
670 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
671 &enabledFeatures,
672 (VkDeviceCreateFlags)0u,
673 1,
674 &deviceQueueCreateInfo,
675 0,
676 DE_NULL,
677 0,
678 DE_NULL,
679 DE_NULL,
680 };
681
682 // Populate enabledFeatures
683 enabledFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
684 enabledFeatures.pNext = DE_NULL;
685
686 vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &enabledFeatures);
687
688 {
689 const Unique<VkDevice> device (createDevice(vki, physicalDevice, &deviceCreateInfo));
690 const DeviceDriver vkd (vki, device.get());
691 VkQueue queue;
692
693 vkd.getDeviceQueue(device.get(), queueFamilyIndex, queueIndex, &queue);
694 VK_CHECK(vkd.queueWaitIdle(queue));
695 }
696
697 return tcu::TestStatus::pass("Pass");
698 }
699
700 } // anonymous
701
createDeviceInitializationTests(tcu::TestContext & testCtx)702 tcu::TestCaseGroup* createDeviceInitializationTests (tcu::TestContext& testCtx)
703 {
704 de::MovePtr<tcu::TestCaseGroup> deviceInitializationTests (new tcu::TestCaseGroup(testCtx, "device_init", "Device Initialization Tests"));
705
706 addFunctionCase(deviceInitializationTests.get(), "create_instance_name_version", "", createInstanceTest);
707 addFunctionCase(deviceInitializationTests.get(), "create_instance_invalid_api_version", "", createInstanceWithInvalidApiVersionTest);
708 addFunctionCase(deviceInitializationTests.get(), "create_instance_null_appinfo", "", createInstanceWithNullApplicationInfoTest);
709 addFunctionCase(deviceInitializationTests.get(), "create_instance_unsupported_extensions", "", createInstanceWithUnsupportedExtensionsTest);
710 addFunctionCase(deviceInitializationTests.get(), "create_device", "", createDeviceTest);
711 addFunctionCase(deviceInitializationTests.get(), "create_multiple_devices", "", createMultipleDevicesTest);
712 addFunctionCase(deviceInitializationTests.get(), "create_device_unsupported_extensions", "", createDeviceWithUnsupportedExtensionsTest);
713 addFunctionCase(deviceInitializationTests.get(), "create_device_various_queue_counts", "", createDeviceWithVariousQueueCountsTest);
714 addFunctionCase(deviceInitializationTests.get(), "create_device_features2", "", createDeviceFeatures2Test);
715
716 return deviceInitializationTests.release();
717 }
718
719 } // api
720 } // vkt
721