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