1
2 /*------------------------------------------------------------------------
3 * Vulkan Conformance Tests
4 * ------------------------
5 *
6 * Copyright (c) 2020 The Khronos Group Inc.
7 * Copyright (c) 2020 Google LLC
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief VK_EXT_device_address_binding_report extension tests.
24 *//*--------------------------------------------------------------------*/
25
26 #include "vktMemoryAddressBindingTests.hpp"
27
28 #include "vktCustomInstancesDevices.hpp"
29 #include "vktExternalMemoryUtil.hpp"
30 #include "vktTestCaseUtil.hpp"
31
32 #include "vkDeviceUtil.hpp"
33 #include "vkObjUtil.hpp"
34 #include "vkQueryUtil.hpp"
35 #include "vkRefUtil.hpp"
36 #include "vkTypeUtil.hpp"
37
38 #include "tcuCommandLine.hpp"
39 #include "tcuTestCase.hpp"
40 #include "tcuTestLog.hpp"
41
42 #include "deSharedPtr.hpp"
43
44 #include <set>
45 #include <vector>
46 #include <limits>
47
48 #define UNUSED(expr) \
49 do \
50 { \
51 (void)(expr); \
52 } while (0)
53
54 namespace vkt
55 {
56
57 namespace memory
58 {
59
60 namespace
61 {
62
63 #define VK_DESCRIPTOR_TYPE_LAST (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT + 1)
64
65 using namespace vk;
66 using namespace vkt::ExternalMemoryUtil;
67 using de::MovePtr;
68 using de::SharedPtr;
69
70 struct BindingData
71 {
72 VkDeviceAddress bindingAddress;
73 VkDeviceSize size;
74 VkDeviceAddressBindingTypeEXT bindingType;
75 uint64_t objectHandle;
76
operator ==vkt::memory::__anon2675d53f0111::BindingData77 bool operator==(const BindingData &rhs) const
78 {
79 if (bindingAddress != rhs.bindingAddress)
80 return false;
81
82 if (size != rhs.size)
83 return false;
84
85 if (objectHandle != rhs.objectHandle)
86 return false;
87
88 return true;
89 }
90 };
91
92 class BindingCallbackRecorder
93 {
94 public:
BindingCallbackRecorder(void)95 BindingCallbackRecorder(void)
96 {
97 }
98 ~BindingCallbackRecorder(void) = default;
99
100 typedef std::vector<BindingData>::const_iterator RecordIterator;
101
getRecordsBegin(void) const102 RecordIterator getRecordsBegin(void) const
103 {
104 return mRecords.begin();
105 }
106
getRecordsEnd(void) const107 RecordIterator getRecordsEnd(void) const
108 {
109 return mRecords.end();
110 }
111
getNumRecords(void) const112 std::size_t getNumRecords(void) const
113 {
114 return mRecords.size();
115 }
116
callbackInternal(const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData)117 void callbackInternal(const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
118 {
119 const VkDeviceAddressBindingCallbackDataEXT *bindingCallbackData =
120 static_cast<const VkDeviceAddressBindingCallbackDataEXT *>(pCallbackData->pNext);
121
122 const BindingData bindingData = {bindingCallbackData->baseAddress, bindingCallbackData->size,
123 bindingCallbackData->bindingType, pCallbackData->pObjects[0].objectHandle};
124
125 mRecords.emplace_back(bindingData);
126 }
127
callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageType,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData,void * pUserData)128 static VKAPI_ATTR VkBool32 VKAPI_CALL callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
129 VkDebugUtilsMessageTypeFlagsEXT messageType,
130 const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
131 void *pUserData)
132 {
133 UNUSED(messageSeverity);
134
135 if (messageType == VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT)
136 {
137 reinterpret_cast<BindingCallbackRecorder *>(pUserData)->callbackInternal(pCallbackData);
138 }
139 return VK_FALSE;
140 }
141
142 private:
143 typedef std::vector<BindingData> Records;
144
145 Records mRecords;
146 };
147
148 struct Environment
149 {
150 const PlatformInterface &vkp;
151 const InstanceInterface &vki;
152 VkInstance instance;
153 VkPhysicalDevice physicalDevice;
154 const DeviceInterface &vkd;
155 VkDevice device;
156 uint32_t queueFamilyIndex;
157 const BinaryCollection &programBinaries;
158 uint32_t usedApiVersion;
159 const tcu::CommandLine &commandLine;
160 const BindingCallbackRecorder *recorder;
161
Environmentvkt::memory::__anon2675d53f0111::Environment162 Environment(const PlatformInterface &vkp_, const InstanceInterface &vki_, VkInstance instance_,
163 VkPhysicalDevice physicalDevice_, const DeviceInterface &vkd_, VkDevice device_,
164 uint32_t queueFamilyIndex_, const BinaryCollection &programBinaries_, uint32_t usedApiVersion_,
165 const tcu::CommandLine &commandLine_, const BindingCallbackRecorder *recorder_)
166 : vkp(vkp_)
167 , vki(vki_)
168 , instance(instance_)
169 , physicalDevice(physicalDevice_)
170 , vkd(vkd_)
171 , device(device_)
172 , queueFamilyIndex(queueFamilyIndex_)
173 , programBinaries(programBinaries_)
174 , usedApiVersion(usedApiVersion_)
175 , commandLine(commandLine_)
176 , recorder(recorder_)
177 {
178 }
179 };
180
181 template <typename Case>
182 struct Dependency
183 {
184 typename Case::Resources resources;
185 Unique<typename Case::Type> object;
186
Dependencyvkt::memory::__anon2675d53f0111::Dependency187 Dependency(const Environment &env, const typename Case::Parameters ¶ms)
188 : resources(env, params)
189 , object(Case::create(env, resources, params))
190 {
191 }
192 };
193
createDeviceWithAdressBindingReport(bool isValidationEnabled,const PlatformInterface & vkp,VkInstance instance,const InstanceInterface & vki,VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex)194 static Move<VkDevice> createDeviceWithAdressBindingReport(bool isValidationEnabled, const PlatformInterface &vkp,
195 VkInstance instance, const InstanceInterface &vki,
196 VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
197 {
198 const uint32_t queueCount = 1;
199 const float queuePriority = 1.0f;
200 const char *const enabledExtensions[] = {"VK_EXT_device_address_binding_report"};
201 VkPhysicalDeviceFeatures features = getPhysicalDeviceFeatures(vki, physicalDevice);
202
203 VkPhysicalDeviceAddressBindingReportFeaturesEXT deviceAddressBindingReportFeatures{
204 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, DE_NULL, VK_TRUE};
205
206 const VkPhysicalDeviceFeatures2 enabledFeatures2 = {
207 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, // VkStructureType sType;
208 &deviceAddressBindingReportFeatures, // const void* pNext;
209 features // VkPhysicalDeviceFeatures features;
210 };
211 const VkDeviceQueueCreateInfo queueCreateInfo = {
212 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
213 DE_NULL, // const void* pNext;
214 (VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
215 queueFamilyIndex, // uint32_t queueFamilyIndex;
216 queueCount, // uint32_t queueCount;
217 &queuePriority, // const float* pQueuePriorities;
218 };
219 const VkDeviceCreateInfo deviceCreateInfo = {
220 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
221 &enabledFeatures2, // const void* pNext;
222 (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
223 queueCount, // uint32_t queueCreateInfoCount;
224 &queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
225 0u, // uint32_t enabledLayerCount;
226 DE_NULL, // const char* const* ppEnabledLayerNames;
227 DE_LENGTH_OF_ARRAY(enabledExtensions), // uint32_t enabledExtensionCount;
228 DE_ARRAY_BEGIN(enabledExtensions), // const char* const* ppEnabledExtensionNames;
229 DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
230 };
231
232 return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
233 }
234
235 struct Device
236 {
237 typedef VkDevice Type;
238
239 struct Parameters
240 {
Parametersvkt::memory::__anon2675d53f0111::Device::Parameters241 Parameters(void)
242 {
243 }
244 };
245
246 struct Resources
247 {
Resourcesvkt::memory::__anon2675d53f0111::Device::Resources248 Resources(const Environment &, const Parameters &)
249 {
250 }
251 };
252
createvkt::memory::__anon2675d53f0111::Device253 static Move<VkDevice> create(const Environment &env, const Resources &, const Parameters &)
254 {
255 return createDeviceWithAdressBindingReport(env.commandLine.isValidationEnabled(), env.vkp, env.instance,
256 env.vki, env.physicalDevice, env.queueFamilyIndex);
257 }
258 };
259
260 struct DeviceMemory
261 {
262 typedef VkDeviceMemory Type;
263
264 struct Parameters
265 {
266 VkDeviceSize size;
267 uint32_t memoryTypeIndex;
268
Parametersvkt::memory::__anon2675d53f0111::DeviceMemory::Parameters269 Parameters(VkDeviceSize size_, uint32_t memoryTypeIndex_) : size(size_), memoryTypeIndex(memoryTypeIndex_)
270 {
271 DE_ASSERT(memoryTypeIndex < VK_MAX_MEMORY_TYPES);
272 }
273 };
274
275 struct Resources
276 {
Resourcesvkt::memory::__anon2675d53f0111::DeviceMemory::Resources277 Resources(const Environment &, const Parameters &)
278 {
279 }
280 };
281
createvkt::memory::__anon2675d53f0111::DeviceMemory282 static Move<VkDeviceMemory> create(const Environment &env, const Resources &, const Parameters ¶ms)
283 {
284 const VkMemoryAllocateInfo memoryAllocateInfo = {
285 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
286 DE_NULL, // const void* pNext;
287 params.size, // VkDeviceSize allocationSize;
288 params.memoryTypeIndex, // uint32_t memoryTypeIndex;
289 };
290
291 return allocateMemory(env.vkd, env.device, &memoryAllocateInfo);
292 }
293 };
294
getDeviceMemoryParameters(const VkMemoryRequirements & memReqs)295 DeviceMemory::Parameters getDeviceMemoryParameters(const VkMemoryRequirements &memReqs)
296 {
297 return DeviceMemory::Parameters(memReqs.size, deCtz32(memReqs.memoryTypeBits));
298 }
299
getDeviceMemoryParameters(const Environment & env,VkImage image)300 DeviceMemory::Parameters getDeviceMemoryParameters(const Environment &env, VkImage image)
301 {
302 return getDeviceMemoryParameters(getImageMemoryRequirements(env.vkd, env.device, image));
303 }
304
getDeviceMemoryParameters(const Environment & env,VkBuffer buffer)305 DeviceMemory::Parameters getDeviceMemoryParameters(const Environment &env, VkBuffer buffer)
306 {
307 return getDeviceMemoryParameters(getBufferMemoryRequirements(env.vkd, env.device, buffer));
308 }
309
310 struct Buffer
311 {
312 typedef VkBuffer Type;
313
314 struct Parameters
315 {
316 VkDeviceSize size;
317 VkBufferUsageFlags usage;
318
Parametersvkt::memory::__anon2675d53f0111::Buffer::Parameters319 Parameters(VkDeviceSize size_, VkBufferUsageFlags usage_) : size(size_), usage(usage_)
320 {
321 }
322 };
323
324 struct Resources
325 {
Resourcesvkt::memory::__anon2675d53f0111::Buffer::Resources326 Resources(const Environment &, const Parameters &)
327 {
328 }
329 };
330
createvkt::memory::__anon2675d53f0111::Buffer331 static Move<VkBuffer> create(const Environment &env, const Resources &, const Parameters ¶ms)
332 {
333 const VkBufferCreateInfo bufferCreateInfo = {
334 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
335 DE_NULL, // const void* pNext;
336 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
337 params.size, // VkDeviceSize size;
338 params.usage, // VkBufferUsageFlags usage;
339 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
340 1u, // uint32_t queueFamilyIndexCount;
341 &env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
342 };
343
344 return createBuffer(env.vkd, env.device, &bufferCreateInfo);
345 }
346 };
347
348 struct BufferView
349 {
350 typedef VkBufferView Type;
351
352 struct Parameters
353 {
354 Buffer::Parameters buffer;
355 VkFormat format;
356 VkDeviceSize offset;
357 VkDeviceSize range;
358
Parametersvkt::memory::__anon2675d53f0111::BufferView::Parameters359 Parameters(const Buffer::Parameters &buffer_, VkFormat format_, VkDeviceSize offset_, VkDeviceSize range_)
360 : buffer(buffer_)
361 , format(format_)
362 , offset(offset_)
363 , range(range_)
364 {
365 }
366 };
367
368 struct Resources
369 {
370 Dependency<Buffer> buffer;
371 Dependency<DeviceMemory> memory;
372
Resourcesvkt::memory::__anon2675d53f0111::BufferView::Resources373 Resources(const Environment &env, const Parameters ¶ms)
374 : buffer(env, params.buffer)
375 , memory(env, getDeviceMemoryParameters(env, *buffer.object))
376 {
377 VK_CHECK(env.vkd.bindBufferMemory(env.device, *buffer.object, *memory.object, 0));
378 }
379 };
380
createvkt::memory::__anon2675d53f0111::BufferView381 static Move<VkBufferView> create(const Environment &env, const Resources &res, const Parameters ¶ms)
382 {
383 const VkBufferViewCreateInfo bufferViewCreateInfo = {
384 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType;
385 DE_NULL, // const void* pNext;
386 (VkBufferViewCreateFlags)0, // VkBufferViewCreateFlags flags;
387 *res.buffer.object, // VkBuffer buffer;
388 params.format, // VkFormat format;
389 params.offset, // VkDeviceSize offset;
390 params.range, // VkDeviceSize range;
391 };
392
393 return createBufferView(env.vkd, env.device, &bufferViewCreateInfo);
394 }
395 };
396
397 struct Image
398 {
399 typedef VkImage Type;
400
401 struct Parameters
402 {
403 VkImageCreateFlags flags;
404 VkImageType imageType;
405 VkFormat format;
406 VkExtent3D extent;
407 uint32_t mipLevels;
408 uint32_t arraySize;
409 VkSampleCountFlagBits samples;
410 VkImageTiling tiling;
411 VkImageUsageFlags usage;
412 VkImageLayout initialLayout;
413
Parametersvkt::memory::__anon2675d53f0111::Image::Parameters414 Parameters(VkImageCreateFlags flags_, VkImageType imageType_, VkFormat format_, VkExtent3D extent_,
415 uint32_t mipLevels_, uint32_t arraySize_, VkSampleCountFlagBits samples_, VkImageTiling tiling_,
416 VkImageUsageFlags usage_, VkImageLayout initialLayout_)
417 : flags(flags_)
418 , imageType(imageType_)
419 , format(format_)
420 , extent(extent_)
421 , mipLevels(mipLevels_)
422 , arraySize(arraySize_)
423 , samples(samples_)
424 , tiling(tiling_)
425 , usage(usage_)
426 , initialLayout(initialLayout_)
427 {
428 }
429 };
430
431 struct Resources
432 {
Resourcesvkt::memory::__anon2675d53f0111::Image::Resources433 Resources(const Environment &, const Parameters &)
434 {
435 }
436 };
437
createvkt::memory::__anon2675d53f0111::Image438 static Move<VkImage> create(const Environment &env, const Resources &, const Parameters ¶ms)
439 {
440 const VkImageCreateInfo imageCreateInfo = {
441 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
442 DE_NULL, // const void* pNext;
443 params.flags, // VkImageCreateFlags flags;
444 params.imageType, // VkImageType imageType;
445 params.format, // VkFormat format;
446 params.extent, // VkExtent3D extent;
447 params.mipLevels, // uint32_t mipLevels;
448 params.arraySize, // uint32_t arrayLayers;
449 params.samples, // VkSampleCountFlagBits samples;
450 params.tiling, // VkImageTiling tiling;
451 params.usage, // VkImageUsageFlags usage;
452 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
453 1u, // uint32_t queueFamilyIndexCount;
454 &env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
455 params.initialLayout, // VkImageLayout initialLayout;
456 };
457
458 return createImage(env.vkd, env.device, &imageCreateInfo);
459 }
460 };
461
462 struct ImageView
463 {
464 typedef VkImageView Type;
465
466 struct Parameters
467 {
468 Image::Parameters image;
469 VkImageViewType viewType;
470 VkFormat format;
471 VkComponentMapping components;
472 VkImageSubresourceRange subresourceRange;
473
Parametersvkt::memory::__anon2675d53f0111::ImageView::Parameters474 Parameters(const Image::Parameters &image_, VkImageViewType viewType_, VkFormat format_,
475 VkComponentMapping components_, VkImageSubresourceRange subresourceRange_)
476 : image(image_)
477 , viewType(viewType_)
478 , format(format_)
479 , components(components_)
480 , subresourceRange(subresourceRange_)
481 {
482 }
483 };
484
485 struct Resources
486 {
487 Dependency<Image> image;
488 Dependency<DeviceMemory> memory;
489
Resourcesvkt::memory::__anon2675d53f0111::ImageView::Resources490 Resources(const Environment &env, const Parameters ¶ms)
491 : image(env, params.image)
492 , memory(env, getDeviceMemoryParameters(env, *image.object))
493 {
494 VK_CHECK(env.vkd.bindImageMemory(env.device, *image.object, *memory.object, 0));
495 }
496 };
497
createvkt::memory::__anon2675d53f0111::ImageView498 static Move<VkImageView> create(const Environment &env, const Resources &res, const Parameters ¶ms)
499 {
500 const VkImageViewCreateInfo imageViewCreateInfo = {
501 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
502 DE_NULL, // const void* pNext;
503 (VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags;
504 *res.image.object, // VkImage image;
505 params.viewType, // VkImageViewType viewType;
506 params.format, // VkFormat format;
507 params.components, // VkComponentMapping components;
508 params.subresourceRange, // VkImageSubresourceRange subresourceRange;
509 };
510
511 return createImageView(env.vkd, env.device, &imageViewCreateInfo);
512 }
513 };
514
515 struct Semaphore
516 {
517 typedef VkSemaphore Type;
518
519 struct Parameters
520 {
521 VkSemaphoreCreateFlags flags;
522
Parametersvkt::memory::__anon2675d53f0111::Semaphore::Parameters523 Parameters(VkSemaphoreCreateFlags flags_) : flags(flags_)
524 {
525 }
526 };
527
528 struct Resources
529 {
Resourcesvkt::memory::__anon2675d53f0111::Semaphore::Resources530 Resources(const Environment &, const Parameters &)
531 {
532 }
533 };
534
createvkt::memory::__anon2675d53f0111::Semaphore535 static Move<VkSemaphore> create(const Environment &env, const Resources &, const Parameters ¶ms)
536 {
537 const VkSemaphoreCreateInfo semaphoreCreateInfo = {
538 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType;
539 DE_NULL, // const void* pNext;
540 params.flags, // VkSemaphoreCreateFlags flags;
541 };
542
543 return createSemaphore(env.vkd, env.device, &semaphoreCreateInfo);
544 }
545 };
546
547 struct Fence
548 {
549 typedef VkFence Type;
550
551 struct Parameters
552 {
553 VkFenceCreateFlags flags;
554
Parametersvkt::memory::__anon2675d53f0111::Fence::Parameters555 Parameters(VkFenceCreateFlags flags_) : flags(flags_)
556 {
557 }
558 };
559
560 struct Resources
561 {
Resourcesvkt::memory::__anon2675d53f0111::Fence::Resources562 Resources(const Environment &, const Parameters &)
563 {
564 }
565 };
566
createvkt::memory::__anon2675d53f0111::Fence567 static Move<VkFence> create(const Environment &env, const Resources &, const Parameters ¶ms)
568 {
569 const VkFenceCreateInfo fenceCreateInfo = {
570 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
571 DE_NULL, // const void* pNext;
572 params.flags, // VkFenceCreateFlags flags;
573 };
574
575 return createFence(env.vkd, env.device, &fenceCreateInfo);
576 }
577 };
578
579 struct Event
580 {
581 typedef VkEvent Type;
582
583 struct Parameters
584 {
585 VkEventCreateFlags flags;
586
Parametersvkt::memory::__anon2675d53f0111::Event::Parameters587 Parameters(VkEventCreateFlags flags_) : flags(flags_)
588 {
589 }
590 };
591
592 struct Resources
593 {
Resourcesvkt::memory::__anon2675d53f0111::Event::Resources594 Resources(const Environment &, const Parameters &)
595 {
596 }
597 };
598
createvkt::memory::__anon2675d53f0111::Event599 static Move<VkEvent> create(const Environment &env, const Resources &, const Parameters ¶ms)
600 {
601 const VkEventCreateInfo eventCreateInfo = {
602 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, // VkStructureType sType;
603 DE_NULL, // const void* pNext;
604 params.flags, // VkEventCreateFlags flags;
605 };
606
607 return createEvent(env.vkd, env.device, &eventCreateInfo);
608 }
609 };
610
611 struct QueryPool
612 {
613 typedef VkQueryPool Type;
614
615 struct Parameters
616 {
617 VkQueryType queryType;
618 uint32_t entryCount;
619 VkQueryPipelineStatisticFlags pipelineStatistics;
620
Parametersvkt::memory::__anon2675d53f0111::QueryPool::Parameters621 Parameters(VkQueryType queryType_, uint32_t entryCount_, VkQueryPipelineStatisticFlags pipelineStatistics_)
622 : queryType(queryType_)
623 , entryCount(entryCount_)
624 , pipelineStatistics(pipelineStatistics_)
625 {
626 }
627 };
628
629 struct Resources
630 {
Resourcesvkt::memory::__anon2675d53f0111::QueryPool::Resources631 Resources(const Environment &, const Parameters &)
632 {
633 }
634 };
635
createvkt::memory::__anon2675d53f0111::QueryPool636 static Move<VkQueryPool> create(const Environment &env, const Resources &, const Parameters ¶ms)
637 {
638 const VkQueryPoolCreateInfo queryPoolCreateInfo = {
639 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
640 DE_NULL, // const void* pNext;
641 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
642 params.queryType, // VkQueryType queryType;
643 params.entryCount, // uint32_t queryCount;
644 params.pipelineStatistics, // VkQueryPipelineStatisticFlags pipelineStatistics;
645 };
646
647 return createQueryPool(env.vkd, env.device, &queryPoolCreateInfo);
648 }
649 };
650
651 struct ShaderModule
652 {
653 typedef VkShaderModule Type;
654
655 struct Parameters
656 {
657 VkShaderStageFlagBits shaderStage;
658 std::string binaryName;
659
Parametersvkt::memory::__anon2675d53f0111::ShaderModule::Parameters660 Parameters(VkShaderStageFlagBits shaderStage_, const std::string &binaryName_)
661 : shaderStage(shaderStage_)
662 , binaryName(binaryName_)
663 {
664 }
665 };
666
667 struct Resources
668 {
669 const ProgramBinary &binary;
670
Resourcesvkt::memory::__anon2675d53f0111::ShaderModule::Resources671 Resources(const Environment &env, const Parameters ¶ms) : binary(env.programBinaries.get(params.binaryName))
672 {
673 }
674 };
675
getSourcevkt::memory::__anon2675d53f0111::ShaderModule676 static const char *getSource(VkShaderStageFlagBits stage)
677 {
678 switch (stage)
679 {
680 case VK_SHADER_STAGE_VERTEX_BIT:
681 return "#version 310 es\n"
682 "layout(location = 0) in highp vec4 a_position;\n"
683 "void main () { gl_Position = a_position; }\n";
684
685 case VK_SHADER_STAGE_FRAGMENT_BIT:
686 return "#version 310 es\n"
687 "layout(location = 0) out mediump vec4 o_color;\n"
688 "void main () { o_color = vec4(1.0, 0.5, 0.25, 1.0); }";
689
690 case VK_SHADER_STAGE_COMPUTE_BIT:
691 return "#version 310 es\n"
692 "layout(binding = 0) buffer Input { highp uint dataIn[]; };\n"
693 "layout(binding = 1) buffer Output { highp uint dataOut[]; };\n"
694 "void main (void)\n"
695 "{\n"
696 " dataOut[gl_GlobalInvocationID.x] = ~dataIn[gl_GlobalInvocationID.x];\n"
697 "}\n";
698
699 default:
700 DE_FATAL("Not implemented");
701 return DE_NULL;
702 }
703 }
704
initProgramsvkt::memory::__anon2675d53f0111::ShaderModule705 static void initPrograms(SourceCollections &dst, Parameters params)
706 {
707 const char *const source = getSource(params.shaderStage);
708
709 DE_ASSERT(source);
710
711 dst.glslSources.add(params.binaryName) << glu::ShaderSource(getGluShaderType(params.shaderStage), source);
712 }
713
createvkt::memory::__anon2675d53f0111::ShaderModule714 static Move<VkShaderModule> create(const Environment &env, const Resources &res, const Parameters &)
715 {
716 const VkShaderModuleCreateInfo shaderModuleCreateInfo = {
717 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
718 DE_NULL, // const void* pNext;
719 (VkShaderModuleCreateFlags)0, // VkShaderModuleCreateFlags flags;
720 res.binary.getSize(), // size_t codeSize;
721 (const uint32_t *)res.binary.getBinary(), // const uint32_t* pCode;
722 };
723
724 return createShaderModule(env.vkd, env.device, &shaderModuleCreateInfo);
725 }
726 };
727
728 struct PipelineCache
729 {
730 typedef VkPipelineCache Type;
731
732 struct Parameters
733 {
Parametersvkt::memory::__anon2675d53f0111::PipelineCache::Parameters734 Parameters(void)
735 {
736 }
737 };
738
739 struct Resources
740 {
Resourcesvkt::memory::__anon2675d53f0111::PipelineCache::Resources741 Resources(const Environment &, const Parameters &)
742 {
743 }
744 };
745
createvkt::memory::__anon2675d53f0111::PipelineCache746 static Move<VkPipelineCache> create(const Environment &env, const Resources &, const Parameters &)
747 {
748 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {
749 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
750 DE_NULL, // const void* pNext;
751 (VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
752 0u, // size_t initialDataSize;
753 DE_NULL, // const void* pInitialData;
754 };
755
756 return createPipelineCache(env.vkd, env.device, &pipelineCacheCreateInfo);
757 }
758 };
759
760 struct Sampler
761 {
762 typedef VkSampler Type;
763
764 struct Parameters
765 {
766 VkFilter magFilter;
767 VkFilter minFilter;
768 VkSamplerMipmapMode mipmapMode;
769 VkSamplerAddressMode addressModeU;
770 VkSamplerAddressMode addressModeV;
771 VkSamplerAddressMode addressModeW;
772 float mipLodBias;
773 VkBool32 anisotropyEnable;
774 float maxAnisotropy;
775 VkBool32 compareEnable;
776 VkCompareOp compareOp;
777 float minLod;
778 float maxLod;
779 VkBorderColor borderColor;
780 VkBool32 unnormalizedCoordinates;
781
Parametersvkt::memory::__anon2675d53f0111::Sampler::Parameters782 Parameters(void)
783 : magFilter(VK_FILTER_NEAREST)
784 , minFilter(VK_FILTER_NEAREST)
785 , mipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST)
786 , addressModeU(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
787 , addressModeV(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
788 , addressModeW(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
789 , mipLodBias(0.0f)
790 , anisotropyEnable(VK_FALSE)
791 , maxAnisotropy(1.0f)
792 , compareEnable(VK_FALSE)
793 , compareOp(VK_COMPARE_OP_ALWAYS)
794 , minLod(-1000.f)
795 , maxLod(+1000.f)
796 , borderColor(VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK)
797 , unnormalizedCoordinates(VK_FALSE)
798 {
799 }
800 };
801
802 struct Resources
803 {
Resourcesvkt::memory::__anon2675d53f0111::Sampler::Resources804 Resources(const Environment &, const Parameters &)
805 {
806 }
807 };
808
createvkt::memory::__anon2675d53f0111::Sampler809 static Move<VkSampler> create(const Environment &env, const Resources &, const Parameters ¶ms)
810 {
811 const VkSamplerCreateInfo samplerCreateInfo = {
812 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
813 DE_NULL, // const void* pNext;
814 (VkSamplerCreateFlags)0, // VkSamplerCreateFlags flags;
815 params.magFilter, // VkFilter magFilter;
816 params.minFilter, // VkFilter minFilter;
817 params.mipmapMode, // VkSamplerMipmapMode mipmapMode;
818 params.addressModeU, // VkSamplerAddressMode addressModeU;
819 params.addressModeV, // VkSamplerAddressMode addressModeV;
820 params.addressModeW, // VkSamplerAddressMode addressModeW;
821 params.mipLodBias, // float mipLodBias;
822 params.anisotropyEnable, // VkBool32 anisotropyEnable;
823 params.maxAnisotropy, // float maxAnisotropy;
824 params.compareEnable, // VkBool32 compareEnable;
825 params.compareOp, // VkCompareOp compareOp;
826 params.minLod, // float minLod;
827 params.maxLod, // float maxLod;
828 params.borderColor, // VkBorderColor borderColor;
829 params.unnormalizedCoordinates, // VkBool32 unnormalizedCoordinates;
830 };
831
832 return createSampler(env.vkd, env.device, &samplerCreateInfo);
833 }
834 };
835
836 struct DescriptorSetLayout
837 {
838 typedef VkDescriptorSetLayout Type;
839
840 struct Parameters
841 {
842 struct Binding
843 {
844 uint32_t binding;
845 VkDescriptorType descriptorType;
846 uint32_t descriptorCount;
847 VkShaderStageFlags stageFlags;
848 bool useImmutableSampler;
849
Bindingvkt::memory::__anon2675d53f0111::DescriptorSetLayout::Parameters::Binding850 Binding(uint32_t binding_, VkDescriptorType descriptorType_, uint32_t descriptorCount_,
851 VkShaderStageFlags stageFlags_, bool useImmutableSampler_)
852 : binding(binding_)
853 , descriptorType(descriptorType_)
854 , descriptorCount(descriptorCount_)
855 , stageFlags(stageFlags_)
856 , useImmutableSampler(useImmutableSampler_)
857 {
858 }
859
Bindingvkt::memory::__anon2675d53f0111::DescriptorSetLayout::Parameters::Binding860 Binding(void)
861 {
862 }
863 };
864
865 std::vector<Binding> bindings;
866
Parametersvkt::memory::__anon2675d53f0111::DescriptorSetLayout::Parameters867 Parameters(const std::vector<Binding> &bindings_) : bindings(bindings_)
868 {
869 }
870
emptyvkt::memory::__anon2675d53f0111::DescriptorSetLayout::Parameters871 static Parameters empty(void)
872 {
873 return Parameters(std::vector<Binding>());
874 }
875
singlevkt::memory::__anon2675d53f0111::DescriptorSetLayout::Parameters876 static Parameters single(uint32_t binding, VkDescriptorType descriptorType, uint32_t descriptorCount,
877 VkShaderStageFlags stageFlags, bool useImmutableSampler = false)
878 {
879 std::vector<Binding> bindings;
880 bindings.push_back(Binding(binding, descriptorType, descriptorCount, stageFlags, useImmutableSampler));
881 return Parameters(bindings);
882 }
883 };
884
885 struct Resources
886 {
887 std::vector<VkDescriptorSetLayoutBinding> bindings;
888 MovePtr<Dependency<Sampler>> immutableSampler;
889 std::vector<VkSampler> immutableSamplersPtr;
890
Resourcesvkt::memory::__anon2675d53f0111::DescriptorSetLayout::Resources891 Resources(const Environment &env, const Parameters ¶ms)
892 {
893 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin();
894 cur != params.bindings.end(); cur++)
895 {
896 if (cur->useImmutableSampler && !immutableSampler)
897 {
898 immutableSampler = de::newMovePtr<Dependency<Sampler>>(env, Sampler::Parameters());
899
900 if (cur->useImmutableSampler && immutableSamplersPtr.size() < (size_t)cur->descriptorCount)
901 immutableSamplersPtr.resize(cur->descriptorCount, *immutableSampler->object);
902 }
903 }
904
905 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin();
906 cur != params.bindings.end(); cur++)
907 {
908 const VkDescriptorSetLayoutBinding binding = {
909 cur->binding, // uint32_t binding;
910 cur->descriptorType, // VkDescriptorType descriptorType;
911 cur->descriptorCount, // uint32_t descriptorCount;
912 cur->stageFlags, // VkShaderStageFlags stageFlags;
913 (cur->useImmutableSampler ? &immutableSamplersPtr[0] :
914 DE_NULL), // const VkSampler* pImmutableSamplers;
915 };
916
917 bindings.push_back(binding);
918 }
919 }
920 };
921
createvkt::memory::__anon2675d53f0111::DescriptorSetLayout922 static Move<VkDescriptorSetLayout> create(const Environment &env, const Resources &res, const Parameters &)
923 {
924 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
925 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
926 DE_NULL, // const void* pNext;
927 (VkDescriptorSetLayoutCreateFlags)0, // VkDescriptorSetLayoutCreateFlags flags;
928 (uint32_t)res.bindings.size(), // uint32_t bindingCount;
929 (res.bindings.empty() ? DE_NULL : &res.bindings[0]), // const VkDescriptorSetLayoutBinding* pBindings;
930 };
931
932 return createDescriptorSetLayout(env.vkd, env.device, &descriptorSetLayoutCreateInfo);
933 }
934 };
935
936 struct PipelineLayout
937 {
938 typedef VkPipelineLayout Type;
939
940 struct Parameters
941 {
942 std::vector<DescriptorSetLayout::Parameters> descriptorSetLayouts;
943 std::vector<VkPushConstantRange> pushConstantRanges;
944
Parametersvkt::memory::__anon2675d53f0111::PipelineLayout::Parameters945 Parameters(void)
946 {
947 }
948
emptyvkt::memory::__anon2675d53f0111::PipelineLayout::Parameters949 static Parameters empty(void)
950 {
951 return Parameters();
952 }
953
singleDescriptorSetvkt::memory::__anon2675d53f0111::PipelineLayout::Parameters954 static Parameters singleDescriptorSet(const DescriptorSetLayout::Parameters &descriptorSetLayout)
955 {
956 Parameters params;
957 params.descriptorSetLayouts.push_back(descriptorSetLayout);
958 return params;
959 }
960 };
961
962 struct Resources
963 {
964 typedef SharedPtr<Dependency<DescriptorSetLayout>> DescriptorSetLayoutDepSp;
965 typedef std::vector<DescriptorSetLayoutDepSp> DescriptorSetLayouts;
966
967 DescriptorSetLayouts descriptorSetLayouts;
968 std::vector<VkDescriptorSetLayout> pSetLayouts;
969
Resourcesvkt::memory::__anon2675d53f0111::PipelineLayout::Resources970 Resources(const Environment &env, const Parameters ¶ms)
971 {
972 for (std::vector<DescriptorSetLayout::Parameters>::const_iterator dsParams =
973 params.descriptorSetLayouts.begin();
974 dsParams != params.descriptorSetLayouts.end(); ++dsParams)
975 {
976 descriptorSetLayouts.push_back(
977 DescriptorSetLayoutDepSp(new Dependency<DescriptorSetLayout>(env, *dsParams)));
978 pSetLayouts.push_back(*descriptorSetLayouts.back()->object);
979 }
980 }
981 };
982
createvkt::memory::__anon2675d53f0111::PipelineLayout983 static Move<VkPipelineLayout> create(const Environment &env, const Resources &res, const Parameters ¶ms)
984 {
985 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
986 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
987 DE_NULL, // const void* pNext;
988 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
989 (uint32_t)res.pSetLayouts.size(), // uint32_t setLayoutCount;
990 (res.pSetLayouts.empty() ? DE_NULL : &res.pSetLayouts[0]), // const VkDescriptorSetLayout* pSetLayouts;
991 (uint32_t)params.pushConstantRanges.size(), // uint32_t pushConstantRangeCount;
992 (params.pushConstantRanges.empty() ?
993 DE_NULL :
994 ¶ms.pushConstantRanges[0]), // const VkPushConstantRange* pPushConstantRanges;
995 };
996
997 return createPipelineLayout(env.vkd, env.device, &pipelineLayoutCreateInfo);
998 }
999 };
1000
1001 struct RenderPass
1002 {
1003 typedef VkRenderPass Type;
1004
1005 struct Parameters
1006 {
Parametersvkt::memory::__anon2675d53f0111::RenderPass::Parameters1007 Parameters(void)
1008 {
1009 }
1010 };
1011
1012 struct Resources
1013 {
Resourcesvkt::memory::__anon2675d53f0111::RenderPass::Resources1014 Resources(const Environment &, const Parameters &)
1015 {
1016 }
1017 };
1018
createvkt::memory::__anon2675d53f0111::RenderPass1019 static Move<VkRenderPass> create(const Environment &env, const Resources &, const Parameters &)
1020 {
1021 return makeRenderPass(
1022 env.vkd, env.device, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_D16_UNORM, VK_ATTACHMENT_LOAD_OP_CLEAR,
1023 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1024 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
1025 }
1026 };
1027
1028 struct GraphicsPipeline
1029 {
1030 typedef VkPipeline Type;
1031
1032 struct Parameters
1033 {
Parametersvkt::memory::__anon2675d53f0111::GraphicsPipeline::Parameters1034 Parameters(void)
1035 {
1036 }
1037 };
1038
1039 struct Resources
1040 {
1041 Dependency<ShaderModule> vertexShader;
1042 Dependency<ShaderModule> fragmentShader;
1043 Dependency<PipelineLayout> layout;
1044 Dependency<RenderPass> renderPass;
1045 Dependency<PipelineCache> pipelineCache;
1046
Resourcesvkt::memory::__anon2675d53f0111::GraphicsPipeline::Resources1047 Resources(const Environment &env, const Parameters &)
1048 : vertexShader(env, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"))
1049 , fragmentShader(env, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"))
1050 , layout(env, PipelineLayout::Parameters::singleDescriptorSet(DescriptorSetLayout::Parameters::single(
1051 0u, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u, VK_SHADER_STAGE_FRAGMENT_BIT, true)))
1052 , renderPass(env, RenderPass::Parameters())
1053 , pipelineCache(env, PipelineCache::Parameters())
1054 {
1055 }
1056 };
1057
initProgramsvkt::memory::__anon2675d53f0111::GraphicsPipeline1058 static void initPrograms(SourceCollections &dst, Parameters)
1059 {
1060 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"));
1061 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"));
1062 }
1063
createvkt::memory::__anon2675d53f0111::GraphicsPipeline1064 static Move<VkPipeline> create(const Environment &env, const Resources &res, const Parameters &)
1065 {
1066 const VkPipelineShaderStageCreateInfo stages[] = {
1067 {
1068 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1069 DE_NULL, // const void* pNext;
1070 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1071 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1072 *res.vertexShader.object, // VkShaderModule module;
1073 "main", // const char* pName;
1074 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1075 },
1076 {
1077 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1078 DE_NULL, // const void* pNext;
1079 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1080 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1081 *res.fragmentShader.object, // VkShaderModule module;
1082 "main", // const char* pName;
1083 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1084 }};
1085 const VkVertexInputBindingDescription vertexBindings[] = {{
1086 0u, // uint32_t binding;
1087 16u, // uint32_t stride;
1088 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
1089 }};
1090 const VkVertexInputAttributeDescription vertexAttribs[] = {{
1091 0u, // uint32_t location;
1092 0u, // uint32_t binding;
1093 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1094 0u, // uint32_t offset;
1095 }};
1096 const VkPipelineVertexInputStateCreateInfo vertexInputState = {
1097 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1098 DE_NULL, // const void* pNext;
1099 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1100 DE_LENGTH_OF_ARRAY(vertexBindings), // uint32_t vertexBindingDescriptionCount;
1101 vertexBindings, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1102 DE_LENGTH_OF_ARRAY(vertexAttribs), // uint32_t vertexAttributeDescriptionCount;
1103 vertexAttribs, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1104 };
1105 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = {
1106 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1107 DE_NULL, // const void* pNext;
1108 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1109 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1110 VK_FALSE, // VkBool32 primitiveRestartEnable;
1111 };
1112 const VkViewport viewport = makeViewport(tcu::UVec2(64));
1113 const VkRect2D scissor = makeRect2D(tcu::UVec2(64));
1114
1115 const VkPipelineViewportStateCreateInfo viewportState = {
1116 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
1117 DE_NULL, // const void* pNext;
1118 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
1119 1u, // uint32_t viewportCount;
1120 &viewport, // const VkViewport* pViewports;
1121 1u, // uint32_t scissorCount;
1122 &scissor, // const VkRect2D* pScissors;
1123 };
1124 const VkPipelineRasterizationStateCreateInfo rasterState = {
1125 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1126 DE_NULL, // const void* pNext;
1127 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1128 VK_FALSE, // VkBool32 depthClampEnable;
1129 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1130 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1131 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
1132 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
1133 VK_FALSE, // VkBool32 depthBiasEnable;
1134 0.0f, // float depthBiasConstantFactor;
1135 0.0f, // float depthBiasClamp;
1136 0.0f, // float depthBiasSlopeFactor;
1137 1.0f, // float lineWidth;
1138 };
1139 const VkPipelineMultisampleStateCreateInfo multisampleState = {
1140 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1141 DE_NULL, // const void* pNext;
1142 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
1143 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
1144 VK_FALSE, // VkBool32 sampleShadingEnable;
1145 1.0f, // float minSampleShading;
1146 DE_NULL, // const VkSampleMask* pSampleMask;
1147 VK_FALSE, // VkBool32 alphaToCoverageEnable;
1148 VK_FALSE, // VkBool32 alphaToOneEnable;
1149 };
1150 const VkPipelineDepthStencilStateCreateInfo depthStencilState = {
1151 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1152 DE_NULL, // const void* pNext;
1153 (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
1154 VK_TRUE, // VkBool32 depthTestEnable;
1155 VK_TRUE, // VkBool32 depthWriteEnable;
1156 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
1157 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1158 VK_FALSE, // VkBool32 stencilTestEnable;
1159 {
1160 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1161 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1162 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1163 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1164 0u, // uint32_t compareMask;
1165 0u, // uint32_t writeMask;
1166 0u, // uint32_t reference;
1167 },
1168 {
1169 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1170 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1171 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1172 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1173 0u, // uint32_t compareMask;
1174 0u, // uint32_t writeMask;
1175 0u, // uint32_t reference;
1176 },
1177 0.0f, // float minDepthBounds;
1178 1.0f, // float maxDepthBounds;
1179 };
1180 const VkPipelineColorBlendAttachmentState colorBlendAttState[] = {{
1181 VK_FALSE, // VkBool32 blendEnable;
1182 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
1183 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
1184 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1185 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
1186 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
1187 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1188 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT |
1189 VK_COLOR_COMPONENT_A_BIT, // VkColorComponentFlags colorWriteMask;
1190 }};
1191 const VkPipelineColorBlendStateCreateInfo colorBlendState = {
1192 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1193 DE_NULL, // const void* pNext;
1194 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
1195 VK_FALSE, // VkBool32 logicOpEnable;
1196 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1197 DE_LENGTH_OF_ARRAY(colorBlendAttState), // uint32_t attachmentCount;
1198 colorBlendAttState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1199 {0.0f, 0.0f, 0.0f, 0.0f}, // float blendConstants[4];
1200 };
1201 const VkGraphicsPipelineCreateInfo pipelineCreateInfo = {
1202 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1203 DE_NULL, // const void* pNext;
1204 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1205 DE_LENGTH_OF_ARRAY(stages), // uint32_t stageCount;
1206 stages, // const VkPipelineShaderStageCreateInfo* pStages;
1207 &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1208 &inputAssemblyState, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1209 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1210 &viewportState, // const VkPipelineViewportStateCreateInfo* pViewportState;
1211 &rasterState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1212 &multisampleState, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1213 &depthStencilState, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1214 &colorBlendState, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1215 (const VkPipelineDynamicStateCreateInfo *)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1216 *res.layout.object, // VkPipelineLayout layout;
1217 *res.renderPass.object, // VkRenderPass renderPass;
1218 0u, // uint32_t subpass;
1219 (VkPipeline)0, // VkPipeline basePipelineHandle;
1220 0, // int32_t basePipelineIndex;
1221 };
1222
1223 return createGraphicsPipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1224 }
1225 };
1226
1227 struct ComputePipeline
1228 {
1229 typedef VkPipeline Type;
1230
1231 struct Parameters
1232 {
Parametersvkt::memory::__anon2675d53f0111::ComputePipeline::Parameters1233 Parameters(void)
1234 {
1235 }
1236 };
1237
1238 struct Resources
1239 {
1240 Dependency<ShaderModule> shaderModule;
1241 Dependency<PipelineLayout> layout;
1242 Dependency<PipelineCache> pipelineCache;
1243
getDescriptorSetLayoutvkt::memory::__anon2675d53f0111::ComputePipeline::Resources1244 static DescriptorSetLayout::Parameters getDescriptorSetLayout(void)
1245 {
1246 typedef DescriptorSetLayout::Parameters::Binding Binding;
1247
1248 std::vector<Binding> bindings;
1249
1250 bindings.push_back(Binding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1251 bindings.push_back(Binding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1252
1253 return DescriptorSetLayout::Parameters(bindings);
1254 }
1255
Resourcesvkt::memory::__anon2675d53f0111::ComputePipeline::Resources1256 Resources(const Environment &env, const Parameters &)
1257 : shaderModule(env, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"))
1258 , layout(env, PipelineLayout::Parameters::singleDescriptorSet(getDescriptorSetLayout()))
1259 , pipelineCache(env, PipelineCache::Parameters())
1260 {
1261 }
1262 };
1263
initProgramsvkt::memory::__anon2675d53f0111::ComputePipeline1264 static void initPrograms(SourceCollections &dst, Parameters)
1265 {
1266 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"));
1267 }
1268
createvkt::memory::__anon2675d53f0111::ComputePipeline1269 static Move<VkPipeline> create(const Environment &env, const Resources &res, const Parameters &)
1270 {
1271 const VkComputePipelineCreateInfo pipelineCreateInfo = {
1272 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1273 DE_NULL, // const void* pNext;
1274 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1275 {
1276 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1277 DE_NULL, // const void* pNext;
1278 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1279 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1280 *res.shaderModule.object, // VkShaderModule module;
1281 "main", // const char* pName;
1282 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1283 },
1284 *res.layout.object, // VkPipelineLayout layout;
1285 (VkPipeline)0, // VkPipeline basePipelineHandle;
1286 0u, // int32_t basePipelineIndex;
1287 };
1288
1289 return createComputePipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1290 }
1291 };
1292
1293 struct DescriptorPool
1294 {
1295 typedef VkDescriptorPool Type;
1296
1297 struct Parameters
1298 {
1299 VkDescriptorPoolCreateFlags flags;
1300 uint32_t maxSets;
1301 std::vector<VkDescriptorPoolSize> poolSizes;
1302
Parametersvkt::memory::__anon2675d53f0111::DescriptorPool::Parameters1303 Parameters(VkDescriptorPoolCreateFlags flags_, uint32_t maxSets_,
1304 const std::vector<VkDescriptorPoolSize> &poolSizes_)
1305 : flags(flags_)
1306 , maxSets(maxSets_)
1307 , poolSizes(poolSizes_)
1308 {
1309 }
1310
singleTypevkt::memory::__anon2675d53f0111::DescriptorPool::Parameters1311 static Parameters singleType(VkDescriptorPoolCreateFlags flags, uint32_t maxSets, VkDescriptorType type,
1312 uint32_t count)
1313 {
1314 std::vector<VkDescriptorPoolSize> poolSizes;
1315 poolSizes.push_back(makeDescriptorPoolSize(type, count));
1316 return Parameters(flags, maxSets, poolSizes);
1317 }
1318 };
1319
1320 struct Resources
1321 {
Resourcesvkt::memory::__anon2675d53f0111::DescriptorPool::Resources1322 Resources(const Environment &, const Parameters &)
1323 {
1324 }
1325 };
1326
createvkt::memory::__anon2675d53f0111::DescriptorPool1327 static Move<VkDescriptorPool> create(const Environment &env, const Resources &, const Parameters ¶ms)
1328 {
1329 const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {
1330 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
1331 DE_NULL, // const void* pNext;
1332 params.flags, // VkDescriptorPoolCreateFlags flags;
1333 params.maxSets, // uint32_t maxSets;
1334 (uint32_t)params.poolSizes.size(), // uint32_t poolSizeCount;
1335 (params.poolSizes.empty() ? DE_NULL : ¶ms.poolSizes[0]), // const VkDescriptorPoolSize* pPoolSizes;
1336 };
1337
1338 return createDescriptorPool(env.vkd, env.device, &descriptorPoolCreateInfo);
1339 }
1340 };
1341
1342 struct DescriptorSet
1343 {
1344 typedef VkDescriptorSet Type;
1345
1346 struct Parameters
1347 {
1348 DescriptorSetLayout::Parameters descriptorSetLayout;
1349
Parametersvkt::memory::__anon2675d53f0111::DescriptorSet::Parameters1350 Parameters(const DescriptorSetLayout::Parameters &descriptorSetLayout_)
1351 : descriptorSetLayout(descriptorSetLayout_)
1352 {
1353 }
1354 };
1355
1356 struct Resources
1357 {
1358 Dependency<DescriptorPool> descriptorPool;
1359 Dependency<DescriptorSetLayout> descriptorSetLayout;
1360
computePoolSizesvkt::memory::__anon2675d53f0111::DescriptorSet::Resources1361 static std::vector<VkDescriptorPoolSize> computePoolSizes(const DescriptorSetLayout::Parameters &layout,
1362 int maxSets)
1363 {
1364 uint32_t countByType[VK_DESCRIPTOR_TYPE_LAST];
1365 std::vector<VkDescriptorPoolSize> typeCounts;
1366
1367 std::fill(DE_ARRAY_BEGIN(countByType), DE_ARRAY_END(countByType), 0u);
1368
1369 for (std::vector<DescriptorSetLayout::Parameters::Binding>::const_iterator cur = layout.bindings.begin();
1370 cur != layout.bindings.end(); cur++)
1371 {
1372 DE_ASSERT((uint32_t)cur->descriptorType < VK_DESCRIPTOR_TYPE_LAST);
1373 countByType[cur->descriptorType] += cur->descriptorCount * maxSets;
1374 }
1375
1376 for (uint32_t type = 0; type < VK_DESCRIPTOR_TYPE_LAST; type++)
1377 {
1378 if (countByType[type] > 0)
1379 typeCounts.push_back(makeDescriptorPoolSize((VkDescriptorType)type, countByType[type]));
1380 }
1381
1382 return typeCounts;
1383 }
1384
Resourcesvkt::memory::__anon2675d53f0111::DescriptorSet::Resources1385 Resources(const Environment &env, const Parameters ¶ms)
1386 : descriptorPool(env, DescriptorPool::Parameters(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u,
1387 computePoolSizes(params.descriptorSetLayout, 1u)))
1388 , descriptorSetLayout(env, params.descriptorSetLayout)
1389 {
1390 }
1391 };
1392
createvkt::memory::__anon2675d53f0111::DescriptorSet1393 static Move<VkDescriptorSet> create(const Environment &env, const Resources &res, const Parameters &)
1394 {
1395 const VkDescriptorSetAllocateInfo allocateInfo = {
1396 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
1397 DE_NULL, // const void* pNext;
1398 *res.descriptorPool.object, // VkDescriptorPool descriptorPool;
1399 1u, // uint32_t descriptorSetCount;
1400 &(*res.descriptorSetLayout.object), // const VkDescriptorSetLayout* pSetLayouts;
1401 };
1402
1403 return allocateDescriptorSet(env.vkd, env.device, &allocateInfo);
1404 }
1405 };
1406
1407 struct Framebuffer
1408 {
1409 typedef VkFramebuffer Type;
1410
1411 struct Parameters
1412 {
Parametersvkt::memory::__anon2675d53f0111::Framebuffer::Parameters1413 Parameters(void)
1414 {
1415 }
1416 };
1417
1418 struct Resources
1419 {
1420 Dependency<ImageView> colorAttachment;
1421 Dependency<ImageView> depthStencilAttachment;
1422 Dependency<RenderPass> renderPass;
1423
Resourcesvkt::memory::__anon2675d53f0111::Framebuffer::Resources1424 Resources(const Environment &env, const Parameters &)
1425 : colorAttachment(
1426 env, ImageView::Parameters(
1427 Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D(256, 256, 1),
1428 1u, 1u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
1429 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_UNDEFINED),
1430 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, makeComponentMappingRGBA(),
1431 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)))
1432 , depthStencilAttachment(
1433 env, ImageView::Parameters(
1434 Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM, makeExtent3D(256, 256, 1), 1u,
1435 1u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
1436 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_UNDEFINED),
1437 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM, makeComponentMappingRGBA(),
1438 makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u)))
1439 , renderPass(env, RenderPass::Parameters())
1440 {
1441 }
1442 };
1443
createvkt::memory::__anon2675d53f0111::Framebuffer1444 static Move<VkFramebuffer> create(const Environment &env, const Resources &res, const Parameters &)
1445 {
1446 const VkImageView attachments[] = {
1447 *res.colorAttachment.object,
1448 *res.depthStencilAttachment.object,
1449 };
1450 const VkFramebufferCreateInfo framebufferCreateInfo = {
1451 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1452 DE_NULL, // const void* pNext;
1453 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
1454 *res.renderPass.object, // VkRenderPass renderPass;
1455 (uint32_t)DE_LENGTH_OF_ARRAY(attachments), // uint32_t attachmentCount;
1456 attachments, // const VkImageView* pAttachments;
1457 256u, // uint32_t width;
1458 256u, // uint32_t height;
1459 1u, // uint32_t layers;
1460 };
1461
1462 return createFramebuffer(env.vkd, env.device, &framebufferCreateInfo);
1463 }
1464 };
1465
1466 struct CommandPool
1467 {
1468 typedef VkCommandPool Type;
1469
1470 struct Parameters
1471 {
1472 VkCommandPoolCreateFlags flags;
1473
Parametersvkt::memory::__anon2675d53f0111::CommandPool::Parameters1474 Parameters(VkCommandPoolCreateFlags flags_) : flags(flags_)
1475 {
1476 }
1477 };
1478
1479 struct Resources
1480 {
Resourcesvkt::memory::__anon2675d53f0111::CommandPool::Resources1481 Resources(const Environment &, const Parameters &)
1482 {
1483 }
1484 };
1485
createvkt::memory::__anon2675d53f0111::CommandPool1486 static Move<VkCommandPool> create(const Environment &env, const Resources &, const Parameters ¶ms)
1487 {
1488 const VkCommandPoolCreateInfo commandPoolCreateInfo = {
1489 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
1490 DE_NULL, // const void* pNext;
1491 params.flags, // VkCommandPoolCreateFlags flags;
1492 env.queueFamilyIndex, // uint32_t queueFamilyIndex;
1493 };
1494
1495 return createCommandPool(env.vkd, env.device, &commandPoolCreateInfo);
1496 }
1497 };
1498
1499 struct CommandBuffer
1500 {
1501 typedef VkCommandBuffer Type;
1502
1503 struct Parameters
1504 {
1505 CommandPool::Parameters commandPool;
1506 VkCommandBufferLevel level;
1507
Parametersvkt::memory::__anon2675d53f0111::CommandBuffer::Parameters1508 Parameters(const CommandPool::Parameters &commandPool_, VkCommandBufferLevel level_)
1509 : commandPool(commandPool_)
1510 , level(level_)
1511 {
1512 }
1513 };
1514
1515 struct Resources
1516 {
1517 Dependency<CommandPool> commandPool;
1518
Resourcesvkt::memory::__anon2675d53f0111::CommandBuffer::Resources1519 Resources(const Environment &env, const Parameters ¶ms) : commandPool(env, params.commandPool)
1520 {
1521 }
1522 };
1523
createvkt::memory::__anon2675d53f0111::CommandBuffer1524 static Move<VkCommandBuffer> create(const Environment &env, const Resources &res, const Parameters ¶ms)
1525 {
1526 const VkCommandBufferAllocateInfo allocateInfo = {
1527 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
1528 DE_NULL, // const void* pNext;
1529 *res.commandPool.object, // VkCommandPool commandPool;
1530 params.level, // VkCommandBufferLevel level;
1531 1, // uint32_t commandBufferCount;
1532 };
1533
1534 return allocateCommandBuffer(env.vkd, env.device, &allocateInfo);
1535 }
1536 };
1537
1538 template <typename Object>
1539 struct NamedParameters
1540 {
1541 const char *name;
1542 typename Object::Parameters parameters;
1543 };
1544
1545 template <typename Object>
1546 struct CaseDescription
1547 {
1548 typename FunctionInstance1<typename Object::Parameters>::Function function;
1549 const NamedParameters<Object> *paramsBegin;
1550 const NamedParameters<Object> *paramsEnd;
1551 };
1552
1553 #define CASE_DESC(FUNCTION, CASES) \
1554 { \
1555 FUNCTION, DE_ARRAY_BEGIN(CASES), DE_ARRAY_END(CASES) \
1556 }
1557
1558 struct CaseDescriptions
1559 {
1560 CaseDescription<Device> device;
1561 CaseDescription<DeviceMemory> deviceMemory;
1562 CaseDescription<Buffer> buffer;
1563 CaseDescription<BufferView> bufferView;
1564 CaseDescription<Image> image;
1565 CaseDescription<ImageView> imageView;
1566 CaseDescription<Semaphore> semaphore;
1567 CaseDescription<Event> event;
1568 CaseDescription<Fence> fence;
1569 CaseDescription<QueryPool> queryPool;
1570 CaseDescription<ShaderModule> shaderModule;
1571 CaseDescription<PipelineCache> pipelineCache;
1572 CaseDescription<Sampler> sampler;
1573 CaseDescription<DescriptorSetLayout> descriptorSetLayout;
1574 CaseDescription<PipelineLayout> pipelineLayout;
1575 CaseDescription<RenderPass> renderPass;
1576 CaseDescription<GraphicsPipeline> graphicsPipeline;
1577 CaseDescription<ComputePipeline> computePipeline;
1578 CaseDescription<DescriptorPool> descriptorPool;
1579 CaseDescription<DescriptorSet> descriptorSet;
1580 CaseDescription<Framebuffer> framebuffer;
1581 CaseDescription<CommandPool> commandPool;
1582 CaseDescription<CommandBuffer> commandBuffer;
1583 };
1584
1585 template <typename Object>
addCases(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1586 void addCases(const MovePtr<tcu::TestCaseGroup> &group, const CaseDescription<Object> &cases)
1587 {
1588 for (const NamedParameters<Object> *cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1589 {
1590 addFunctionCase(group.get(), cur->name, cases.function, cur->parameters);
1591 }
1592 }
1593
1594 template <typename Object>
addCasesWithProgs(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1595 void addCasesWithProgs(const MovePtr<tcu::TestCaseGroup> &group, const CaseDescription<Object> &cases)
1596 {
1597 for (const NamedParameters<Object> *cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1598 {
1599 addFunctionCaseWithPrograms(group.get(), cur->name, Object::initPrograms, cases.function, cur->parameters);
1600 }
1601 }
1602
createObjectTestsGroup(tcu::TestContext & testCtx,const char * name,const CaseDescriptions & cases)1603 tcu::TestCaseGroup *createObjectTestsGroup(tcu::TestContext &testCtx, const char *name, const CaseDescriptions &cases)
1604 {
1605 MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, name));
1606
1607 addCases(group, cases.device);
1608 addCases(group, cases.deviceMemory);
1609 addCases(group, cases.buffer);
1610 addCases(group, cases.bufferView);
1611 addCases(group, cases.image);
1612 addCases(group, cases.imageView);
1613 addCases(group, cases.semaphore);
1614 addCases(group, cases.event);
1615 addCases(group, cases.fence);
1616 addCases(group, cases.queryPool);
1617 addCasesWithProgs(group, cases.shaderModule);
1618 addCases(group, cases.pipelineCache);
1619 addCases(group, cases.sampler);
1620 addCases(group, cases.descriptorSetLayout);
1621 addCases(group, cases.pipelineLayout);
1622 addCases(group, cases.renderPass);
1623 addCasesWithProgs(group, cases.graphicsPipeline);
1624 addCasesWithProgs(group, cases.computePipeline);
1625 addCases(group, cases.descriptorPool);
1626 addCases(group, cases.descriptorSet);
1627 addCases(group, cases.framebuffer);
1628 addCases(group, cases.commandPool);
1629 addCases(group, cases.commandBuffer);
1630
1631 return group.release();
1632 }
1633
validateCallbackRecords(Context & context,const BindingCallbackRecorder & recorder)1634 static bool validateCallbackRecords(Context &context, const BindingCallbackRecorder &recorder)
1635 {
1636 tcu::TestLog &log = context.getTestContext().getLog();
1637
1638 for (auto bindRecord = recorder.getRecordsBegin(); bindRecord != recorder.getRecordsEnd(); bindRecord++)
1639 {
1640 if (bindRecord->bindingType == VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT)
1641 {
1642 bool matchedBoundUnbound = false;
1643
1644 for (auto pairRecord = bindRecord; pairRecord != recorder.getRecordsEnd(); pairRecord++)
1645 {
1646 if (pairRecord->bindingType == VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT)
1647 {
1648 if ((*bindRecord) == (*pairRecord))
1649 {
1650 log << tcu::TestLog::Message << "Bind/Unbind base adress:" << bindRecord->bindingAddress
1651 << tcu::TestLog::EndMessage;
1652 log << tcu::TestLog::Message << "Bind/Unbind size:" << bindRecord->size
1653 << tcu::TestLog::EndMessage;
1654 log << tcu::TestLog::Message << "Bind/Unbind object handle:" << bindRecord->objectHandle
1655 << tcu::TestLog::EndMessage;
1656
1657 matchedBoundUnbound = true;
1658 break;
1659 }
1660 }
1661 }
1662
1663 if (matchedBoundUnbound == false)
1664 {
1665 log << tcu::TestLog::Message << "Lonely bind base adress:" << bindRecord->bindingAddress
1666 << tcu::TestLog::EndMessage;
1667 log << tcu::TestLog::Message << "Lonely bind size:" << bindRecord->size << tcu::TestLog::EndMessage;
1668 log << tcu::TestLog::Message << "Lonely bind object handle:" << bindRecord->objectHandle
1669 << tcu::TestLog::EndMessage;
1670
1671 return false;
1672 }
1673 }
1674 else if (bindRecord->bindingType == VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT)
1675 {
1676 bool matchedBoundUnbound = false;
1677
1678 for (auto pairRecord = recorder.getRecordsBegin(); pairRecord != bindRecord; pairRecord++)
1679 {
1680 if (pairRecord->bindingType == VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT)
1681 {
1682 if ((*bindRecord) == (*pairRecord))
1683 {
1684 matchedBoundUnbound = true;
1685 break;
1686 }
1687 }
1688 }
1689
1690 if (matchedBoundUnbound == false)
1691 {
1692 log << tcu::TestLog::Message << "Lonely unbind base adress:" << bindRecord->bindingAddress
1693 << tcu::TestLog::EndMessage;
1694 log << tcu::TestLog::Message << "Lonely unbind size:" << bindRecord->size << tcu::TestLog::EndMessage;
1695 log << tcu::TestLog::Message << "Lonely unbind object handle:" << bindRecord->objectHandle
1696 << tcu::TestLog::EndMessage;
1697
1698 return false;
1699 }
1700 }
1701 }
1702
1703 return true;
1704 }
1705
1706 struct EnvClone
1707 {
1708 Unique<VkDevice> device;
1709 DeviceDriver vkd;
1710 Environment env;
1711
EnvClonevkt::memory::__anon2675d53f0111::EnvClone1712 EnvClone(const Environment &parent)
1713 : device(Device::create(parent, Device::Resources(parent, Device::Parameters()), Device::Parameters()))
1714 , vkd(parent.vkp, parent.instance, *device, parent.usedApiVersion, parent.commandLine)
1715 , env(parent.vkp, parent.vki, parent.instance, parent.physicalDevice, vkd, *device, parent.queueFamilyIndex,
1716 parent.programBinaries, parent.usedApiVersion, parent.commandLine, nullptr)
1717 {
1718 }
1719 };
1720
getInstanceExtensions(const uint32_t instanceVersion)1721 static std::vector<std::string> getInstanceExtensions(const uint32_t instanceVersion)
1722 {
1723 std::vector<std::string> instanceExtensions;
1724
1725 if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
1726 instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
1727
1728 if (!isCoreInstanceExtension(instanceVersion, "VK_EXT_debug_utils"))
1729 instanceExtensions.push_back("VK_EXT_debug_utils");
1730
1731 return instanceExtensions;
1732 }
1733
checkSupport(CustomInstance & customInstance,vk::VkPhysicalDevice & physicalDevice)1734 static bool checkSupport(CustomInstance &customInstance, vk::VkPhysicalDevice &physicalDevice)
1735 {
1736 const std::vector<VkExtensionProperties> extensions =
1737 enumerateDeviceExtensionProperties(customInstance.getDriver(), physicalDevice, DE_NULL);
1738
1739 for (size_t extNdx = 0; extNdx < extensions.size(); extNdx++)
1740 {
1741 if (deStringEqual("VK_EXT_device_address_binding_report", extensions[extNdx].extensionName))
1742 {
1743 VkPhysicalDeviceAddressBindingReportFeaturesEXT deviceAddressBindingReportFeatures{
1744 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, DE_NULL, VK_FALSE};
1745
1746 VkPhysicalDeviceFeatures2 availFeatures;
1747 availFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1748 availFeatures.pNext = &deviceAddressBindingReportFeatures;
1749
1750 customInstance.getDriver().getPhysicalDeviceFeatures2(physicalDevice, &availFeatures);
1751
1752 if (deviceAddressBindingReportFeatures.reportAddressBinding == VK_TRUE)
1753 return true;
1754 else
1755 return false;
1756 }
1757 }
1758
1759 return false;
1760 }
1761
1762 template <typename Object>
createDestroyObjectTest(Context & context,typename Object::Parameters params)1763 tcu::TestStatus createDestroyObjectTest(Context &context, typename Object::Parameters params)
1764 {
1765 BindingCallbackRecorder recorder;
1766 VkDebugUtilsMessengerEXT messenger;
1767
1768 CustomInstance customInstance =
1769 createCustomInstanceWithExtensions(context, getInstanceExtensions(context.getUsedApiVersion()));
1770 vk::VkPhysicalDevice physicalDevice =
1771 chooseDevice(customInstance.getDriver(), customInstance, context.getTestContext().getCommandLine());
1772 uint32_t queueFamilyIndex = 0;
1773
1774 if (!checkSupport(customInstance, physicalDevice))
1775 {
1776 TCU_THROW(NotSupportedError, "Device address binding report not supported");
1777 }
1778
1779 const std::vector<VkQueueFamilyProperties> queueProps =
1780 getPhysicalDeviceQueueFamilyProperties(customInstance.getDriver(), physicalDevice);
1781
1782 for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
1783 {
1784 if ((queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT)
1785 {
1786 queueFamilyIndex = (uint32_t)queueNdx;
1787 break;
1788 }
1789 }
1790
1791 VkDebugUtilsMessengerCreateInfoEXT debugUtilsMessengerCreateInfo = {
1792 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
1793 nullptr,
1794 0,
1795 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
1796 VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT,
1797 recorder.callback,
1798 &recorder};
1799
1800 customInstance.getDriver().createDebugUtilsMessengerEXT(customInstance, &debugUtilsMessengerCreateInfo, nullptr,
1801 &messenger);
1802
1803 {
1804 Move<VkDevice> device = createDeviceWithAdressBindingReport(
1805 context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(),
1806 customInstance, customInstance.getDriver(), physicalDevice, queueFamilyIndex);
1807
1808 de::MovePtr<DeviceDriver> deviceInterface = de::MovePtr<DeviceDriver>(
1809 new DeviceDriver(context.getPlatformInterface(), customInstance, device.get(), context.getUsedApiVersion(),
1810 context.getTestContext().getCommandLine()));
1811
1812 const Environment env(context.getPlatformInterface(), customInstance.getDriver(), customInstance,
1813 physicalDevice, *deviceInterface.get(), device.get(), queueFamilyIndex,
1814 context.getBinaryCollection(), context.getUsedApiVersion(),
1815 context.getTestContext().getCommandLine(), &recorder);
1816
1817 {
1818 const typename Object::Resources res(env, params);
1819 Unique<typename Object::Type> obj(Object::create(env, res, params));
1820 }
1821 }
1822
1823 customInstance.getDriver().destroyDebugUtilsMessengerEXT(customInstance, messenger, nullptr);
1824
1825 if (!validateCallbackRecords(context, recorder))
1826 {
1827 return tcu::TestStatus::fail("Invalid address binding report callback");
1828 }
1829
1830 return tcu::TestStatus::pass("Ok");
1831 }
1832
1833 } // namespace
1834
createAddressBindingReportTests(tcu::TestContext & testCtx)1835 tcu::TestCaseGroup *createAddressBindingReportTests(tcu::TestContext &testCtx)
1836 {
1837 MovePtr<tcu::TestCaseGroup> addressBindingReportTests(new tcu::TestCaseGroup(testCtx, "address_binding_report"));
1838
1839 const Image::Parameters img1D(0u, VK_IMAGE_TYPE_1D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D(256, 1, 1), 1u, 4u,
1840 VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT,
1841 VK_IMAGE_LAYOUT_UNDEFINED);
1842 const Image::Parameters img2D(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D(64, 64, 1), 1u, 12u,
1843 VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
1844 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1845 VK_IMAGE_LAYOUT_UNDEFINED);
1846 const Image::Parameters imgCube(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
1847 makeExtent3D(64, 64, 1), 1u, 12u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
1848 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1849 VK_IMAGE_LAYOUT_UNDEFINED);
1850 const Image::Parameters img3D(0u, VK_IMAGE_TYPE_3D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D(64, 64, 4), 1u, 1u,
1851 VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT,
1852 VK_IMAGE_LAYOUT_UNDEFINED);
1853 const ImageView::Parameters imgView1D(img1D, VK_IMAGE_VIEW_TYPE_1D, img1D.format, makeComponentMappingRGBA(),
1854 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
1855 const ImageView::Parameters imgView1DArr(img1D, VK_IMAGE_VIEW_TYPE_1D_ARRAY, img1D.format,
1856 makeComponentMappingRGBA(),
1857 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 4u));
1858 const ImageView::Parameters imgView2D(img2D, VK_IMAGE_VIEW_TYPE_2D, img2D.format, makeComponentMappingRGBA(),
1859 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
1860 const ImageView::Parameters imgView2DArr(img2D, VK_IMAGE_VIEW_TYPE_2D_ARRAY, img2D.format,
1861 makeComponentMappingRGBA(),
1862 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 8u));
1863 const ImageView::Parameters imgViewCube(imgCube, VK_IMAGE_VIEW_TYPE_CUBE, img2D.format, makeComponentMappingRGBA(),
1864 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 6u));
1865 const ImageView::Parameters imgViewCubeArr(imgCube, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, img2D.format,
1866 makeComponentMappingRGBA(),
1867 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 12u));
1868 const ImageView::Parameters imgView3D(img3D, VK_IMAGE_VIEW_TYPE_3D, img3D.format, makeComponentMappingRGBA(),
1869 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
1870
1871 const DescriptorSetLayout::Parameters singleUboDescLayout =
1872 DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, VK_SHADER_STAGE_VERTEX_BIT);
1873
1874 const NamedParameters<Device> s_deviceCases[] = {
1875 {"device", Device::Parameters()},
1876 };
1877 static const NamedParameters<DeviceMemory> s_deviceMemCases[] = {
1878 {"device_memory_small", DeviceMemory::Parameters(1024, 0u)},
1879 };
1880 static const NamedParameters<Buffer> s_bufferCases[] = {
1881 {
1882 "buffer_uniform_small",
1883 Buffer::Parameters(1024u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT),
1884 },
1885 {
1886 "buffer_uniform_large",
1887 Buffer::Parameters(1024u * 1024u * 16u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT),
1888 },
1889 {
1890 "buffer_storage_small",
1891 Buffer::Parameters(1024u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),
1892 },
1893 {
1894 "buffer_storage_large",
1895 Buffer::Parameters(1024u * 1024u * 16u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),
1896 },
1897 };
1898 static const NamedParameters<BufferView> s_bufferViewCases[] = {
1899 {"buffer_view_uniform_r8g8b8a8_unorm",
1900 BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT),
1901 VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u)},
1902 {"buffer_view_storage_r8g8b8a8_unorm",
1903 BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT),
1904 VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u)},
1905 };
1906 static const NamedParameters<Image> s_imageCases[] = {
1907 {"image_1d", img1D},
1908 {"image_2d", img2D},
1909 {"image_3d", img3D},
1910 };
1911 static const NamedParameters<ImageView> s_imageViewCases[] = {
1912 {"image_view_1d", imgView1D}, {"image_view_1d_arr", imgView1DArr},
1913 {"image_view_2d", imgView2D}, {"image_view_2d_arr", imgView2DArr},
1914 {"image_view_cube", imgViewCube}, {"image_view_cube_arr", imgViewCubeArr},
1915 {"image_view_3d", imgView3D},
1916 };
1917 static const NamedParameters<Semaphore> s_semaphoreCases[] = {{
1918 "semaphore",
1919 Semaphore::Parameters(0u),
1920 }};
1921 static const NamedParameters<Event> s_eventCases[] = {{"event", Event::Parameters(0u)}};
1922 static const NamedParameters<Fence> s_fenceCases[] = {
1923 {"fence", Fence::Parameters(0u)}, {"fence_signaled", Fence::Parameters(VK_FENCE_CREATE_SIGNALED_BIT)}};
1924 static const NamedParameters<QueryPool> s_queryPoolCases[] = {
1925 {"query_pool", QueryPool::Parameters(VK_QUERY_TYPE_OCCLUSION, 1u, 0u)}};
1926 static const NamedParameters<ShaderModule> s_shaderModuleCases[] = {
1927 {"shader_module", ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "test")}};
1928 static const NamedParameters<PipelineCache> s_pipelineCacheCases[] = {
1929 {"pipeline_cache", PipelineCache::Parameters()}};
1930 static const NamedParameters<Sampler> s_samplerCases[] = {{"sampler", Sampler::Parameters()}};
1931 static const NamedParameters<DescriptorSetLayout> s_descriptorSetLayoutCases[] = {
1932 {"descriptor_set_layout_empty", DescriptorSetLayout::Parameters::empty()},
1933 {"descriptor_set_layout_single", singleUboDescLayout}};
1934 static const NamedParameters<PipelineLayout> s_pipelineLayoutCases[] = {
1935 {"pipeline_layout_empty", PipelineLayout::Parameters::empty()},
1936 {"pipeline_layout_single", PipelineLayout::Parameters::singleDescriptorSet(singleUboDescLayout)}};
1937 static const NamedParameters<RenderPass> s_renderPassCases[] = {{"render_pass", RenderPass::Parameters()}};
1938 static const NamedParameters<GraphicsPipeline> s_graphicsPipelineCases[] = {
1939 {"graphics_pipeline", GraphicsPipeline::Parameters()}};
1940 static const NamedParameters<ComputePipeline> s_computePipelineCases[] = {
1941 {"compute_pipeline", ComputePipeline::Parameters()}};
1942 static const NamedParameters<DescriptorPool> s_descriptorPoolCases[] = {
1943 {"descriptor_pool", DescriptorPool::Parameters::singleType((VkDescriptorPoolCreateFlags)0, 4u,
1944 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u)},
1945 {"descriptor_pool_free_descriptor_set",
1946 DescriptorPool::Parameters::singleType(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 4u,
1947 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u)}};
1948 static const NamedParameters<DescriptorSet> s_descriptorSetCases[] = {
1949 {"descriptor_set", DescriptorSet::Parameters(singleUboDescLayout)}};
1950 static const NamedParameters<Framebuffer> s_framebufferCases[] = {{"framebuffer", Framebuffer::Parameters()}};
1951 static const NamedParameters<CommandPool> s_commandPoolCases[] = {
1952 {"command_pool", CommandPool::Parameters((VkCommandPoolCreateFlags)0)},
1953 {"command_pool_transient", CommandPool::Parameters(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)}};
1954 static const NamedParameters<CommandBuffer> s_commandBufferCases[] = {
1955 {"command_buffer_primary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u),
1956 VK_COMMAND_BUFFER_LEVEL_PRIMARY)},
1957 {"command_buffer_secondary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u),
1958 VK_COMMAND_BUFFER_LEVEL_SECONDARY)}};
1959
1960 const CaseDescriptions s_createDestroyObjectGroup = {
1961 CASE_DESC(createDestroyObjectTest<Device>, s_deviceCases),
1962 CASE_DESC(createDestroyObjectTest<DeviceMemory>, s_deviceMemCases),
1963 CASE_DESC(createDestroyObjectTest<Buffer>, s_bufferCases),
1964 CASE_DESC(createDestroyObjectTest<BufferView>, s_bufferViewCases),
1965 CASE_DESC(createDestroyObjectTest<Image>, s_imageCases),
1966 CASE_DESC(createDestroyObjectTest<ImageView>, s_imageViewCases),
1967 CASE_DESC(createDestroyObjectTest<Semaphore>, s_semaphoreCases),
1968 CASE_DESC(createDestroyObjectTest<Event>, s_eventCases),
1969 CASE_DESC(createDestroyObjectTest<Fence>, s_fenceCases),
1970 CASE_DESC(createDestroyObjectTest<QueryPool>, s_queryPoolCases),
1971 CASE_DESC(createDestroyObjectTest<ShaderModule>, s_shaderModuleCases),
1972 CASE_DESC(createDestroyObjectTest<PipelineCache>, s_pipelineCacheCases),
1973 CASE_DESC(createDestroyObjectTest<Sampler>, s_samplerCases),
1974 CASE_DESC(createDestroyObjectTest<DescriptorSetLayout>, s_descriptorSetLayoutCases),
1975 CASE_DESC(createDestroyObjectTest<PipelineLayout>, s_pipelineLayoutCases),
1976 CASE_DESC(createDestroyObjectTest<RenderPass>, s_renderPassCases),
1977 CASE_DESC(createDestroyObjectTest<GraphicsPipeline>, s_graphicsPipelineCases),
1978 CASE_DESC(createDestroyObjectTest<ComputePipeline>, s_computePipelineCases),
1979 CASE_DESC(createDestroyObjectTest<DescriptorPool>, s_descriptorPoolCases),
1980 CASE_DESC(createDestroyObjectTest<DescriptorSet>, s_descriptorSetCases),
1981 CASE_DESC(createDestroyObjectTest<Framebuffer>, s_framebufferCases),
1982 CASE_DESC(createDestroyObjectTest<CommandPool>, s_commandPoolCases),
1983 CASE_DESC(createDestroyObjectTest<CommandBuffer>, s_commandBufferCases),
1984 };
1985 // Check emitted callbacks are properly paired
1986 addressBindingReportTests->addChild(
1987 createObjectTestsGroup(testCtx, "create_and_destroy_object", s_createDestroyObjectGroup));
1988
1989 return addressBindingReportTests.release();
1990 }
1991
1992 } // namespace memory
1993 } // namespace vkt
1994