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