1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2020 The Khronos Group Inc.
6 * Copyright (c) 2020 Google LLC
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief VK_EXT_device_memory_report extension tests.
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktMemoryDeviceMemoryReportTests.hpp"
26
27 #include "vktCustomInstancesDevices.hpp"
28 #include "vktExternalMemoryUtil.hpp"
29 #include "vktTestCaseUtil.hpp"
30
31 #include "vkDeviceUtil.hpp"
32 #include "vkObjUtil.hpp"
33 #include "vkQueryUtil.hpp"
34 #include "vkRefUtil.hpp"
35 #include "vkTypeUtil.hpp"
36
37 #include "tcuCommandLine.hpp"
38 #include "tcuTestCase.hpp"
39 #include "tcuTestLog.hpp"
40
41 #include "deSharedPtr.hpp"
42
43 #include <set>
44 #include <vector>
45 #include <limits>
46
47 namespace vkt
48 {
49 namespace memory
50 {
51 namespace
52 {
53
54 #define VK_DESCRIPTOR_TYPE_LAST (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT + 1)
55
56 using namespace vk;
57 using namespace vkt::ExternalMemoryUtil;
58 using de::MovePtr;
59 using de::SharedPtr;
60
61 enum CallbackMarker
62 {
63 MARKER_UNKNOWN = 0,
64 MARKER_ALLOCATE,
65 MARKER_FREE,
66 MARKER_IMPORT,
67 MARKER_UNIMPORT,
68 MARKER_ALLOCATION_FAILED
69 };
70
71 class CallbackRecorder
72 {
73 public:
CallbackRecorder(void)74 CallbackRecorder(void): mMarker(MARKER_UNKNOWN) {}
75 ~CallbackRecorder(void) = default;
76
77 typedef std::vector<std::pair<VkDeviceMemoryReportCallbackDataEXT, CallbackMarker>>::const_iterator RecordIterator;
78
getRecordsBegin(void) const79 RecordIterator getRecordsBegin (void) const
80 {
81 return mRecords.begin();
82 }
83
getRecordsEnd(void) const84 RecordIterator getRecordsEnd (void) const
85 {
86 return mRecords.end();
87 }
88
getNumRecords(void) const89 std::size_t getNumRecords (void) const
90 {
91 return mRecords.size();
92 }
93
setCallbackMarker(CallbackMarker marker)94 void setCallbackMarker(CallbackMarker marker)
95 {
96 mMarker = marker;
97 }
98
callbackInternal(const VkDeviceMemoryReportCallbackDataEXT * pCallbackData)99 void callbackInternal (const VkDeviceMemoryReportCallbackDataEXT* pCallbackData)
100 {
101 mRecords.emplace_back(*pCallbackData, mMarker);
102 }
103
callback(const struct VkDeviceMemoryReportCallbackDataEXT * pCallbackData,void * pUserData)104 static VKAPI_ATTR void VKAPI_CALL callback (const struct VkDeviceMemoryReportCallbackDataEXT* pCallbackData, void* pUserData)
105 {
106 reinterpret_cast<CallbackRecorder*>(pUserData)->callbackInternal(pCallbackData);
107 }
108
109 private:
110 typedef std::vector<std::pair<VkDeviceMemoryReportCallbackDataEXT, CallbackMarker>> Records;
111
112 Records mRecords;
113 CallbackMarker mMarker;
114 };
115
116 struct Environment
117 {
118 const PlatformInterface& vkp;
119 const InstanceInterface& vki;
120 VkInstance instance;
121 VkPhysicalDevice physicalDevice;
122 const DeviceInterface& vkd;
123 VkDevice device;
124 deUint32 queueFamilyIndex;
125 const BinaryCollection& programBinaries;
126 const tcu::CommandLine& commandLine;
127 const CallbackRecorder* recorder;
128 const uint32_t usedApiVersion;
129
Environmentvkt::memory::__anon67ed6e6e0111::Environment130 Environment (const PlatformInterface& vkp_,
131 const InstanceInterface& vki_,
132 VkInstance instance_,
133 VkPhysicalDevice physicalDevice_,
134 const DeviceInterface& vkd_,
135 VkDevice device_,
136 deUint32 queueFamilyIndex_,
137 const BinaryCollection& programBinaries_,
138 const tcu::CommandLine& commandLine_,
139 const CallbackRecorder* recorder_,
140 const uint32_t usedApiVersion_)
141 : vkp (vkp_)
142 , vki (vki_)
143 , instance (instance_)
144 , physicalDevice (physicalDevice_)
145 , vkd (vkd_)
146 , device (device_)
147 , queueFamilyIndex (queueFamilyIndex_)
148 , programBinaries (programBinaries_)
149 , commandLine (commandLine_)
150 , recorder (recorder_)
151 , usedApiVersion (usedApiVersion_)
152 {
153 }
154 };
155
156 template<typename Case>
157 struct Dependency
158 {
159 typename Case::Resources resources;
160 Unique<typename Case::Type> object;
161
Dependencyvkt::memory::__anon67ed6e6e0111::Dependency162 Dependency (const Environment& env, const typename Case::Parameters& params)
163 : resources (env, params)
164 , object (Case::create(env, resources, params))
165 {}
166 };
167
createDeviceWithMemoryReport(deBool isValidationEnabled,const PlatformInterface & vkp,VkInstance instance,const InstanceInterface & vki,VkPhysicalDevice physicalDevice,deUint32 queueFamilyIndex,const CallbackRecorder * recorder)168 static Move<VkDevice> createDeviceWithMemoryReport (deBool isValidationEnabled,
169 const PlatformInterface& vkp,
170 VkInstance instance,
171 const InstanceInterface& vki,
172 VkPhysicalDevice physicalDevice,
173 deUint32 queueFamilyIndex,
174 const CallbackRecorder* recorder)
175 {
176 const deUint32 queueCount = 1;
177 const float queuePriority = 1.0f;
178 const char* const enabledExtensions[] = {"VK_EXT_device_memory_report"};
179 const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
180 {
181 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, // VkStructureType sType;
182 DE_NULL, // void* pNext;
183 VK_TRUE // VkBool32 deviceMemoryReport;
184 };
185 const VkDeviceDeviceMemoryReportCreateInfoEXT deviceMemoryReportCreateInfo =
186 {
187 VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, // VkStructureType sType;
188 &deviceMemoryReportFeatures, // void* pNext;
189 (VkDeviceMemoryReportFlagsEXT)0, // VkDeviceMemoryReportFlagsEXT flags;
190 recorder->callback, // PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
191 (void*)recorder, // void* pUserData;
192 };
193 const VkDeviceQueueCreateInfo queueCreateInfo =
194 {
195 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
196 DE_NULL, // const void* pNext;
197 (VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
198 queueFamilyIndex, // deUint32 queueFamilyIndex;
199 queueCount, // deUint32 queueCount;
200 &queuePriority, // const float* pQueuePriorities;
201 };
202 // Enable all available features since some tests require them to be enabled, VK_IMAGE_VIEW_CUBE_ARRAY for example
203 vk::VkPhysicalDeviceFeatures2 enabledFeatures = vk::initVulkanStructure();
204 vki.getPhysicalDeviceFeatures(physicalDevice, &enabledFeatures.features);
205 const VkDeviceCreateInfo deviceCreateInfo =
206 {
207 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
208 &deviceMemoryReportCreateInfo, // const void* pNext;
209 (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
210 queueCount, // uint32_t queueCreateInfoCount;
211 &queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
212 0u, // uint32_t enabledLayerCount
213 DE_NULL, // const char* const* ppEnabledLayerNames
214 DE_LENGTH_OF_ARRAY(enabledExtensions), // uint32_t enabledExtensionCount
215 DE_ARRAY_BEGIN(enabledExtensions), // const char* const* ppEnabledExtensionNames
216 &enabledFeatures.features, // const VkPhysicalDeviceFeatures* pEnabledFeatures
217 };
218
219 return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
220 }
221
222 struct Device
223 {
224 typedef VkDevice Type;
225
226 struct Parameters
227 {
Parametersvkt::memory::__anon67ed6e6e0111::Device::Parameters228 Parameters (void) {}
229 };
230
231 struct Resources
232 {
Resourcesvkt::memory::__anon67ed6e6e0111::Device::Resources233 Resources (const Environment&, const Parameters&) {}
234 };
235
createvkt::memory::__anon67ed6e6e0111::Device236 static Move<VkDevice> create (const Environment& env, const Resources&, const Parameters&)
237 {
238 return createDeviceWithMemoryReport(env.commandLine.isValidationEnabled(), env.vkp, env.instance, env.vki, env.physicalDevice, env.queueFamilyIndex, env.recorder);
239 }
240 };
241
242 struct DeviceMemory
243 {
244 typedef VkDeviceMemory Type;
245
246 struct Parameters
247 {
248 VkDeviceSize size;
249 deUint32 memoryTypeIndex;
250
Parametersvkt::memory::__anon67ed6e6e0111::DeviceMemory::Parameters251 Parameters (VkDeviceSize size_, deUint32 memoryTypeIndex_)
252 : size (size_)
253 , memoryTypeIndex (memoryTypeIndex_)
254 {
255 DE_ASSERT(memoryTypeIndex < VK_MAX_MEMORY_TYPES);
256 }
257 };
258
259 struct Resources
260 {
Resourcesvkt::memory::__anon67ed6e6e0111::DeviceMemory::Resources261 Resources (const Environment&, const Parameters&) {}
262 };
263
createvkt::memory::__anon67ed6e6e0111::DeviceMemory264 static Move<VkDeviceMemory> create (const Environment& env, const Resources&, const Parameters& params)
265 {
266 const VkMemoryAllocateInfo memoryAllocateInfo =
267 {
268 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
269 DE_NULL, // const void* pNext;
270 params.size, // VkDeviceSize allocationSize;
271 params.memoryTypeIndex, // uint32_t memoryTypeIndex;
272 };
273
274 return allocateMemory(env.vkd, env.device, &memoryAllocateInfo);
275 }
276 };
277
getDeviceMemoryParameters(const VkMemoryRequirements & memReqs)278 DeviceMemory::Parameters getDeviceMemoryParameters (const VkMemoryRequirements& memReqs)
279 {
280 return DeviceMemory::Parameters(memReqs.size, deCtz32(memReqs.memoryTypeBits));
281 }
282
getDeviceMemoryParameters(const Environment & env,VkImage image)283 DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkImage image)
284 {
285 return getDeviceMemoryParameters(getImageMemoryRequirements(env.vkd, env.device, image));
286 }
287
getDeviceMemoryParameters(const Environment & env,VkBuffer buffer)288 DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkBuffer buffer)
289 {
290 return getDeviceMemoryParameters(getBufferMemoryRequirements(env.vkd, env.device, buffer));
291 }
292
293 struct Buffer
294 {
295 typedef VkBuffer Type;
296
297 struct Parameters
298 {
299 VkDeviceSize size;
300 VkBufferUsageFlags usage;
301
Parametersvkt::memory::__anon67ed6e6e0111::Buffer::Parameters302 Parameters (VkDeviceSize size_,
303 VkBufferUsageFlags usage_)
304 : size (size_)
305 , usage (usage_)
306 {}
307 };
308
309 struct Resources
310 {
Resourcesvkt::memory::__anon67ed6e6e0111::Buffer::Resources311 Resources (const Environment&, const Parameters&) {}
312 };
313
createvkt::memory::__anon67ed6e6e0111::Buffer314 static Move<VkBuffer> create (const Environment& env, const Resources&, const Parameters& params)
315 {
316 const VkBufferCreateInfo bufferCreateInfo =
317 {
318 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
319 DE_NULL, // const void* pNext;
320 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
321 params.size, // VkDeviceSize size;
322 params.usage, // VkBufferUsageFlags usage;
323 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
324 1u, // uint32_t queueFamilyIndexCount;
325 &env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
326 };
327
328 return createBuffer(env.vkd, env.device, &bufferCreateInfo);
329 }
330 };
331
332 struct BufferView
333 {
334 typedef VkBufferView Type;
335
336 struct Parameters
337 {
338 Buffer::Parameters buffer;
339 VkFormat format;
340 VkDeviceSize offset;
341 VkDeviceSize range;
342
Parametersvkt::memory::__anon67ed6e6e0111::BufferView::Parameters343 Parameters (const Buffer::Parameters& buffer_,
344 VkFormat format_,
345 VkDeviceSize offset_,
346 VkDeviceSize range_)
347 : buffer (buffer_)
348 , format (format_)
349 , offset (offset_)
350 , range (range_)
351 {}
352 };
353
354 struct Resources
355 {
356 Dependency<Buffer> buffer;
357 Dependency<DeviceMemory> memory;
358
Resourcesvkt::memory::__anon67ed6e6e0111::BufferView::Resources359 Resources (const Environment& env, const Parameters& params)
360 : buffer(env, params.buffer)
361 , memory(env, getDeviceMemoryParameters(env, *buffer.object))
362 {
363 VK_CHECK(env.vkd.bindBufferMemory(env.device, *buffer.object, *memory.object, 0));
364 }
365 };
366
createvkt::memory::__anon67ed6e6e0111::BufferView367 static Move<VkBufferView> create (const Environment& env, const Resources& res, const Parameters& params)
368 {
369 const VkBufferViewCreateInfo bufferViewCreateInfo =
370 {
371 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType;
372 DE_NULL, // const void* pNext;
373 (VkBufferViewCreateFlags)0, // VkBufferViewCreateFlags flags;
374 *res.buffer.object, // VkBuffer buffer;
375 params.format, // VkFormat format;
376 params.offset, // VkDeviceSize offset;
377 params.range, // VkDeviceSize range;
378 };
379
380 return createBufferView(env.vkd, env.device, &bufferViewCreateInfo);
381 }
382 };
383
384 struct Image
385 {
386 typedef VkImage Type;
387
388 struct Parameters
389 {
390 VkImageCreateFlags flags;
391 VkImageType imageType;
392 VkFormat format;
393 VkExtent3D extent;
394 deUint32 mipLevels;
395 deUint32 arraySize;
396 VkSampleCountFlagBits samples;
397 VkImageTiling tiling;
398 VkImageUsageFlags usage;
399 VkImageLayout initialLayout;
400
Parametersvkt::memory::__anon67ed6e6e0111::Image::Parameters401 Parameters (VkImageCreateFlags flags_,
402 VkImageType imageType_,
403 VkFormat format_,
404 VkExtent3D extent_,
405 deUint32 mipLevels_,
406 deUint32 arraySize_,
407 VkSampleCountFlagBits samples_,
408 VkImageTiling tiling_,
409 VkImageUsageFlags usage_,
410 VkImageLayout initialLayout_)
411 : flags (flags_)
412 , imageType (imageType_)
413 , format (format_)
414 , extent (extent_)
415 , mipLevels (mipLevels_)
416 , arraySize (arraySize_)
417 , samples (samples_)
418 , tiling (tiling_)
419 , usage (usage_)
420 , initialLayout (initialLayout_)
421 {}
422 };
423
424 struct Resources
425 {
Resourcesvkt::memory::__anon67ed6e6e0111::Image::Resources426 Resources (const Environment&, const Parameters&) {}
427 };
428
createvkt::memory::__anon67ed6e6e0111::Image429 static Move<VkImage> create (const Environment& env, const Resources&, const Parameters& params)
430 {
431 const VkImageCreateInfo imageCreateInfo =
432 {
433 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
434 DE_NULL, // const void* pNext;
435 params.flags, // VkImageCreateFlags flags;
436 params.imageType, // VkImageType imageType;
437 params.format, // VkFormat format;
438 params.extent, // VkExtent3D extent;
439 params.mipLevels, // uint32_t mipLevels;
440 params.arraySize, // uint32_t arrayLayers;
441 params.samples, // VkSampleCountFlagBits samples;
442 params.tiling, // VkImageTiling tiling;
443 params.usage, // VkImageUsageFlags usage;
444 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
445 1u, // uint32_t queueFamilyIndexCount;
446 &env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
447 params.initialLayout, // VkImageLayout initialLayout;
448 };
449
450 return createImage(env.vkd, env.device, &imageCreateInfo);
451 }
452 };
453
454 struct ImageView
455 {
456 typedef VkImageView Type;
457
458 struct Parameters
459 {
460 Image::Parameters image;
461 VkImageViewType viewType;
462 VkFormat format;
463 VkComponentMapping components;
464 VkImageSubresourceRange subresourceRange;
465
Parametersvkt::memory::__anon67ed6e6e0111::ImageView::Parameters466 Parameters (const Image::Parameters& image_,
467 VkImageViewType viewType_,
468 VkFormat format_,
469 VkComponentMapping components_,
470 VkImageSubresourceRange subresourceRange_)
471 : image (image_)
472 , viewType (viewType_)
473 , format (format_)
474 , components (components_)
475 , subresourceRange (subresourceRange_)
476 {}
477 };
478
479 struct Resources
480 {
481 Dependency<Image> image;
482 Dependency<DeviceMemory> memory;
483
Resourcesvkt::memory::__anon67ed6e6e0111::ImageView::Resources484 Resources (const Environment& env, const Parameters& params)
485 : image (env, params.image)
486 , memory(env, getDeviceMemoryParameters(env, *image.object))
487 {
488 VK_CHECK(env.vkd.bindImageMemory(env.device, *image.object, *memory.object, 0));
489 }
490 };
491
createvkt::memory::__anon67ed6e6e0111::ImageView492 static Move<VkImageView> create (const Environment& env, const Resources& res, const Parameters& params)
493 {
494 const VkImageViewCreateInfo imageViewCreateInfo =
495 {
496 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
497 DE_NULL, // const void* pNext;
498 (VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags;
499 *res.image.object, // VkImage image;
500 params.viewType, // VkImageViewType viewType;
501 params.format, // VkFormat format;
502 params.components, // VkComponentMapping components;
503 params.subresourceRange, // VkImageSubresourceRange subresourceRange;
504 };
505
506 return createImageView(env.vkd, env.device, &imageViewCreateInfo);
507 }
508 };
509
510 struct Semaphore
511 {
512 typedef VkSemaphore Type;
513
514 struct Parameters
515 {
516 VkSemaphoreCreateFlags flags;
517
Parametersvkt::memory::__anon67ed6e6e0111::Semaphore::Parameters518 Parameters (VkSemaphoreCreateFlags flags_)
519 : flags(flags_)
520 {}
521 };
522
523 struct Resources
524 {
Resourcesvkt::memory::__anon67ed6e6e0111::Semaphore::Resources525 Resources (const Environment&, const Parameters&) {}
526 };
527
createvkt::memory::__anon67ed6e6e0111::Semaphore528 static Move<VkSemaphore> create (const Environment& env, const Resources&, const Parameters& params)
529 {
530 const VkSemaphoreCreateInfo semaphoreCreateInfo =
531 {
532 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType;
533 DE_NULL, // const void* pNext;
534 params.flags, // VkSemaphoreCreateFlags flags;
535 };
536
537 return createSemaphore(env.vkd, env.device, &semaphoreCreateInfo);
538 }
539 };
540
541 struct Fence
542 {
543 typedef VkFence Type;
544
545 struct Parameters
546 {
547 VkFenceCreateFlags flags;
548
Parametersvkt::memory::__anon67ed6e6e0111::Fence::Parameters549 Parameters (VkFenceCreateFlags flags_)
550 : flags(flags_)
551 {}
552 };
553
554 struct Resources
555 {
Resourcesvkt::memory::__anon67ed6e6e0111::Fence::Resources556 Resources (const Environment&, const Parameters&) {}
557 };
558
createvkt::memory::__anon67ed6e6e0111::Fence559 static Move<VkFence> create (const Environment& env, const Resources&, const Parameters& params)
560 {
561 const VkFenceCreateInfo fenceCreateInfo =
562 {
563 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
564 DE_NULL, // const void* pNext;
565 params.flags, // VkFenceCreateFlags flags;
566 };
567
568 return createFence(env.vkd, env.device, &fenceCreateInfo);
569 }
570 };
571
572 struct Event
573 {
574 typedef VkEvent Type;
575
576 struct Parameters
577 {
578 VkEventCreateFlags flags;
579
Parametersvkt::memory::__anon67ed6e6e0111::Event::Parameters580 Parameters (VkEventCreateFlags flags_)
581 : flags(flags_)
582 {}
583 };
584
585 struct Resources
586 {
Resourcesvkt::memory::__anon67ed6e6e0111::Event::Resources587 Resources (const Environment&, const Parameters&) {}
588 };
589
createvkt::memory::__anon67ed6e6e0111::Event590 static Move<VkEvent> create (const Environment& env, const Resources&, const Parameters& params)
591 {
592 const VkEventCreateInfo eventCreateInfo =
593 {
594 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, // VkStructureType sType;
595 DE_NULL, // const void* pNext;
596 params.flags, // VkEventCreateFlags flags;
597 };
598
599 return createEvent(env.vkd, env.device, &eventCreateInfo);
600 }
601 };
602
603 struct QueryPool
604 {
605 typedef VkQueryPool Type;
606
607 struct Parameters
608 {
609 VkQueryType queryType;
610 deUint32 entryCount;
611 VkQueryPipelineStatisticFlags pipelineStatistics;
612
Parametersvkt::memory::__anon67ed6e6e0111::QueryPool::Parameters613 Parameters (VkQueryType queryType_,
614 deUint32 entryCount_,
615 VkQueryPipelineStatisticFlags pipelineStatistics_)
616 : queryType (queryType_)
617 , entryCount (entryCount_)
618 , pipelineStatistics (pipelineStatistics_)
619 {}
620 };
621
622 struct Resources
623 {
Resourcesvkt::memory::__anon67ed6e6e0111::QueryPool::Resources624 Resources (const Environment&, const Parameters&) {}
625 };
626
createvkt::memory::__anon67ed6e6e0111::QueryPool627 static Move<VkQueryPool> create (const Environment& env, const Resources&, const Parameters& params)
628 {
629 const VkQueryPoolCreateInfo queryPoolCreateInfo =
630 {
631 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
632 DE_NULL, // const void* pNext;
633 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
634 params.queryType, // VkQueryType queryType;
635 params.entryCount, // uint32_t queryCount;
636 params.pipelineStatistics, // VkQueryPipelineStatisticFlags pipelineStatistics;
637 };
638
639 return createQueryPool(env.vkd, env.device, &queryPoolCreateInfo);
640 }
641 };
642
643 struct ShaderModule
644 {
645 typedef VkShaderModule Type;
646
647 struct Parameters
648 {
649 VkShaderStageFlagBits shaderStage;
650 std::string binaryName;
651
Parametersvkt::memory::__anon67ed6e6e0111::ShaderModule::Parameters652 Parameters (VkShaderStageFlagBits shaderStage_,
653 const std::string& binaryName_)
654 : shaderStage (shaderStage_)
655 , binaryName (binaryName_)
656 {}
657 };
658
659 struct Resources
660 {
661 const ProgramBinary& binary;
662
Resourcesvkt::memory::__anon67ed6e6e0111::ShaderModule::Resources663 Resources (const Environment& env, const Parameters& params)
664 : binary(env.programBinaries.get(params.binaryName))
665 {}
666 };
667
getSourcevkt::memory::__anon67ed6e6e0111::ShaderModule668 static const char* getSource (VkShaderStageFlagBits stage)
669 {
670 switch (stage)
671 {
672 case VK_SHADER_STAGE_VERTEX_BIT:
673 return "#version 310 es\n"
674 "layout(location = 0) in highp vec4 a_position;\n"
675 "void main () { gl_Position = a_position; }\n";
676
677 case VK_SHADER_STAGE_FRAGMENT_BIT:
678 return "#version 310 es\n"
679 "layout(location = 0) out mediump vec4 o_color;\n"
680 "void main () { o_color = vec4(1.0, 0.5, 0.25, 1.0); }";
681
682 case VK_SHADER_STAGE_COMPUTE_BIT:
683 return "#version 310 es\n"
684 "layout(binding = 0) buffer Input { highp uint dataIn[]; };\n"
685 "layout(binding = 1) buffer Output { highp uint dataOut[]; };\n"
686 "void main (void)\n"
687 "{\n"
688 " dataOut[gl_GlobalInvocationID.x] = ~dataIn[gl_GlobalInvocationID.x];\n"
689 "}\n";
690
691 default:
692 DE_FATAL("Not implemented");
693 return DE_NULL;
694 }
695 }
696
initProgramsvkt::memory::__anon67ed6e6e0111::ShaderModule697 static void initPrograms (SourceCollections& dst, Parameters params)
698 {
699 const char* const source = getSource(params.shaderStage);
700
701 DE_ASSERT(source);
702
703 dst.glslSources.add(params.binaryName)
704 << glu::ShaderSource(getGluShaderType(params.shaderStage), source);
705 }
706
createvkt::memory::__anon67ed6e6e0111::ShaderModule707 static Move<VkShaderModule> create (const Environment& env, const Resources& res, const Parameters&)
708 {
709 const VkShaderModuleCreateInfo shaderModuleCreateInfo =
710 {
711 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
712 DE_NULL, // const void* pNext;
713 (VkShaderModuleCreateFlags)0, // VkShaderModuleCreateFlags flags;
714 res.binary.getSize(), // size_t codeSize;
715 (const deUint32*)res.binary.getBinary(), // const uint32_t* pCode;
716 };
717
718 return createShaderModule(env.vkd, env.device, &shaderModuleCreateInfo);
719 }
720 };
721
722 struct PipelineCache
723 {
724 typedef VkPipelineCache Type;
725
726 struct Parameters
727 {
Parametersvkt::memory::__anon67ed6e6e0111::PipelineCache::Parameters728 Parameters (void) {}
729 };
730
731 struct Resources
732 {
Resourcesvkt::memory::__anon67ed6e6e0111::PipelineCache::Resources733 Resources (const Environment&, const Parameters&) {}
734 };
735
createvkt::memory::__anon67ed6e6e0111::PipelineCache736 static Move<VkPipelineCache> create (const Environment& env, const Resources&, const Parameters&)
737 {
738 const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
739 {
740 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
741 DE_NULL, // const void* pNext;
742 #ifndef CTS_USES_VULKANSC
743 (VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
744 0, // size_t initialDataSize;
745 DE_NULL // const void* pInitialData;
746 #else
747 VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT |
748 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT, // VkPipelineCacheCreateFlags flags;
749 env.resourceInterface->getCacheDataSize(), // deUintptr initialDataSize;
750 env.resourceInterface->getCacheData() // const void* pInitialData;
751 #endif // CTS_USES_VULKANSC
752 };
753
754 return createPipelineCache(env.vkd, env.device, &pipelineCacheCreateInfo);
755 }
756 };
757
758 struct Sampler
759 {
760 typedef VkSampler Type;
761
762 struct Parameters
763 {
764 VkFilter magFilter;
765 VkFilter minFilter;
766 VkSamplerMipmapMode mipmapMode;
767 VkSamplerAddressMode addressModeU;
768 VkSamplerAddressMode addressModeV;
769 VkSamplerAddressMode addressModeW;
770 float mipLodBias;
771 VkBool32 anisotropyEnable;
772 float maxAnisotropy;
773 VkBool32 compareEnable;
774 VkCompareOp compareOp;
775 float minLod;
776 float maxLod;
777 VkBorderColor borderColor;
778 VkBool32 unnormalizedCoordinates;
779
Parametersvkt::memory::__anon67ed6e6e0111::Sampler::Parameters780 Parameters (void)
781 : magFilter (VK_FILTER_NEAREST)
782 , minFilter (VK_FILTER_NEAREST)
783 , mipmapMode (VK_SAMPLER_MIPMAP_MODE_NEAREST)
784 , addressModeU (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
785 , addressModeV (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
786 , addressModeW (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
787 , mipLodBias (0.0f)
788 , anisotropyEnable (VK_FALSE)
789 , maxAnisotropy (1.0f)
790 , compareEnable (VK_FALSE)
791 , compareOp (VK_COMPARE_OP_ALWAYS)
792 , minLod (-1000.f)
793 , maxLod (+1000.f)
794 , borderColor (VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK)
795 , unnormalizedCoordinates (VK_FALSE)
796 {}
797 };
798
799 struct Resources
800 {
Resourcesvkt::memory::__anon67ed6e6e0111::Sampler::Resources801 Resources (const Environment&, const Parameters&) {}
802 };
803
createvkt::memory::__anon67ed6e6e0111::Sampler804 static Move<VkSampler> create (const Environment& env, const Resources&, const Parameters& params)
805 {
806 const VkSamplerCreateInfo samplerCreateInfo =
807 {
808 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
809 DE_NULL, // const void* pNext;
810 (VkSamplerCreateFlags)0, // VkSamplerCreateFlags flags;
811 params.magFilter, // VkFilter magFilter;
812 params.minFilter, // VkFilter minFilter;
813 params.mipmapMode, // VkSamplerMipmapMode mipmapMode;
814 params.addressModeU, // VkSamplerAddressMode addressModeU;
815 params.addressModeV, // VkSamplerAddressMode addressModeV;
816 params.addressModeW, // VkSamplerAddressMode addressModeW;
817 params.mipLodBias, // float mipLodBias;
818 params.anisotropyEnable, // VkBool32 anisotropyEnable;
819 params.maxAnisotropy, // float maxAnisotropy;
820 params.compareEnable, // VkBool32 compareEnable;
821 params.compareOp, // VkCompareOp compareOp;
822 params.minLod, // float minLod;
823 params.maxLod, // float maxLod;
824 params.borderColor, // VkBorderColor borderColor;
825 params.unnormalizedCoordinates, // VkBool32 unnormalizedCoordinates;
826 };
827
828 return createSampler(env.vkd, env.device, &samplerCreateInfo);
829 }
830 };
831
832 struct DescriptorSetLayout
833 {
834 typedef VkDescriptorSetLayout Type;
835
836 struct Parameters
837 {
838 struct Binding
839 {
840 deUint32 binding;
841 VkDescriptorType descriptorType;
842 deUint32 descriptorCount;
843 VkShaderStageFlags stageFlags;
844 bool useImmutableSampler;
845
Bindingvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Parameters::Binding846 Binding (deUint32 binding_,
847 VkDescriptorType descriptorType_,
848 deUint32 descriptorCount_,
849 VkShaderStageFlags stageFlags_,
850 bool useImmutableSampler_)
851 : binding (binding_)
852 , descriptorType (descriptorType_)
853 , descriptorCount (descriptorCount_)
854 , stageFlags (stageFlags_)
855 , useImmutableSampler (useImmutableSampler_)
856 {}
857
Bindingvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Parameters::Binding858 Binding (void) {}
859 };
860
861 std::vector<Binding> bindings;
862
Parametersvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Parameters863 Parameters (const std::vector<Binding>& bindings_)
864 : bindings(bindings_)
865 {}
866
emptyvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Parameters867 static Parameters empty (void)
868 {
869 return Parameters(std::vector<Binding>());
870 }
871
singlevkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Parameters872 static Parameters single (deUint32 binding,
873 VkDescriptorType descriptorType,
874 deUint32 descriptorCount,
875 VkShaderStageFlags stageFlags,
876 bool useImmutableSampler = false)
877 {
878 std::vector<Binding> bindings;
879 bindings.push_back(Binding(binding, descriptorType, descriptorCount, stageFlags, useImmutableSampler));
880 return Parameters(bindings);
881 }
882 };
883
884 struct Resources
885 {
886 std::vector<VkDescriptorSetLayoutBinding> bindings;
887 MovePtr<Dependency<Sampler>> immutableSampler;
888 std::vector<VkSampler> immutableSamplersPtr;
889
Resourcesvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout::Resources890 Resources (const Environment& env, const Parameters& params)
891 {
892 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
893 {
894 if (cur->useImmutableSampler && !immutableSampler)
895 {
896 immutableSampler = de::newMovePtr<Dependency<Sampler>>(env, Sampler::Parameters());
897
898 if (cur->useImmutableSampler && immutableSamplersPtr.size() < (size_t)cur->descriptorCount)
899 immutableSamplersPtr.resize(cur->descriptorCount, *immutableSampler->object);
900 }
901 }
902
903 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
904 {
905 const VkDescriptorSetLayoutBinding binding =
906 {
907 cur->binding, // uint32_t binding;
908 cur->descriptorType, // VkDescriptorType descriptorType;
909 cur->descriptorCount, // uint32_t descriptorCount;
910 cur->stageFlags, // VkShaderStageFlags stageFlags;
911 (cur->useImmutableSampler ? &immutableSamplersPtr[0] : DE_NULL), // const VkSampler* pImmutableSamplers;
912 };
913
914 bindings.push_back(binding);
915 }
916 }
917 };
918
createvkt::memory::__anon67ed6e6e0111::DescriptorSetLayout919 static Move<VkDescriptorSetLayout> create (const Environment& env, const Resources& res, const Parameters&)
920 {
921 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
922 {
923 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
924 DE_NULL, // const void* pNext;
925 (VkDescriptorSetLayoutCreateFlags)0, // VkDescriptorSetLayoutCreateFlags flags;
926 (deUint32)res.bindings.size(), // uint32_t bindingCount;
927 (res.bindings.empty() ? DE_NULL : &res.bindings[0]), // const VkDescriptorSetLayoutBinding* pBindings;
928 };
929
930 return createDescriptorSetLayout(env.vkd, env.device, &descriptorSetLayoutCreateInfo);
931 }
932 };
933
934 struct PipelineLayout
935 {
936 typedef VkPipelineLayout Type;
937
938 struct Parameters
939 {
940 std::vector<DescriptorSetLayout::Parameters> descriptorSetLayouts;
941 std::vector<VkPushConstantRange> pushConstantRanges;
942
Parametersvkt::memory::__anon67ed6e6e0111::PipelineLayout::Parameters943 Parameters (void) {}
944
emptyvkt::memory::__anon67ed6e6e0111::PipelineLayout::Parameters945 static Parameters empty (void)
946 {
947 return Parameters();
948 }
949
singleDescriptorSetvkt::memory::__anon67ed6e6e0111::PipelineLayout::Parameters950 static Parameters singleDescriptorSet (const DescriptorSetLayout::Parameters& descriptorSetLayout)
951 {
952 Parameters params;
953 params.descriptorSetLayouts.push_back(descriptorSetLayout);
954 return params;
955 }
956 };
957
958 struct Resources
959 {
960 typedef SharedPtr<Dependency<DescriptorSetLayout>> DescriptorSetLayoutDepSp;
961 typedef std::vector<DescriptorSetLayoutDepSp> DescriptorSetLayouts;
962
963 DescriptorSetLayouts descriptorSetLayouts;
964 std::vector<VkDescriptorSetLayout> pSetLayouts;
965
Resourcesvkt::memory::__anon67ed6e6e0111::PipelineLayout::Resources966 Resources (const Environment& env, const Parameters& params)
967 {
968 for (std::vector<DescriptorSetLayout::Parameters>::const_iterator dsParams = params.descriptorSetLayouts.begin();
969 dsParams != params.descriptorSetLayouts.end();
970 ++dsParams)
971 {
972 descriptorSetLayouts.push_back(DescriptorSetLayoutDepSp(new Dependency<DescriptorSetLayout>(env, *dsParams)));
973 pSetLayouts.push_back(*descriptorSetLayouts.back()->object);
974 }
975 }
976 };
977
createvkt::memory::__anon67ed6e6e0111::PipelineLayout978 static Move<VkPipelineLayout> create (const Environment& env, const Resources& res, const Parameters& params)
979 {
980 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
981 {
982 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
983 DE_NULL, // const void* pNext;
984 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
985 (deUint32)res.pSetLayouts.size(), // uint32_t setLayoutCount;
986 (res.pSetLayouts.empty() ? DE_NULL : &res.pSetLayouts[0]), // const VkDescriptorSetLayout* pSetLayouts;
987 (deUint32)params.pushConstantRanges.size(), // uint32_t pushConstantRangeCount;
988 (params.pushConstantRanges.empty() ? DE_NULL : ¶ms.pushConstantRanges[0]), // const VkPushConstantRange* pPushConstantRanges;
989 };
990
991 return createPipelineLayout(env.vkd, env.device, &pipelineLayoutCreateInfo);
992 }
993 };
994
995 struct RenderPass
996 {
997 typedef VkRenderPass Type;
998
999 struct Parameters
1000 {
Parametersvkt::memory::__anon67ed6e6e0111::RenderPass::Parameters1001 Parameters (void) {}
1002 };
1003
1004 struct Resources
1005 {
Resourcesvkt::memory::__anon67ed6e6e0111::RenderPass::Resources1006 Resources (const Environment&, const Parameters&) {}
1007 };
1008
createvkt::memory::__anon67ed6e6e0111::RenderPass1009 static Move<VkRenderPass> create (const Environment& env, const Resources&, const Parameters&)
1010 {
1011 return makeRenderPass(env.vkd, env.device, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_D16_UNORM,
1012 VK_ATTACHMENT_LOAD_OP_CLEAR,
1013 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1014 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1015 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1016 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
1017 }
1018 };
1019
1020 struct GraphicsPipeline
1021 {
1022 typedef VkPipeline Type;
1023
1024 struct Parameters
1025 {
Parametersvkt::memory::__anon67ed6e6e0111::GraphicsPipeline::Parameters1026 Parameters (void) {}
1027 };
1028
1029 struct Resources
1030 {
1031 Dependency<ShaderModule> vertexShader;
1032 Dependency<ShaderModule> fragmentShader;
1033 Dependency<PipelineLayout> layout;
1034 Dependency<RenderPass> renderPass;
1035 Dependency<PipelineCache> pipelineCache;
1036
Resourcesvkt::memory::__anon67ed6e6e0111::GraphicsPipeline::Resources1037 Resources (const Environment& env, const Parameters&)
1038 : vertexShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"))
1039 , fragmentShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"))
1040 , layout (env, PipelineLayout::Parameters::singleDescriptorSet(
1041 DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u, VK_SHADER_STAGE_FRAGMENT_BIT, true)))
1042 , renderPass (env, RenderPass::Parameters())
1043 , pipelineCache (env, PipelineCache::Parameters())
1044 {}
1045 };
1046
initProgramsvkt::memory::__anon67ed6e6e0111::GraphicsPipeline1047 static void initPrograms (SourceCollections& dst, Parameters)
1048 {
1049 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"));
1050 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"));
1051 }
1052
createvkt::memory::__anon67ed6e6e0111::GraphicsPipeline1053 static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
1054 {
1055 const VkPipelineShaderStageCreateInfo stages[] =
1056 {
1057 {
1058 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1059 DE_NULL, // const void* pNext;
1060 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1061 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1062 *res.vertexShader.object, // VkShaderModule module;
1063 "main", // const char* pName;
1064 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1065 },
1066 {
1067 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1068 DE_NULL, // const void* pNext;
1069 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1070 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1071 *res.fragmentShader.object, // VkShaderModule module;
1072 "main", // const char* pName;
1073 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1074 }
1075 };
1076 const VkVertexInputBindingDescription vertexBindings[] =
1077 {
1078 {
1079 0u, // uint32_t binding;
1080 16u, // uint32_t stride;
1081 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
1082 }
1083 };
1084 const VkVertexInputAttributeDescription vertexAttribs[] =
1085 {
1086 {
1087 0u, // uint32_t location;
1088 0u, // uint32_t binding;
1089 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1090 0u, // uint32_t offset;
1091 }
1092 };
1093 const VkPipelineVertexInputStateCreateInfo vertexInputState =
1094 {
1095 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1096 DE_NULL, // const void* pNext;
1097 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1098 DE_LENGTH_OF_ARRAY(vertexBindings), // uint32_t vertexBindingDescriptionCount;
1099 vertexBindings, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1100 DE_LENGTH_OF_ARRAY(vertexAttribs), // uint32_t vertexAttributeDescriptionCount;
1101 vertexAttribs, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1102 };
1103 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
1104 {
1105 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1106 DE_NULL, // const void* pNext;
1107 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1108 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1109 VK_FALSE, // VkBool32 primitiveRestartEnable;
1110 };
1111 const VkViewport viewport = makeViewport(tcu::UVec2(64));
1112 const VkRect2D scissor = makeRect2D(tcu::UVec2(64));
1113
1114 const VkPipelineViewportStateCreateInfo viewportState =
1115 {
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 {
1126 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1127 DE_NULL, // const void* pNext;
1128 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1129 VK_FALSE, // VkBool32 depthClampEnable;
1130 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1131 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1132 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
1133 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
1134 VK_FALSE, // VkBool32 depthBiasEnable;
1135 0.0f, // float depthBiasConstantFactor;
1136 0.0f, // float depthBiasClamp;
1137 0.0f, // float depthBiasSlopeFactor;
1138 1.0f, // float lineWidth;
1139 };
1140 const VkPipelineMultisampleStateCreateInfo multisampleState =
1141 {
1142 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1143 DE_NULL, // const void* pNext;
1144 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
1145 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
1146 VK_FALSE, // VkBool32 sampleShadingEnable;
1147 1.0f, // float minSampleShading;
1148 DE_NULL, // const VkSampleMask* pSampleMask;
1149 VK_FALSE, // VkBool32 alphaToCoverageEnable;
1150 VK_FALSE, // VkBool32 alphaToOneEnable;
1151 };
1152 const VkPipelineDepthStencilStateCreateInfo depthStencilState =
1153 {
1154 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1155 DE_NULL, // const void* pNext;
1156 (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
1157 VK_TRUE, // VkBool32 depthTestEnable;
1158 VK_TRUE, // VkBool32 depthWriteEnable;
1159 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
1160 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1161 VK_FALSE, // VkBool32 stencilTestEnable;
1162 {
1163 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1164 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1165 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1166 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1167 0u, // uint32_t compareMask;
1168 0u, // uint32_t writeMask;
1169 0u, // uint32_t reference;
1170 },
1171 {
1172 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1173 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1174 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1175 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1176 0u, // uint32_t compareMask;
1177 0u, // uint32_t writeMask;
1178 0u, // uint32_t reference;
1179 },
1180 0.0f, // float minDepthBounds;
1181 1.0f, // float maxDepthBounds;
1182 };
1183 const VkPipelineColorBlendAttachmentState colorBlendAttState[]=
1184 {
1185 {
1186 VK_FALSE, // VkBool32 blendEnable;
1187 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
1188 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
1189 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1190 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
1191 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
1192 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1193 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
1194 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, // VkColorComponentFlags colorWriteMask;
1195 }
1196 };
1197 const VkPipelineColorBlendStateCreateInfo colorBlendState =
1198 {
1199 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1200 DE_NULL, // const void* pNext;
1201 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
1202 VK_FALSE, // VkBool32 logicOpEnable;
1203 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1204 DE_LENGTH_OF_ARRAY(colorBlendAttState), // uint32_t attachmentCount;
1205 colorBlendAttState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1206 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
1207 };
1208 const VkGraphicsPipelineCreateInfo pipelineCreateInfo =
1209 {
1210 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1211 DE_NULL, // const void* pNext;
1212 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1213 DE_LENGTH_OF_ARRAY(stages), // uint32_t stageCount;
1214 stages, // const VkPipelineShaderStageCreateInfo* pStages;
1215 &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1216 &inputAssemblyState, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1217 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1218 &viewportState, // const VkPipelineViewportStateCreateInfo* pViewportState;
1219 &rasterState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1220 &multisampleState, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1221 &depthStencilState, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1222 &colorBlendState, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1223 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1224 *res.layout.object, // VkPipelineLayout layout;
1225 *res.renderPass.object, // VkRenderPass renderPass;
1226 0u, // uint32_t subpass;
1227 (VkPipeline)0, // VkPipeline basePipelineHandle;
1228 0, // int32_t basePipelineIndex;
1229 };
1230
1231 return createGraphicsPipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1232 }
1233 };
1234
1235 struct ComputePipeline
1236 {
1237 typedef VkPipeline Type;
1238
1239 struct Parameters
1240 {
Parametersvkt::memory::__anon67ed6e6e0111::ComputePipeline::Parameters1241 Parameters (void) {}
1242 };
1243
1244 struct Resources
1245 {
1246 Dependency<ShaderModule> shaderModule;
1247 Dependency<PipelineLayout> layout;
1248 Dependency<PipelineCache> pipelineCache;
1249
getDescriptorSetLayoutvkt::memory::__anon67ed6e6e0111::ComputePipeline::Resources1250 static DescriptorSetLayout::Parameters getDescriptorSetLayout (void)
1251 {
1252 typedef DescriptorSetLayout::Parameters::Binding Binding;
1253
1254 std::vector<Binding> bindings;
1255
1256 bindings.push_back(Binding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1257 bindings.push_back(Binding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1258
1259 return DescriptorSetLayout::Parameters(bindings);
1260 }
1261
Resourcesvkt::memory::__anon67ed6e6e0111::ComputePipeline::Resources1262 Resources (const Environment& env, const Parameters&)
1263 : shaderModule (env, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"))
1264 , layout (env, PipelineLayout::Parameters::singleDescriptorSet(getDescriptorSetLayout()))
1265 , pipelineCache (env, PipelineCache::Parameters())
1266 {}
1267 };
1268
initProgramsvkt::memory::__anon67ed6e6e0111::ComputePipeline1269 static void initPrograms (SourceCollections& dst, Parameters)
1270 {
1271 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"));
1272 }
1273
createvkt::memory::__anon67ed6e6e0111::ComputePipeline1274 static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
1275 {
1276 const VkComputePipelineCreateInfo pipelineCreateInfo =
1277 {
1278 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1279 DE_NULL, // const void* pNext;
1280 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1281 {
1282 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1283 DE_NULL, // const void* pNext;
1284 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1285 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1286 *res.shaderModule.object, // VkShaderModule module;
1287 "main", // const char* pName;
1288 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1289 },
1290 *res.layout.object, // VkPipelineLayout layout;
1291 (VkPipeline)0, // VkPipeline basePipelineHandle;
1292 0u, // int32_t basePipelineIndex;
1293 };
1294
1295 return createComputePipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1296 }
1297 };
1298
1299 struct DescriptorPool
1300 {
1301 typedef VkDescriptorPool Type;
1302
1303 struct Parameters
1304 {
1305 VkDescriptorPoolCreateFlags flags;
1306 deUint32 maxSets;
1307 std::vector<VkDescriptorPoolSize> poolSizes;
1308
Parametersvkt::memory::__anon67ed6e6e0111::DescriptorPool::Parameters1309 Parameters (VkDescriptorPoolCreateFlags flags_,
1310 deUint32 maxSets_,
1311 const std::vector<VkDescriptorPoolSize>& poolSizes_)
1312 : flags (flags_)
1313 , maxSets (maxSets_)
1314 , poolSizes (poolSizes_)
1315 {}
1316
singleTypevkt::memory::__anon67ed6e6e0111::DescriptorPool::Parameters1317 static Parameters singleType (VkDescriptorPoolCreateFlags flags,
1318 deUint32 maxSets,
1319 VkDescriptorType type,
1320 deUint32 count)
1321 {
1322 std::vector<VkDescriptorPoolSize> poolSizes;
1323 poolSizes.push_back(makeDescriptorPoolSize(type, count));
1324 return Parameters(flags, maxSets, poolSizes);
1325 }
1326 };
1327
1328 struct Resources
1329 {
Resourcesvkt::memory::__anon67ed6e6e0111::DescriptorPool::Resources1330 Resources (const Environment&, const Parameters&) {}
1331 };
1332
createvkt::memory::__anon67ed6e6e0111::DescriptorPool1333 static Move<VkDescriptorPool> create (const Environment& env, const Resources&, const Parameters& params)
1334 {
1335 const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
1336 {
1337 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
1338 DE_NULL, // const void* pNext;
1339 params.flags, // VkDescriptorPoolCreateFlags flags;
1340 params.maxSets, // uint32_t maxSets;
1341 (deUint32)params.poolSizes.size(), // uint32_t poolSizeCount;
1342 (params.poolSizes.empty() ? DE_NULL : ¶ms.poolSizes[0]), // const VkDescriptorPoolSize* pPoolSizes;
1343 };
1344
1345 return createDescriptorPool(env.vkd, env.device, &descriptorPoolCreateInfo);
1346 }
1347 };
1348
1349 struct DescriptorSet
1350 {
1351 typedef VkDescriptorSet Type;
1352
1353 struct Parameters
1354 {
1355 DescriptorSetLayout::Parameters descriptorSetLayout;
1356
Parametersvkt::memory::__anon67ed6e6e0111::DescriptorSet::Parameters1357 Parameters (const DescriptorSetLayout::Parameters& descriptorSetLayout_)
1358 : descriptorSetLayout(descriptorSetLayout_)
1359 {}
1360 };
1361
1362 struct Resources
1363 {
1364 Dependency<DescriptorPool> descriptorPool;
1365 Dependency<DescriptorSetLayout> descriptorSetLayout;
1366
computePoolSizesvkt::memory::__anon67ed6e6e0111::DescriptorSet::Resources1367 static std::vector<VkDescriptorPoolSize> computePoolSizes (const DescriptorSetLayout::Parameters& layout, int maxSets)
1368 {
1369 deUint32 countByType[VK_DESCRIPTOR_TYPE_LAST];
1370 std::vector<VkDescriptorPoolSize> typeCounts;
1371
1372 std::fill(DE_ARRAY_BEGIN(countByType), DE_ARRAY_END(countByType), 0u);
1373
1374 for (std::vector<DescriptorSetLayout::Parameters::Binding>::const_iterator cur = layout.bindings.begin(); cur != layout.bindings.end(); cur++)
1375 {
1376 DE_ASSERT((deUint32)cur->descriptorType < VK_DESCRIPTOR_TYPE_LAST);
1377 countByType[cur->descriptorType] += cur->descriptorCount * maxSets;
1378 }
1379
1380 for (deUint32 type = 0; type < VK_DESCRIPTOR_TYPE_LAST; type++)
1381 {
1382 if (countByType[type] > 0)
1383 typeCounts.push_back(makeDescriptorPoolSize((VkDescriptorType)type, countByType[type]));
1384 }
1385
1386 return typeCounts;
1387 }
1388
Resourcesvkt::memory::__anon67ed6e6e0111::DescriptorSet::Resources1389 Resources (const Environment& env, const Parameters& params)
1390 : descriptorPool (env, DescriptorPool::Parameters(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u, computePoolSizes(params.descriptorSetLayout, 1u)))
1391 , descriptorSetLayout (env, params.descriptorSetLayout)
1392 {
1393 }
1394 };
1395
createvkt::memory::__anon67ed6e6e0111::DescriptorSet1396 static Move<VkDescriptorSet> create (const Environment& env, const Resources& res, const Parameters&)
1397 {
1398 const VkDescriptorSetAllocateInfo allocateInfo =
1399 {
1400 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
1401 DE_NULL, // const void* pNext;
1402 *res.descriptorPool.object, // VkDescriptorPool descriptorPool;
1403 1u, // uint32_t descriptorSetCount;
1404 &(*res.descriptorSetLayout.object), // const VkDescriptorSetLayout* pSetLayouts;
1405 };
1406
1407 return allocateDescriptorSet(env.vkd, env.device, &allocateInfo);
1408 }
1409 };
1410
1411 struct Framebuffer
1412 {
1413 typedef VkFramebuffer Type;
1414
1415 struct Parameters
1416 {
Parametersvkt::memory::__anon67ed6e6e0111::Framebuffer::Parameters1417 Parameters (void)
1418 {}
1419 };
1420
1421 struct Resources
1422 {
1423 Dependency<ImageView> colorAttachment;
1424 Dependency<ImageView> depthStencilAttachment;
1425 Dependency<RenderPass> renderPass;
1426
Resourcesvkt::memory::__anon67ed6e6e0111::Framebuffer::Resources1427 Resources (const Environment& env, const Parameters&)
1428 : colorAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
1429 makeExtent3D(256, 256, 1),
1430 1u, 1u,
1431 VK_SAMPLE_COUNT_1_BIT,
1432 VK_IMAGE_TILING_OPTIMAL,
1433 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1434 VK_IMAGE_LAYOUT_UNDEFINED),
1435 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
1436 makeComponentMappingRGBA(),
1437 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)))
1438 , depthStencilAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM,
1439 makeExtent3D(256, 256, 1),
1440 1u, 1u,
1441 VK_SAMPLE_COUNT_1_BIT,
1442 VK_IMAGE_TILING_OPTIMAL,
1443 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1444 VK_IMAGE_LAYOUT_UNDEFINED),
1445 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM,
1446 makeComponentMappingRGBA(),
1447 makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u)))
1448 , renderPass (env, RenderPass::Parameters())
1449 {}
1450 };
1451
createvkt::memory::__anon67ed6e6e0111::Framebuffer1452 static Move<VkFramebuffer> create (const Environment& env, const Resources& res, const Parameters&)
1453 {
1454 const VkImageView attachments[] =
1455 {
1456 *res.colorAttachment.object,
1457 *res.depthStencilAttachment.object,
1458 };
1459 const VkFramebufferCreateInfo framebufferCreateInfo =
1460 {
1461 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1462 DE_NULL, // const void* pNext;
1463 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
1464 *res.renderPass.object, // VkRenderPass renderPass;
1465 (deUint32)DE_LENGTH_OF_ARRAY(attachments), // uint32_t attachmentCount;
1466 attachments, // const VkImageView* pAttachments;
1467 256u, // uint32_t width;
1468 256u, // uint32_t height;
1469 1u, // uint32_t layers;
1470 };
1471
1472 return createFramebuffer(env.vkd, env.device, &framebufferCreateInfo);
1473 }
1474 };
1475
1476 struct CommandPool
1477 {
1478 typedef VkCommandPool Type;
1479
1480 struct Parameters
1481 {
1482 VkCommandPoolCreateFlags flags;
1483
Parametersvkt::memory::__anon67ed6e6e0111::CommandPool::Parameters1484 Parameters (VkCommandPoolCreateFlags flags_)
1485 : flags(flags_)
1486 {}
1487 };
1488
1489 struct Resources
1490 {
Resourcesvkt::memory::__anon67ed6e6e0111::CommandPool::Resources1491 Resources (const Environment&, const Parameters&) {}
1492 };
1493
createvkt::memory::__anon67ed6e6e0111::CommandPool1494 static Move<VkCommandPool> create (const Environment& env, const Resources&, const Parameters& params)
1495 {
1496 const VkCommandPoolCreateInfo commandPoolCreateInfo =
1497 {
1498 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
1499 DE_NULL, // const void* pNext;
1500 params.flags, // VkCommandPoolCreateFlags flags;
1501 env.queueFamilyIndex, // uint32_t queueFamilyIndex;
1502 };
1503
1504 return createCommandPool(env.vkd, env.device, &commandPoolCreateInfo);
1505 }
1506 };
1507
1508 struct CommandBuffer
1509 {
1510 typedef VkCommandBuffer Type;
1511
1512 struct Parameters
1513 {
1514 CommandPool::Parameters commandPool;
1515 VkCommandBufferLevel level;
1516
Parametersvkt::memory::__anon67ed6e6e0111::CommandBuffer::Parameters1517 Parameters (const CommandPool::Parameters& commandPool_,
1518 VkCommandBufferLevel level_)
1519 : commandPool (commandPool_)
1520 , level (level_)
1521 {}
1522 };
1523
1524 struct Resources
1525 {
1526 Dependency<CommandPool> commandPool;
1527
Resourcesvkt::memory::__anon67ed6e6e0111::CommandBuffer::Resources1528 Resources (const Environment& env, const Parameters& params)
1529 : commandPool(env, params.commandPool)
1530 {}
1531 };
1532
createvkt::memory::__anon67ed6e6e0111::CommandBuffer1533 static Move<VkCommandBuffer> create (const Environment& env, const Resources& res, const Parameters& params)
1534 {
1535 const VkCommandBufferAllocateInfo allocateInfo =
1536 {
1537 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
1538 DE_NULL, // const void* pNext;
1539 *res.commandPool.object, // VkCommandPool commandPool;
1540 params.level, // VkCommandBufferLevel level;
1541 1, // uint32_t commandBufferCount;
1542 };
1543
1544 return allocateCommandBuffer(env.vkd, env.device, &allocateInfo);
1545 }
1546 };
1547
1548 template<typename Object>
1549 struct NamedParameters
1550 {
1551 const char* name;
1552 typename Object::Parameters parameters;
1553 };
1554
1555 template<typename Object>
1556 struct CaseDescription
1557 {
1558 typename FunctionInstance1<typename Object::Parameters>::Function function;
1559 const NamedParameters<Object>* paramsBegin;
1560 const NamedParameters<Object>* paramsEnd;
1561 };
1562
1563 #define CASE_DESC(FUNCTION, CASES) \
1564 { FUNCTION, DE_ARRAY_BEGIN(CASES), DE_ARRAY_END(CASES) }
1565
1566 struct CaseDescriptions
1567 {
1568 CaseDescription<Device> device;
1569 CaseDescription<DeviceMemory> deviceMemory;
1570 CaseDescription<Buffer> buffer;
1571 CaseDescription<BufferView> bufferView;
1572 CaseDescription<Image> image;
1573 CaseDescription<ImageView> imageView;
1574 CaseDescription<Semaphore> semaphore;
1575 CaseDescription<Event> event;
1576 CaseDescription<Fence> fence;
1577 CaseDescription<QueryPool> queryPool;
1578 CaseDescription<ShaderModule> shaderModule;
1579 CaseDescription<PipelineCache> pipelineCache;
1580 CaseDescription<Sampler> sampler;
1581 CaseDescription<DescriptorSetLayout> descriptorSetLayout;
1582 CaseDescription<PipelineLayout> pipelineLayout;
1583 CaseDescription<RenderPass> renderPass;
1584 CaseDescription<GraphicsPipeline> graphicsPipeline;
1585 CaseDescription<ComputePipeline> computePipeline;
1586 CaseDescription<DescriptorPool> descriptorPool;
1587 CaseDescription<DescriptorSet> descriptorSet;
1588 CaseDescription<Framebuffer> framebuffer;
1589 CaseDescription<CommandPool> commandPool;
1590 CaseDescription<CommandBuffer> commandBuffer;
1591 };
1592
checkSupport(Context & context)1593 static void checkSupport(Context& context)
1594 {
1595 const auto& extensions = enumerateCachedDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice());
1596
1597 for (size_t extNdx = 0; extNdx < extensions.size(); extNdx++)
1598 {
1599 if (deStringEqual("VK_EXT_device_memory_report", extensions[extNdx].extensionName))
1600 {
1601 VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
1602 {
1603 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
1604 DE_NULL,
1605 VK_FALSE
1606 };
1607
1608 VkPhysicalDeviceFeatures2 availFeatures;
1609 availFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1610 availFeatures.pNext = &deviceMemoryReportFeatures;
1611
1612 context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &availFeatures);
1613
1614 if (deviceMemoryReportFeatures.deviceMemoryReport == VK_FALSE)
1615 {
1616 TCU_THROW(NotSupportedError, "VK_EXT_device_memory_report not supported");
1617 }
1618 return;
1619 }
1620 }
1621
1622 TCU_THROW(NotSupportedError, "VK_EXT_device_memory_report not supported");
1623 }
1624
1625 template<typename Object>
checkSupport(Context & context,typename Object::Parameters)1626 void checkSupport (Context& context, typename Object::Parameters)
1627 {
1628 checkSupport(context);
1629 }
1630
1631 template<>
checkSupport(Context & context,ImageView::Parameters parameters)1632 void checkSupport<ImageView> (Context& context, ImageView::Parameters parameters)
1633 {
1634 if (parameters.viewType == vk::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
1635 context.requireDeviceCoreFeature(vkt::DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY);
1636
1637 context.requireDeviceFunctionality("VK_EXT_device_memory_report");
1638 }
1639
1640 template<typename Object>
addCases(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1641 void addCases (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
1642 {
1643 for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1644 {
1645 addFunctionCase(group.get(), cur->name, checkSupport<Object>, cases.function, cur->parameters);
1646 }
1647 }
1648
1649 template<typename Object>
addCasesWithProgs(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1650 void addCasesWithProgs (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
1651 {
1652 for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1653 {
1654 addFunctionCaseWithPrograms(group.get(), cur->name, checkSupport<Object>, Object::initPrograms, cases.function, cur->parameters);
1655 }
1656 }
1657
createObjectTestsGroup(tcu::TestContext & testCtx,const char * name,const CaseDescriptions & cases)1658 tcu::TestCaseGroup* createObjectTestsGroup (tcu::TestContext& testCtx, const char* name, const CaseDescriptions& cases)
1659 {
1660 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name));
1661
1662 addCases (group, cases.device);
1663 addCases (group, cases.deviceMemory);
1664 addCases (group, cases.buffer);
1665 addCases (group, cases.bufferView);
1666 addCases (group, cases.image);
1667 addCases (group, cases.imageView);
1668 addCases (group, cases.semaphore);
1669 addCases (group, cases.event);
1670 addCases (group, cases.fence);
1671 addCases (group, cases.queryPool);
1672 addCasesWithProgs (group, cases.shaderModule);
1673 addCases (group, cases.pipelineCache);
1674 addCases (group, cases.sampler);
1675 addCases (group, cases.descriptorSetLayout);
1676 addCases (group, cases.pipelineLayout);
1677 addCases (group, cases.renderPass);
1678 addCasesWithProgs (group, cases.graphicsPipeline);
1679 addCasesWithProgs (group, cases.computePipeline);
1680 addCases (group, cases.descriptorPool);
1681 addCases (group, cases.descriptorSet);
1682 addCases (group, cases.framebuffer);
1683 addCases (group, cases.commandPool);
1684 addCases (group, cases.commandBuffer);
1685
1686 return group.release();
1687 }
1688
validateCallbackRecords(Context & context,const CallbackRecorder & recorder)1689 static deBool validateCallbackRecords (Context& context, const CallbackRecorder& recorder)
1690 {
1691 tcu::TestLog& log = context.getTestContext().getLog();
1692 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1693 const InstanceInterface& vki = context.getInstanceInterface();
1694 const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
1695 std::set<std::pair<deUint64, deUint64>> memoryObjectSet;
1696
1697 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
1698 {
1699 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
1700
1701 if ((record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
1702 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT) &&
1703 record.heapIndex >= memoryProperties.memoryHeapCount)
1704 {
1705 log << tcu::TestLog::Message << "memoryHeapCount: " << memoryProperties.memoryHeapCount << tcu::TestLog::EndMessage;
1706 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1707 return false;
1708 }
1709
1710 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT)
1711 {
1712 log << tcu::TestLog::Message << "Observed ALLOCATION_FAILED event" << tcu::TestLog::EndMessage;
1713 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1714 continue;
1715 }
1716
1717 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
1718 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
1719 {
1720 memoryObjectSet.insert(std::make_pair(record.memoryObjectId, record.objectHandle));
1721 continue;
1722 }
1723
1724 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT ||
1725 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
1726 {
1727 const auto objectPair = std::make_pair(record.memoryObjectId, record.objectHandle);
1728 if (!memoryObjectSet.count(objectPair))
1729 {
1730 log << tcu::TestLog::Message << "Unpaired or out-of-order free/unimport event" << tcu::TestLog::EndMessage;
1731 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1732 return false;
1733 }
1734 memoryObjectSet.erase(objectPair);
1735 }
1736 }
1737
1738 if (!memoryObjectSet.empty())
1739 {
1740 log << tcu::TestLog::Message << "Unpaired alloc/import event" << tcu::TestLog::EndMessage;
1741 return false;
1742 }
1743
1744 return true;
1745 }
1746
1747 struct EnvClone
1748 {
1749 Unique<VkDevice> device;
1750 DeviceDriver vkd;
1751 Environment env;
1752
EnvClonevkt::memory::__anon67ed6e6e0111::EnvClone1753 EnvClone (const Environment& parent)
1754 : device (Device::create(parent, Device::Resources(parent, Device::Parameters()), Device::Parameters()))
1755 , vkd (parent.vkp, parent.instance, *device, parent.usedApiVersion)
1756 , env (parent.vkp, parent.vki, parent.instance, parent.physicalDevice, vkd, *device, parent.queueFamilyIndex, parent.programBinaries, parent.commandLine, nullptr, parent.usedApiVersion)
1757 {
1758 }
1759 };
1760
1761 template<typename Object>
createDestroyObjectTest(Context & context,typename Object::Parameters params)1762 tcu::TestStatus createDestroyObjectTest (Context& context, typename Object::Parameters params)
1763 {
1764 CallbackRecorder recorder;
1765 const Environment env (context.getPlatformInterface(),
1766 context.getInstanceInterface(),
1767 context.getInstance(),
1768 context.getPhysicalDevice(),
1769 context.getDeviceInterface(),
1770 context.getDevice(),
1771 context.getUniversalQueueFamilyIndex(),
1772 context.getBinaryCollection(),
1773 context.getTestContext().getCommandLine(),
1774 &recorder,
1775 context.getUsedApiVersion());
1776
1777 if (std::is_same<Object, Device>::value)
1778 {
1779 const typename Object::Resources res (env, params);
1780 Unique<typename Object::Type> obj (Object::create(env, res, params));
1781 }
1782 else
1783 {
1784 const EnvClone envWithCustomDevice (env);
1785 const typename Object::Resources res (envWithCustomDevice.env, params);
1786 Unique<typename Object::Type> obj (Object::create(envWithCustomDevice.env, res, params));
1787 }
1788
1789 if (!validateCallbackRecords(context, recorder))
1790 {
1791 return tcu::TestStatus::fail("Invalid device memory report callback");
1792 }
1793
1794 return tcu::TestStatus::pass("Ok");
1795 }
1796
vkDeviceMemoryAllocateAndFreeTest(Context & context)1797 tcu::TestStatus vkDeviceMemoryAllocateAndFreeTest (Context& context)
1798 {
1799 CallbackRecorder recorder;
1800 const PlatformInterface& vkp = context.getPlatformInterface();
1801 const VkInstance instance = context.getInstance();
1802 const InstanceInterface& vki = context.getInstanceInterface();
1803 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1804 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1805 const deBool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
1806 const Unique<VkDevice> device (createDeviceWithMemoryReport(isValidationEnabled, vkp, instance, vki, physicalDevice, queueFamilyIndex, &recorder));
1807 const DeviceDriver vkd (vkp, instance, *device, context.getUsedApiVersion());
1808 const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
1809 const VkDeviceSize testSize = 1024;
1810 const deUint32 testTypeIndex = 0;
1811 const deUint32 testHeapIndex = memoryProperties.memoryTypes[testTypeIndex].heapIndex;
1812 deUint64 objectHandle = 0;
1813
1814 {
1815 recorder.setCallbackMarker(MARKER_ALLOCATE);
1816
1817 VkResult result = VK_SUCCESS;
1818 VkDeviceMemory memory = DE_NULL;
1819 const VkMemoryAllocateInfo memoryAllocateInfo =
1820 {
1821 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
1822 DE_NULL, // const void* pNext;
1823 testSize, // VkDeviceSize allocationSize;
1824 testTypeIndex, // uint32_t memoryTypeIndex;
1825 };
1826
1827 result = vkd.allocateMemory(*device, &memoryAllocateInfo, (const VkAllocationCallbacks*)DE_NULL, &memory);
1828 if (result != VK_SUCCESS)
1829 {
1830 return tcu::TestStatus::fail("Unable to allocate " + de::toString(testSize) + " bytes of memory");
1831 }
1832 objectHandle = memory.getInternal();
1833
1834 recorder.setCallbackMarker(MARKER_FREE);
1835 vkd.freeMemory(*device, memory, (const VkAllocationCallbacks*)DE_NULL);
1836 }
1837
1838 recorder.setCallbackMarker(MARKER_UNKNOWN);
1839
1840 deBool allocateEvent = false;
1841 deBool freeEvent = false;
1842 deUint64 memoryObjectId = 0;
1843
1844 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
1845 {
1846 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
1847 const CallbackMarker marker = iter->second;
1848
1849 if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
1850 {
1851 TCU_CHECK(marker == MARKER_ALLOCATE);
1852 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
1853 TCU_CHECK(memoryObjectId == 0);
1854 TCU_CHECK(record.memoryObjectId != 0);
1855 TCU_CHECK_MSG(record.size >= testSize, ("record.size=" + de::toString(record.size) + ", testSize=" + de::toString(testSize)).c_str());
1856 TCU_CHECK(record.heapIndex == testHeapIndex);
1857
1858 memoryObjectId = record.memoryObjectId;
1859 allocateEvent = true;
1860 }
1861 else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
1862 {
1863 TCU_CHECK(marker == MARKER_FREE);
1864 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
1865 ("record.memoryObjectId=" + de::toString(record.memoryObjectId) +
1866 ", memoryObjectId=" + de::toString(memoryObjectId)).c_str());
1867
1868 freeEvent = true;
1869 }
1870 }
1871
1872 TCU_CHECK(allocateEvent);
1873 TCU_CHECK(freeEvent);
1874
1875 return tcu::TestStatus::pass("Ok");
1876 }
1877
createVkDeviceMemoryTestsGroup(tcu::TestContext & testCtx,const char * name)1878 tcu::TestCaseGroup* createVkDeviceMemoryTestsGroup (tcu::TestContext& testCtx, const char* name)
1879 {
1880 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name));
1881
1882 addFunctionCase(group.get(), "allocate_and_free", checkSupport, vkDeviceMemoryAllocateAndFreeTest);
1883
1884 return group.release();
1885 }
1886
checkSupport(Context & context,VkExternalMemoryHandleTypeFlagBits externalMemoryType)1887 static void checkSupport (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
1888 {
1889 checkSupport(context);
1890
1891 context.requireInstanceFunctionality("VK_KHR_external_memory_capabilities");
1892 context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
1893 context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
1894
1895 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1896 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
1897 {
1898 context.requireDeviceFunctionality("VK_KHR_external_memory_fd");
1899 }
1900
1901 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
1902 {
1903 context.requireDeviceFunctionality("VK_EXT_external_memory_dma_buf");
1904 }
1905
1906 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
1907 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
1908 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
1909 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
1910 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
1911 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
1912 {
1913 context.requireDeviceFunctionality("VK_KHR_external_memory_win32");
1914 }
1915
1916 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
1917 {
1918 context.requireDeviceFunctionality("VK_ANDROID_external_memory_android_hardware_buffer");
1919 }
1920 }
1921
getInstanceExtensions(const deUint32 instanceVersion)1922 static std::vector<std::string> getInstanceExtensions (const deUint32 instanceVersion)
1923 {
1924 std::vector<std::string> instanceExtensions;
1925
1926 if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
1927 instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
1928
1929 if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_external_memory_capabilities"))
1930 instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
1931
1932 return instanceExtensions;
1933 }
1934
createExternalMemoryDevice(deBool isValidationEnabled,const PlatformInterface & vkp,VkInstance instance,const InstanceInterface & vki,VkPhysicalDevice physicalDevice,deUint32 apiVersion,deUint32 queueFamilyIndex,VkExternalMemoryHandleTypeFlagBits externalMemoryType,const CallbackRecorder * recorder)1935 static Move<VkDevice> createExternalMemoryDevice (deBool isValidationEnabled,
1936 const PlatformInterface& vkp,
1937 VkInstance instance,
1938 const InstanceInterface& vki,
1939 VkPhysicalDevice physicalDevice,
1940 deUint32 apiVersion,
1941 deUint32 queueFamilyIndex,
1942 VkExternalMemoryHandleTypeFlagBits externalMemoryType,
1943 const CallbackRecorder* recorder)
1944 {
1945 const deUint32 queueCount = 1;
1946 const float queuePriority = 1.0f;
1947 std::vector<const char*> enabledExtensions = {"VK_EXT_device_memory_report"};
1948
1949 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
1950 {
1951 enabledExtensions.push_back("VK_KHR_dedicated_allocation");
1952 }
1953 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
1954 {
1955 enabledExtensions.push_back("VK_KHR_get_memory_requirements2");
1956 }
1957
1958 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1959 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
1960 {
1961 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_external_memory_fd"))
1962 {
1963 enabledExtensions.push_back("VK_KHR_external_memory_fd");
1964 }
1965 }
1966
1967 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
1968 {
1969 enabledExtensions.push_back("VK_EXT_external_memory_dma_buf");
1970 }
1971
1972 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
1973 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
1974 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
1975 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
1976 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
1977 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
1978 {
1979 enabledExtensions.push_back("VK_KHR_external_memory_win32");
1980 }
1981
1982 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
1983 {
1984 enabledExtensions.push_back("VK_ANDROID_external_memory_android_hardware_buffer");
1985 enabledExtensions.push_back("VK_EXT_queue_family_foreign");
1986 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_sampler_ycbcr_conversion"))
1987 {
1988 enabledExtensions.push_back("VK_KHR_sampler_ycbcr_conversion");
1989 }
1990 }
1991
1992 const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
1993 {
1994 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, // VkStructureType sType;
1995 DE_NULL, // void* pNext;
1996 VK_TRUE // VkBool32 deviceMemoryReport;
1997 };
1998 const VkDeviceDeviceMemoryReportCreateInfoEXT deviceMemoryReportCreateInfo =
1999 {
2000 VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, // VkStructureType sType;
2001 &deviceMemoryReportFeatures, // void* pNext;
2002 (VkDeviceMemoryReportFlagsEXT)0, // VkDeviceMemoryReportFlagsEXT flags;
2003 recorder->callback, // PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
2004 (void*)recorder, // void* pUserData;
2005 };
2006 const VkDeviceQueueCreateInfo queueCreateInfo =
2007 {
2008 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
2009 DE_NULL, // const void* pNext;
2010 (VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
2011 queueFamilyIndex, // deUint32 queueFamilyIndex;
2012 queueCount, // deUint32 queueCount;
2013 &queuePriority, // const float* pQueuePriorities;
2014 };
2015 const VkDeviceCreateInfo deviceCreateInfo =
2016 {
2017 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
2018 &deviceMemoryReportCreateInfo, // const void* pNext;
2019 (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
2020 queueCount, // uint32_t queueCreateInfoCount;
2021 &queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
2022 0u, // uint32_t enabledLayerCount;
2023 DE_NULL, // const char* const* ppEnabledLayerNames;
2024 (deUint32)enabledExtensions.size(), // uint32_t enabledExtensionCount;
2025 enabledExtensions.data(), // const char* const* ppEnabledExtensionNames;
2026 DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
2027 };
2028
2029 return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
2030 }
2031
checkBufferSupport(const InstanceInterface & vki,VkPhysicalDevice device,VkBufferUsageFlags usage,VkExternalMemoryHandleTypeFlagBits externalMemoryType)2032 static void checkBufferSupport (const InstanceInterface& vki,
2033 VkPhysicalDevice device,
2034 VkBufferUsageFlags usage,
2035 VkExternalMemoryHandleTypeFlagBits externalMemoryType)
2036 {
2037 const VkPhysicalDeviceExternalBufferInfo info =
2038 {
2039 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, // VkStructureType sType;
2040 DE_NULL, // void* pNext;
2041 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
2042 usage, // VkBufferUsageFlags usage;
2043 externalMemoryType, // VkExternalMemoryHandleTypeFlagBits handleType;
2044 };
2045 VkExternalBufferProperties properties =
2046 {
2047 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, // VkStructureType sType;
2048 DE_NULL, // void* pNext;
2049 { 0u, 0u, 0u }, // VkExternalMemoryProperties externalMemoryProperties;
2050 };
2051
2052 vki.getPhysicalDeviceExternalBufferProperties(device, &info, &properties);
2053
2054 if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
2055 TCU_THROW(NotSupportedError, "External handle type doesn't support exporting buffer");
2056
2057 if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
2058 TCU_THROW(NotSupportedError, "External handle type doesn't support importing buffer");
2059 }
2060
testImportAndUnimportExternalMemory(Context & context,VkExternalMemoryHandleTypeFlagBits externalMemoryType)2061 tcu::TestStatus testImportAndUnimportExternalMemory (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
2062 {
2063 CallbackRecorder recorder;
2064 const PlatformInterface& vkp (context.getPlatformInterface());
2065 const CustomInstance instance (createCustomInstanceWithExtensions(context, getInstanceExtensions(context.getUsedApiVersion())));
2066 const InstanceDriver& vki (instance.getDriver());
2067 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
2068 const deUint32 queueFamilyIndex (context.getUniversalQueueFamilyIndex());
2069 const Unique<VkDevice> device (createExternalMemoryDevice(context.getTestContext().getCommandLine().isValidationEnabled(),
2070 vkp,
2071 instance,
2072 vki,
2073 physicalDevice,
2074 context.getUsedApiVersion(),
2075 queueFamilyIndex,
2076 externalMemoryType,
2077 &recorder));
2078 const DeviceDriver vkd (vkp, instance, *device, context.getUsedApiVersion());
2079 const VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
2080 const VkDeviceSize bufferSize = 1024;
2081
2082 checkBufferSupport(vki, physicalDevice, usage, externalMemoryType);
2083
2084 const Unique<VkBuffer> buffer (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2085 const VkMemoryRequirements requirements (getBufferMemoryRequirements(vkd, *device, *buffer));
2086 const deUint32 memoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
2087 deUint64 objectHandle = 0;
2088 deUint64 objectHandleA = 0;
2089 deUint64 objectHandleB = 0;
2090
2091 {
2092 recorder.setCallbackMarker(MARKER_ALLOCATE);
2093 const Unique<VkDeviceMemory> memory (allocateExportableMemory(vkd, *device, requirements.size, memoryTypeIndex, externalMemoryType, *buffer));
2094 objectHandle = (*memory).getInternal();
2095 NativeHandle handleA;
2096
2097 getMemoryNative(vkd, *device, *memory, externalMemoryType, handleA);
2098
2099 NativeHandle handleB (handleA);
2100 const Unique<VkBuffer> bufferA (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2101 const Unique<VkBuffer> bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2102
2103 {
2104 recorder.setCallbackMarker(MARKER_IMPORT);
2105 const Unique<VkDeviceMemory> memoryA (importDedicatedMemory(vkd, *device, *bufferA, requirements, externalMemoryType, memoryTypeIndex, handleA));
2106 const Unique<VkDeviceMemory> memoryB (importDedicatedMemory(vkd, *device, *bufferB, requirements, externalMemoryType, memoryTypeIndex, handleB));
2107 objectHandleA = (*memoryA).getInternal();
2108 objectHandleB = (*memoryB).getInternal();
2109 recorder.setCallbackMarker(MARKER_UNIMPORT);
2110 }
2111
2112 recorder.setCallbackMarker(MARKER_FREE);
2113 }
2114
2115 recorder.setCallbackMarker(MARKER_UNKNOWN);
2116
2117 deBool allocateEvent = false;
2118 deBool freeEvent = false;
2119 deBool importA = false;
2120 deBool importB = false;
2121 deBool unimportA = false;
2122 deBool unimportB = false;
2123 deUint64 memoryObjectId = 0;
2124
2125 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
2126 {
2127 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
2128 const CallbackMarker marker = iter->second;
2129
2130 if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
2131 {
2132 TCU_CHECK(marker == MARKER_ALLOCATE);
2133 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2134 TCU_CHECK(memoryObjectId == 0);
2135 TCU_CHECK(record.memoryObjectId != 0);
2136 TCU_CHECK_MSG(record.size >= requirements.size,
2137 ("size: record=" + de::toString(record.size) +
2138 ", requirements=" + de::toString(requirements.size)).c_str());
2139
2140 allocateEvent = true;
2141 memoryObjectId = record.memoryObjectId;
2142 }
2143 else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
2144 {
2145 TCU_CHECK(marker == MARKER_IMPORT);
2146 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2147 TCU_CHECK_MSG(record.size >= requirements.size,
2148 ("sizeA: record=" + de::toString(record.size) +
2149 ", requirements=" + de::toString(requirements.size)).c_str());
2150 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2151 ("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
2152 ", original=" + de::toString(memoryObjectId)).c_str());
2153
2154 importA = true;
2155 }
2156 else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
2157 {
2158 TCU_CHECK(marker == MARKER_IMPORT);
2159 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2160 TCU_CHECK_MSG(record.size >= requirements.size,
2161 ("sizeB: record=" + de::toString(record.size) +
2162 ", requirements=" + de::toString(requirements.size)).c_str());
2163 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2164 ("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
2165 ", original=" + de::toString(memoryObjectId)).c_str());
2166
2167 importB = true;
2168 }
2169 else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
2170 {
2171 TCU_CHECK(marker == MARKER_UNIMPORT);
2172 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2173 ("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
2174 ", original=" + de::toString(memoryObjectId)).c_str());
2175
2176 unimportB = true;
2177 }
2178 else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
2179 {
2180 TCU_CHECK(marker == MARKER_UNIMPORT);
2181 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2182 ("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
2183 ", original=" + de::toString(memoryObjectId)).c_str());
2184
2185 unimportA = true;
2186 }
2187 else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
2188 {
2189 TCU_CHECK(marker == MARKER_FREE);
2190 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2191 ("memoryObjectId: record=" + de::toString(record.memoryObjectId) +
2192 ", original=" + de::toString(memoryObjectId)).c_str());
2193
2194 freeEvent = true;
2195 }
2196 }
2197
2198 TCU_CHECK(allocateEvent);
2199 TCU_CHECK(importA);
2200 TCU_CHECK(importB);
2201 TCU_CHECK(unimportB);
2202 TCU_CHECK(unimportA);
2203 TCU_CHECK(freeEvent);
2204
2205 return tcu::TestStatus::pass("Pass");
2206 }
2207
createExternalMemoryTestsGroup(tcu::TestContext & testCtx,const char * name)2208 tcu::TestCaseGroup* createExternalMemoryTestsGroup (tcu::TestContext& testCtx, const char* name)
2209 {
2210 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name));
2211
2212 const std::vector<VkExternalMemoryHandleTypeFlagBits> externalMemoryTypes =
2213 {
2214 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
2215 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
2216 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2217 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
2218 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
2219 };
2220
2221 for (const auto externalMemoryType : externalMemoryTypes)
2222 {
2223 const std::string testName = std::string("import_and_unimport_") + std::string(externalMemoryTypeToName(externalMemoryType));
2224
2225 addFunctionCase(group.get(), testName.c_str(), checkSupport, testImportAndUnimportExternalMemory, externalMemoryType);
2226 }
2227
2228 return group.release();
2229 }
2230
2231 } // anonymous
2232
createDeviceMemoryReportTests(tcu::TestContext & testCtx)2233 tcu::TestCaseGroup* createDeviceMemoryReportTests (tcu::TestContext& testCtx)
2234 {
2235 MovePtr<tcu::TestCaseGroup> deviceMemoryReportTests (new tcu::TestCaseGroup(testCtx, "device_memory_report"));
2236
2237 const Image::Parameters img1D (0u,
2238 VK_IMAGE_TYPE_1D,
2239 VK_FORMAT_R8G8B8A8_UNORM,
2240 makeExtent3D(256, 1, 1),
2241 1u,
2242 4u,
2243 VK_SAMPLE_COUNT_1_BIT,
2244 VK_IMAGE_TILING_OPTIMAL,
2245 VK_IMAGE_USAGE_SAMPLED_BIT,
2246 VK_IMAGE_LAYOUT_UNDEFINED);
2247 const Image::Parameters img2D (0u,
2248 VK_IMAGE_TYPE_2D,
2249 VK_FORMAT_R8G8B8A8_UNORM,
2250 makeExtent3D(64, 64, 1),
2251 1u,
2252 12u,
2253 VK_SAMPLE_COUNT_1_BIT,
2254 VK_IMAGE_TILING_OPTIMAL,
2255 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
2256 VK_IMAGE_LAYOUT_UNDEFINED);
2257 const Image::Parameters imgCube (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
2258 VK_IMAGE_TYPE_2D,
2259 VK_FORMAT_R8G8B8A8_UNORM,
2260 makeExtent3D(64, 64, 1),
2261 1u,
2262 12u,
2263 VK_SAMPLE_COUNT_1_BIT,
2264 VK_IMAGE_TILING_OPTIMAL,
2265 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
2266 VK_IMAGE_LAYOUT_UNDEFINED);
2267 const Image::Parameters img3D (0u,
2268 VK_IMAGE_TYPE_3D,
2269 VK_FORMAT_R8G8B8A8_UNORM,
2270 makeExtent3D(64, 64, 4),
2271 1u,
2272 1u,
2273 VK_SAMPLE_COUNT_1_BIT,
2274 VK_IMAGE_TILING_OPTIMAL,
2275 VK_IMAGE_USAGE_SAMPLED_BIT,
2276 VK_IMAGE_LAYOUT_UNDEFINED);
2277 const ImageView::Parameters imgView1D (img1D,
2278 VK_IMAGE_VIEW_TYPE_1D,
2279 img1D.format,
2280 makeComponentMappingRGBA(),
2281 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2282 const ImageView::Parameters imgView1DArr (img1D,
2283 VK_IMAGE_VIEW_TYPE_1D_ARRAY,
2284 img1D.format,
2285 makeComponentMappingRGBA(),
2286 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 4u));
2287 const ImageView::Parameters imgView2D (img2D,
2288 VK_IMAGE_VIEW_TYPE_2D,
2289 img2D.format,
2290 makeComponentMappingRGBA(),
2291 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2292 const ImageView::Parameters imgView2DArr (img2D,
2293 VK_IMAGE_VIEW_TYPE_2D_ARRAY,
2294 img2D.format,
2295 makeComponentMappingRGBA(),
2296 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 8u));
2297 const ImageView::Parameters imgViewCube (imgCube,VK_IMAGE_VIEW_TYPE_CUBE,
2298 img2D.format,
2299 makeComponentMappingRGBA(),
2300 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 6u));
2301 const ImageView::Parameters imgViewCubeArr (imgCube,
2302 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
2303 img2D.format,
2304 makeComponentMappingRGBA(),
2305 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 12u));
2306 const ImageView::Parameters imgView3D (img3D,
2307 VK_IMAGE_VIEW_TYPE_3D,
2308 img3D.format,
2309 makeComponentMappingRGBA(),
2310 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2311
2312 const DescriptorSetLayout::Parameters singleUboDescLayout = DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, VK_SHADER_STAGE_VERTEX_BIT);
2313
2314 const NamedParameters<Device> s_deviceCases[] =
2315 {
2316 { "device", Device::Parameters() },
2317 };
2318 static const NamedParameters<DeviceMemory> s_deviceMemCases[] =
2319 {
2320 { "device_memory_small", DeviceMemory::Parameters(1024, 0u) },
2321 };
2322 static const NamedParameters<Buffer> s_bufferCases[] =
2323 {
2324 { "buffer_uniform_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
2325 { "buffer_uniform_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
2326 { "buffer_storage_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
2327 { "buffer_storage_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
2328 };
2329 static const NamedParameters<BufferView> s_bufferViewCases[] =
2330 {
2331 { "buffer_view_uniform_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
2332 { "buffer_view_storage_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
2333 };
2334 static const NamedParameters<Image> s_imageCases[] =
2335 {
2336 { "image_1d", img1D },
2337 { "image_2d", img2D },
2338 { "image_3d", img3D },
2339 };
2340 static const NamedParameters<ImageView> s_imageViewCases[] =
2341 {
2342 { "image_view_1d", imgView1D },
2343 { "image_view_1d_arr", imgView1DArr },
2344 { "image_view_2d", imgView2D },
2345 { "image_view_2d_arr", imgView2DArr },
2346 { "image_view_cube", imgViewCube },
2347 { "image_view_cube_arr", imgViewCubeArr },
2348 { "image_view_3d", imgView3D },
2349 };
2350 static const NamedParameters<Semaphore> s_semaphoreCases[] =
2351 {
2352 { "semaphore", Semaphore::Parameters(0u), }
2353 };
2354 static const NamedParameters<Event> s_eventCases[] =
2355 {
2356 { "event", Event::Parameters(0u) }
2357 };
2358 static const NamedParameters<Fence> s_fenceCases[] =
2359 {
2360 { "fence", Fence::Parameters(0u) },
2361 { "fence_signaled", Fence::Parameters(VK_FENCE_CREATE_SIGNALED_BIT) }
2362 };
2363 static const NamedParameters<QueryPool> s_queryPoolCases[] =
2364 {
2365 { "query_pool", QueryPool::Parameters(VK_QUERY_TYPE_OCCLUSION, 1u, 0u) }
2366 };
2367 static const NamedParameters<ShaderModule> s_shaderModuleCases[] =
2368 {
2369 { "shader_module", ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "test") }
2370 };
2371 static const NamedParameters<PipelineCache> s_pipelineCacheCases[] =
2372 {
2373 { "pipeline_cache", PipelineCache::Parameters() }
2374 };
2375 static const NamedParameters<Sampler> s_samplerCases[] =
2376 {
2377 { "sampler", Sampler::Parameters() }
2378 };
2379 static const NamedParameters<DescriptorSetLayout> s_descriptorSetLayoutCases[] =
2380 {
2381 { "descriptor_set_layout_empty", DescriptorSetLayout::Parameters::empty() },
2382 { "descriptor_set_layout_single", singleUboDescLayout }
2383 };
2384 static const NamedParameters<PipelineLayout> s_pipelineLayoutCases[] =
2385 {
2386 { "pipeline_layout_empty", PipelineLayout::Parameters::empty() },
2387 { "pipeline_layout_single", PipelineLayout::Parameters::singleDescriptorSet(singleUboDescLayout) }
2388 };
2389 static const NamedParameters<RenderPass> s_renderPassCases[] =
2390 {
2391 { "render_pass", RenderPass::Parameters() }
2392 };
2393 static const NamedParameters<GraphicsPipeline> s_graphicsPipelineCases[] =
2394 {
2395 { "graphics_pipeline", GraphicsPipeline::Parameters() }
2396 };
2397 static const NamedParameters<ComputePipeline> s_computePipelineCases[] =
2398 {
2399 { "compute_pipeline", ComputePipeline::Parameters() }
2400 };
2401 static const NamedParameters<DescriptorPool> s_descriptorPoolCases[] =
2402 {
2403 { "descriptor_pool", DescriptorPool::Parameters::singleType((VkDescriptorPoolCreateFlags)0, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) },
2404 { "descriptor_pool_free_descriptor_set", DescriptorPool::Parameters::singleType(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) }
2405 };
2406 static const NamedParameters<DescriptorSet> s_descriptorSetCases[] =
2407 {
2408 { "descriptor_set", DescriptorSet::Parameters(singleUboDescLayout) }
2409 };
2410 static const NamedParameters<Framebuffer> s_framebufferCases[] =
2411 {
2412 { "framebuffer", Framebuffer::Parameters() }
2413 };
2414 static const NamedParameters<CommandPool> s_commandPoolCases[] =
2415 {
2416 { "command_pool", CommandPool::Parameters((VkCommandPoolCreateFlags)0) },
2417 { "command_pool_transient", CommandPool::Parameters(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) }
2418 };
2419 static const NamedParameters<CommandBuffer> s_commandBufferCases[] =
2420 {
2421 { "command_buffer_primary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_PRIMARY) },
2422 { "command_buffer_secondary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_SECONDARY) }
2423 };
2424
2425 const CaseDescriptions s_createDestroyObjectGroup =
2426 {
2427 CASE_DESC(createDestroyObjectTest <Device>, s_deviceCases),
2428 CASE_DESC(createDestroyObjectTest <DeviceMemory>, s_deviceMemCases),
2429 CASE_DESC(createDestroyObjectTest <Buffer>, s_bufferCases),
2430 CASE_DESC(createDestroyObjectTest <BufferView>, s_bufferViewCases),
2431 CASE_DESC(createDestroyObjectTest <Image>, s_imageCases),
2432 CASE_DESC(createDestroyObjectTest <ImageView>, s_imageViewCases),
2433 CASE_DESC(createDestroyObjectTest <Semaphore>, s_semaphoreCases),
2434 CASE_DESC(createDestroyObjectTest <Event>, s_eventCases),
2435 CASE_DESC(createDestroyObjectTest <Fence>, s_fenceCases),
2436 CASE_DESC(createDestroyObjectTest <QueryPool>, s_queryPoolCases),
2437 CASE_DESC(createDestroyObjectTest <ShaderModule>, s_shaderModuleCases),
2438 CASE_DESC(createDestroyObjectTest <PipelineCache>, s_pipelineCacheCases),
2439 CASE_DESC(createDestroyObjectTest <Sampler>, s_samplerCases),
2440 CASE_DESC(createDestroyObjectTest <DescriptorSetLayout>, s_descriptorSetLayoutCases),
2441 CASE_DESC(createDestroyObjectTest <PipelineLayout>, s_pipelineLayoutCases),
2442 CASE_DESC(createDestroyObjectTest <RenderPass>, s_renderPassCases),
2443 CASE_DESC(createDestroyObjectTest <GraphicsPipeline>, s_graphicsPipelineCases),
2444 CASE_DESC(createDestroyObjectTest <ComputePipeline>, s_computePipelineCases),
2445 CASE_DESC(createDestroyObjectTest <DescriptorPool>, s_descriptorPoolCases),
2446 CASE_DESC(createDestroyObjectTest <DescriptorSet>, s_descriptorSetCases),
2447 CASE_DESC(createDestroyObjectTest <Framebuffer>, s_framebufferCases),
2448 CASE_DESC(createDestroyObjectTest <CommandPool>, s_commandPoolCases),
2449 CASE_DESC(createDestroyObjectTest <CommandBuffer>, s_commandBufferCases),
2450 };
2451 // Check emitted callbacks are properly paired
2452 deviceMemoryReportTests->addChild(createObjectTestsGroup(testCtx, "create_and_destroy_object", s_createDestroyObjectGroup));
2453 // Check callbacks are emitted properly for VkDeviceMemory
2454 deviceMemoryReportTests->addChild(createVkDeviceMemoryTestsGroup(testCtx, "vk_device_memory"));
2455 // Check callbacks are emitted properly for external memory
2456 deviceMemoryReportTests->addChild(createExternalMemoryTestsGroup(testCtx, "external_memory"));
2457
2458 return deviceMemoryReportTests.release();
2459 }
2460
2461 } // memory
2462 } // vkt
2463