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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::Device::Parameters222 Parameters (void) {}
223 };
224
225 struct Resources
226 {
Resourcesvkt::memory::__anona8f23c0c0111::Device::Resources227 Resources (const Environment&, const Parameters&) {}
228 };
229
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::DeviceMemory::Resources255 Resources (const Environment&, const Parameters&) {}
256 };
257
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::Buffer::Parameters296 Parameters (VkDeviceSize size_,
297 VkBufferUsageFlags usage_)
298 : size (size_)
299 , usage (usage_)
300 {}
301 };
302
303 struct Resources
304 {
Resourcesvkt::memory::__anona8f23c0c0111::Buffer::Resources305 Resources (const Environment&, const Parameters&) {}
306 };
307
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::Image::Resources420 Resources (const Environment&, const Parameters&) {}
421 };
422
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::Semaphore::Parameters512 Parameters (VkSemaphoreCreateFlags flags_)
513 : flags(flags_)
514 {}
515 };
516
517 struct Resources
518 {
Resourcesvkt::memory::__anona8f23c0c0111::Semaphore::Resources519 Resources (const Environment&, const Parameters&) {}
520 };
521
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::Fence::Parameters543 Parameters (VkFenceCreateFlags flags_)
544 : flags(flags_)
545 {}
546 };
547
548 struct Resources
549 {
Resourcesvkt::memory::__anona8f23c0c0111::Fence::Resources550 Resources (const Environment&, const Parameters&) {}
551 };
552
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::Event::Parameters574 Parameters (VkEventCreateFlags flags_)
575 : flags(flags_)
576 {}
577 };
578
579 struct Resources
580 {
Resourcesvkt::memory::__anona8f23c0c0111::Event::Resources581 Resources (const Environment&, const Parameters&) {}
582 };
583
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::QueryPool::Resources618 Resources (const Environment&, const Parameters&) {}
619 };
620
createvkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::ShaderModule::Resources657 Resources (const Environment& env, const Parameters& params)
658 : binary(env.programBinaries.get(params.binaryName))
659 {}
660 };
661
getSourcevkt::memory::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::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::__anona8f23c0c0111::PipelineCache::Parameters722 Parameters (void) {}
723 };
724
725 struct Resources
726 {
Resourcesvkt::memory::__anona8f23c0c0111::PipelineCache::Resources727 Resources (const Environment&, const Parameters&) {}
728 };
729
createvkt::memory::__anona8f23c0c0111::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 (VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
737 0u, // size_t initialDataSize;
738 DE_NULL, // const void* pInitialData;
739 };
740
741 return createPipelineCache(env.vkd, env.device, &pipelineCacheCreateInfo);
742 }
743 };
744
745 struct Sampler
746 {
747 typedef VkSampler Type;
748
749 struct Parameters
750 {
751 VkFilter magFilter;
752 VkFilter minFilter;
753 VkSamplerMipmapMode mipmapMode;
754 VkSamplerAddressMode addressModeU;
755 VkSamplerAddressMode addressModeV;
756 VkSamplerAddressMode addressModeW;
757 float mipLodBias;
758 VkBool32 anisotropyEnable;
759 float maxAnisotropy;
760 VkBool32 compareEnable;
761 VkCompareOp compareOp;
762 float minLod;
763 float maxLod;
764 VkBorderColor borderColor;
765 VkBool32 unnormalizedCoordinates;
766
Parametersvkt::memory::__anona8f23c0c0111::Sampler::Parameters767 Parameters (void)
768 : magFilter (VK_FILTER_NEAREST)
769 , minFilter (VK_FILTER_NEAREST)
770 , mipmapMode (VK_SAMPLER_MIPMAP_MODE_NEAREST)
771 , addressModeU (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
772 , addressModeV (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
773 , addressModeW (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
774 , mipLodBias (0.0f)
775 , anisotropyEnable (VK_FALSE)
776 , maxAnisotropy (1.0f)
777 , compareEnable (VK_FALSE)
778 , compareOp (VK_COMPARE_OP_ALWAYS)
779 , minLod (-1000.f)
780 , maxLod (+1000.f)
781 , borderColor (VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK)
782 , unnormalizedCoordinates (VK_FALSE)
783 {}
784 };
785
786 struct Resources
787 {
Resourcesvkt::memory::__anona8f23c0c0111::Sampler::Resources788 Resources (const Environment&, const Parameters&) {}
789 };
790
createvkt::memory::__anona8f23c0c0111::Sampler791 static Move<VkSampler> create (const Environment& env, const Resources&, const Parameters& params)
792 {
793 const VkSamplerCreateInfo samplerCreateInfo =
794 {
795 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
796 DE_NULL, // const void* pNext;
797 (VkSamplerCreateFlags)0, // VkSamplerCreateFlags flags;
798 params.magFilter, // VkFilter magFilter;
799 params.minFilter, // VkFilter minFilter;
800 params.mipmapMode, // VkSamplerMipmapMode mipmapMode;
801 params.addressModeU, // VkSamplerAddressMode addressModeU;
802 params.addressModeV, // VkSamplerAddressMode addressModeV;
803 params.addressModeW, // VkSamplerAddressMode addressModeW;
804 params.mipLodBias, // float mipLodBias;
805 params.anisotropyEnable, // VkBool32 anisotropyEnable;
806 params.maxAnisotropy, // float maxAnisotropy;
807 params.compareEnable, // VkBool32 compareEnable;
808 params.compareOp, // VkCompareOp compareOp;
809 params.minLod, // float minLod;
810 params.maxLod, // float maxLod;
811 params.borderColor, // VkBorderColor borderColor;
812 params.unnormalizedCoordinates, // VkBool32 unnormalizedCoordinates;
813 };
814
815 return createSampler(env.vkd, env.device, &samplerCreateInfo);
816 }
817 };
818
819 struct DescriptorSetLayout
820 {
821 typedef VkDescriptorSetLayout Type;
822
823 struct Parameters
824 {
825 struct Binding
826 {
827 deUint32 binding;
828 VkDescriptorType descriptorType;
829 deUint32 descriptorCount;
830 VkShaderStageFlags stageFlags;
831 bool useImmutableSampler;
832
Bindingvkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Parameters::Binding833 Binding (deUint32 binding_,
834 VkDescriptorType descriptorType_,
835 deUint32 descriptorCount_,
836 VkShaderStageFlags stageFlags_,
837 bool useImmutableSampler_)
838 : binding (binding_)
839 , descriptorType (descriptorType_)
840 , descriptorCount (descriptorCount_)
841 , stageFlags (stageFlags_)
842 , useImmutableSampler (useImmutableSampler_)
843 {}
844
Bindingvkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Parameters::Binding845 Binding (void) {}
846 };
847
848 std::vector<Binding> bindings;
849
Parametersvkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Parameters850 Parameters (const std::vector<Binding>& bindings_)
851 : bindings(bindings_)
852 {}
853
emptyvkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Parameters854 static Parameters empty (void)
855 {
856 return Parameters(std::vector<Binding>());
857 }
858
singlevkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Parameters859 static Parameters single (deUint32 binding,
860 VkDescriptorType descriptorType,
861 deUint32 descriptorCount,
862 VkShaderStageFlags stageFlags,
863 bool useImmutableSampler = false)
864 {
865 std::vector<Binding> bindings;
866 bindings.push_back(Binding(binding, descriptorType, descriptorCount, stageFlags, useImmutableSampler));
867 return Parameters(bindings);
868 }
869 };
870
871 struct Resources
872 {
873 std::vector<VkDescriptorSetLayoutBinding> bindings;
874 MovePtr<Dependency<Sampler>> immutableSampler;
875 std::vector<VkSampler> immutableSamplersPtr;
876
Resourcesvkt::memory::__anona8f23c0c0111::DescriptorSetLayout::Resources877 Resources (const Environment& env, const Parameters& params)
878 {
879 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
880 {
881 if (cur->useImmutableSampler && !immutableSampler)
882 {
883 immutableSampler = de::newMovePtr<Dependency<Sampler>>(env, Sampler::Parameters());
884
885 if (cur->useImmutableSampler && immutableSamplersPtr.size() < (size_t)cur->descriptorCount)
886 immutableSamplersPtr.resize(cur->descriptorCount, *immutableSampler->object);
887 }
888 }
889
890 for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
891 {
892 const VkDescriptorSetLayoutBinding binding =
893 {
894 cur->binding, // uint32_t binding;
895 cur->descriptorType, // VkDescriptorType descriptorType;
896 cur->descriptorCount, // uint32_t descriptorCount;
897 cur->stageFlags, // VkShaderStageFlags stageFlags;
898 (cur->useImmutableSampler ? &immutableSamplersPtr[0] : DE_NULL), // const VkSampler* pImmutableSamplers;
899 };
900
901 bindings.push_back(binding);
902 }
903 }
904 };
905
createvkt::memory::__anona8f23c0c0111::DescriptorSetLayout906 static Move<VkDescriptorSetLayout> create (const Environment& env, const Resources& res, const Parameters&)
907 {
908 const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
909 {
910 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
911 DE_NULL, // const void* pNext;
912 (VkDescriptorSetLayoutCreateFlags)0, // VkDescriptorSetLayoutCreateFlags flags;
913 (deUint32)res.bindings.size(), // uint32_t bindingCount;
914 (res.bindings.empty() ? DE_NULL : &res.bindings[0]), // const VkDescriptorSetLayoutBinding* pBindings;
915 };
916
917 return createDescriptorSetLayout(env.vkd, env.device, &descriptorSetLayoutCreateInfo);
918 }
919 };
920
921 struct PipelineLayout
922 {
923 typedef VkPipelineLayout Type;
924
925 struct Parameters
926 {
927 std::vector<DescriptorSetLayout::Parameters> descriptorSetLayouts;
928 std::vector<VkPushConstantRange> pushConstantRanges;
929
Parametersvkt::memory::__anona8f23c0c0111::PipelineLayout::Parameters930 Parameters (void) {}
931
emptyvkt::memory::__anona8f23c0c0111::PipelineLayout::Parameters932 static Parameters empty (void)
933 {
934 return Parameters();
935 }
936
singleDescriptorSetvkt::memory::__anona8f23c0c0111::PipelineLayout::Parameters937 static Parameters singleDescriptorSet (const DescriptorSetLayout::Parameters& descriptorSetLayout)
938 {
939 Parameters params;
940 params.descriptorSetLayouts.push_back(descriptorSetLayout);
941 return params;
942 }
943 };
944
945 struct Resources
946 {
947 typedef SharedPtr<Dependency<DescriptorSetLayout>> DescriptorSetLayoutDepSp;
948 typedef std::vector<DescriptorSetLayoutDepSp> DescriptorSetLayouts;
949
950 DescriptorSetLayouts descriptorSetLayouts;
951 std::vector<VkDescriptorSetLayout> pSetLayouts;
952
Resourcesvkt::memory::__anona8f23c0c0111::PipelineLayout::Resources953 Resources (const Environment& env, const Parameters& params)
954 {
955 for (std::vector<DescriptorSetLayout::Parameters>::const_iterator dsParams = params.descriptorSetLayouts.begin();
956 dsParams != params.descriptorSetLayouts.end();
957 ++dsParams)
958 {
959 descriptorSetLayouts.push_back(DescriptorSetLayoutDepSp(new Dependency<DescriptorSetLayout>(env, *dsParams)));
960 pSetLayouts.push_back(*descriptorSetLayouts.back()->object);
961 }
962 }
963 };
964
createvkt::memory::__anona8f23c0c0111::PipelineLayout965 static Move<VkPipelineLayout> create (const Environment& env, const Resources& res, const Parameters& params)
966 {
967 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
968 {
969 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
970 DE_NULL, // const void* pNext;
971 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
972 (deUint32)res.pSetLayouts.size(), // uint32_t setLayoutCount;
973 (res.pSetLayouts.empty() ? DE_NULL : &res.pSetLayouts[0]), // const VkDescriptorSetLayout* pSetLayouts;
974 (deUint32)params.pushConstantRanges.size(), // uint32_t pushConstantRangeCount;
975 (params.pushConstantRanges.empty() ? DE_NULL : ¶ms.pushConstantRanges[0]), // const VkPushConstantRange* pPushConstantRanges;
976 };
977
978 return createPipelineLayout(env.vkd, env.device, &pipelineLayoutCreateInfo);
979 }
980 };
981
982 struct RenderPass
983 {
984 typedef VkRenderPass Type;
985
986 struct Parameters
987 {
Parametersvkt::memory::__anona8f23c0c0111::RenderPass::Parameters988 Parameters (void) {}
989 };
990
991 struct Resources
992 {
Resourcesvkt::memory::__anona8f23c0c0111::RenderPass::Resources993 Resources (const Environment&, const Parameters&) {}
994 };
995
createvkt::memory::__anona8f23c0c0111::RenderPass996 static Move<VkRenderPass> create (const Environment& env, const Resources&, const Parameters&)
997 {
998 return makeRenderPass(env.vkd, env.device, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_D16_UNORM,
999 VK_ATTACHMENT_LOAD_OP_CLEAR,
1000 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1001 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1002 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1003 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
1004 }
1005 };
1006
1007 struct GraphicsPipeline
1008 {
1009 typedef VkPipeline Type;
1010
1011 struct Parameters
1012 {
Parametersvkt::memory::__anona8f23c0c0111::GraphicsPipeline::Parameters1013 Parameters (void) {}
1014 };
1015
1016 struct Resources
1017 {
1018 Dependency<ShaderModule> vertexShader;
1019 Dependency<ShaderModule> fragmentShader;
1020 Dependency<PipelineLayout> layout;
1021 Dependency<RenderPass> renderPass;
1022 Dependency<PipelineCache> pipelineCache;
1023
Resourcesvkt::memory::__anona8f23c0c0111::GraphicsPipeline::Resources1024 Resources (const Environment& env, const Parameters&)
1025 : vertexShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"))
1026 , fragmentShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"))
1027 , layout (env, PipelineLayout::Parameters::singleDescriptorSet(
1028 DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u, VK_SHADER_STAGE_FRAGMENT_BIT, true)))
1029 , renderPass (env, RenderPass::Parameters())
1030 , pipelineCache (env, PipelineCache::Parameters())
1031 {}
1032 };
1033
initProgramsvkt::memory::__anona8f23c0c0111::GraphicsPipeline1034 static void initPrograms (SourceCollections& dst, Parameters)
1035 {
1036 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"));
1037 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"));
1038 }
1039
createvkt::memory::__anona8f23c0c0111::GraphicsPipeline1040 static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
1041 {
1042 const VkPipelineShaderStageCreateInfo stages[] =
1043 {
1044 {
1045 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1046 DE_NULL, // const void* pNext;
1047 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1048 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
1049 *res.vertexShader.object, // VkShaderModule module;
1050 "main", // const char* pName;
1051 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1052 },
1053 {
1054 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1055 DE_NULL, // const void* pNext;
1056 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1057 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
1058 *res.fragmentShader.object, // VkShaderModule module;
1059 "main", // const char* pName;
1060 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1061 }
1062 };
1063 const VkVertexInputBindingDescription vertexBindings[] =
1064 {
1065 {
1066 0u, // uint32_t binding;
1067 16u, // uint32_t stride;
1068 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
1069 }
1070 };
1071 const VkVertexInputAttributeDescription vertexAttribs[] =
1072 {
1073 {
1074 0u, // uint32_t location;
1075 0u, // uint32_t binding;
1076 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1077 0u, // uint32_t offset;
1078 }
1079 };
1080 const VkPipelineVertexInputStateCreateInfo vertexInputState =
1081 {
1082 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1083 DE_NULL, // const void* pNext;
1084 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1085 DE_LENGTH_OF_ARRAY(vertexBindings), // uint32_t vertexBindingDescriptionCount;
1086 vertexBindings, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1087 DE_LENGTH_OF_ARRAY(vertexAttribs), // uint32_t vertexAttributeDescriptionCount;
1088 vertexAttribs, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1089 };
1090 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
1091 {
1092 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1093 DE_NULL, // const void* pNext;
1094 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1095 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1096 VK_FALSE, // VkBool32 primitiveRestartEnable;
1097 };
1098 const VkViewport viewport = makeViewport(tcu::UVec2(64));
1099 const VkRect2D scissor = makeRect2D(tcu::UVec2(64));
1100
1101 const VkPipelineViewportStateCreateInfo viewportState =
1102 {
1103 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
1104 DE_NULL, // const void* pNext;
1105 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
1106 1u, // uint32_t viewportCount;
1107 &viewport, // const VkViewport* pViewports;
1108 1u, // uint32_t scissorCount;
1109 &scissor, // const VkRect2D* pScissors;
1110 };
1111 const VkPipelineRasterizationStateCreateInfo rasterState =
1112 {
1113 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1114 DE_NULL, // const void* pNext;
1115 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1116 VK_FALSE, // VkBool32 depthClampEnable;
1117 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1118 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1119 VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
1120 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
1121 VK_FALSE, // VkBool32 depthBiasEnable;
1122 0.0f, // float depthBiasConstantFactor;
1123 0.0f, // float depthBiasClamp;
1124 0.0f, // float depthBiasSlopeFactor;
1125 1.0f, // float lineWidth;
1126 };
1127 const VkPipelineMultisampleStateCreateInfo multisampleState =
1128 {
1129 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1130 DE_NULL, // const void* pNext;
1131 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
1132 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
1133 VK_FALSE, // VkBool32 sampleShadingEnable;
1134 1.0f, // float minSampleShading;
1135 DE_NULL, // const VkSampleMask* pSampleMask;
1136 VK_FALSE, // VkBool32 alphaToCoverageEnable;
1137 VK_FALSE, // VkBool32 alphaToOneEnable;
1138 };
1139 const VkPipelineDepthStencilStateCreateInfo depthStencilState =
1140 {
1141 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1142 DE_NULL, // const void* pNext;
1143 (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
1144 VK_TRUE, // VkBool32 depthTestEnable;
1145 VK_TRUE, // VkBool32 depthWriteEnable;
1146 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
1147 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1148 VK_FALSE, // VkBool32 stencilTestEnable;
1149 {
1150 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1151 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1152 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1153 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1154 0u, // uint32_t compareMask;
1155 0u, // uint32_t writeMask;
1156 0u, // uint32_t reference;
1157 },
1158 {
1159 VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
1160 VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
1161 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
1162 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1163 0u, // uint32_t compareMask;
1164 0u, // uint32_t writeMask;
1165 0u, // uint32_t reference;
1166 },
1167 0.0f, // float minDepthBounds;
1168 1.0f, // float maxDepthBounds;
1169 };
1170 const VkPipelineColorBlendAttachmentState colorBlendAttState[]=
1171 {
1172 {
1173 VK_FALSE, // VkBool32 blendEnable;
1174 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
1175 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
1176 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1177 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
1178 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
1179 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1180 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
1181 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, // VkColorComponentFlags colorWriteMask;
1182 }
1183 };
1184 const VkPipelineColorBlendStateCreateInfo colorBlendState =
1185 {
1186 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1187 DE_NULL, // const void* pNext;
1188 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
1189 VK_FALSE, // VkBool32 logicOpEnable;
1190 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1191 DE_LENGTH_OF_ARRAY(colorBlendAttState), // uint32_t attachmentCount;
1192 colorBlendAttState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1193 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
1194 };
1195 const VkGraphicsPipelineCreateInfo pipelineCreateInfo =
1196 {
1197 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1198 DE_NULL, // const void* pNext;
1199 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1200 DE_LENGTH_OF_ARRAY(stages), // uint32_t stageCount;
1201 stages, // const VkPipelineShaderStageCreateInfo* pStages;
1202 &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1203 &inputAssemblyState, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1204 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1205 &viewportState, // const VkPipelineViewportStateCreateInfo* pViewportState;
1206 &rasterState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1207 &multisampleState, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1208 &depthStencilState, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1209 &colorBlendState, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1210 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1211 *res.layout.object, // VkPipelineLayout layout;
1212 *res.renderPass.object, // VkRenderPass renderPass;
1213 0u, // uint32_t subpass;
1214 (VkPipeline)0, // VkPipeline basePipelineHandle;
1215 0, // int32_t basePipelineIndex;
1216 };
1217
1218 return createGraphicsPipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1219 }
1220 };
1221
1222 struct ComputePipeline
1223 {
1224 typedef VkPipeline Type;
1225
1226 struct Parameters
1227 {
Parametersvkt::memory::__anona8f23c0c0111::ComputePipeline::Parameters1228 Parameters (void) {}
1229 };
1230
1231 struct Resources
1232 {
1233 Dependency<ShaderModule> shaderModule;
1234 Dependency<PipelineLayout> layout;
1235 Dependency<PipelineCache> pipelineCache;
1236
getDescriptorSetLayoutvkt::memory::__anona8f23c0c0111::ComputePipeline::Resources1237 static DescriptorSetLayout::Parameters getDescriptorSetLayout (void)
1238 {
1239 typedef DescriptorSetLayout::Parameters::Binding Binding;
1240
1241 std::vector<Binding> bindings;
1242
1243 bindings.push_back(Binding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1244 bindings.push_back(Binding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
1245
1246 return DescriptorSetLayout::Parameters(bindings);
1247 }
1248
Resourcesvkt::memory::__anona8f23c0c0111::ComputePipeline::Resources1249 Resources (const Environment& env, const Parameters&)
1250 : shaderModule (env, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"))
1251 , layout (env, PipelineLayout::Parameters::singleDescriptorSet(getDescriptorSetLayout()))
1252 , pipelineCache (env, PipelineCache::Parameters())
1253 {}
1254 };
1255
initProgramsvkt::memory::__anona8f23c0c0111::ComputePipeline1256 static void initPrograms (SourceCollections& dst, Parameters)
1257 {
1258 ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"));
1259 }
1260
createvkt::memory::__anona8f23c0c0111::ComputePipeline1261 static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
1262 {
1263 const VkComputePipelineCreateInfo pipelineCreateInfo =
1264 {
1265 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1266 DE_NULL, // const void* pNext;
1267 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1268 {
1269 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1270 DE_NULL, // const void* pNext;
1271 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
1272 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1273 *res.shaderModule.object, // VkShaderModule module;
1274 "main", // const char* pName;
1275 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1276 },
1277 *res.layout.object, // VkPipelineLayout layout;
1278 (VkPipeline)0, // VkPipeline basePipelineHandle;
1279 0u, // int32_t basePipelineIndex;
1280 };
1281
1282 return createComputePipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
1283 }
1284 };
1285
1286 struct DescriptorPool
1287 {
1288 typedef VkDescriptorPool Type;
1289
1290 struct Parameters
1291 {
1292 VkDescriptorPoolCreateFlags flags;
1293 deUint32 maxSets;
1294 std::vector<VkDescriptorPoolSize> poolSizes;
1295
Parametersvkt::memory::__anona8f23c0c0111::DescriptorPool::Parameters1296 Parameters (VkDescriptorPoolCreateFlags flags_,
1297 deUint32 maxSets_,
1298 const std::vector<VkDescriptorPoolSize>& poolSizes_)
1299 : flags (flags_)
1300 , maxSets (maxSets_)
1301 , poolSizes (poolSizes_)
1302 {}
1303
singleTypevkt::memory::__anona8f23c0c0111::DescriptorPool::Parameters1304 static Parameters singleType (VkDescriptorPoolCreateFlags flags,
1305 deUint32 maxSets,
1306 VkDescriptorType type,
1307 deUint32 count)
1308 {
1309 std::vector<VkDescriptorPoolSize> poolSizes;
1310 poolSizes.push_back(makeDescriptorPoolSize(type, count));
1311 return Parameters(flags, maxSets, poolSizes);
1312 }
1313 };
1314
1315 struct Resources
1316 {
Resourcesvkt::memory::__anona8f23c0c0111::DescriptorPool::Resources1317 Resources (const Environment&, const Parameters&) {}
1318 };
1319
createvkt::memory::__anona8f23c0c0111::DescriptorPool1320 static Move<VkDescriptorPool> create (const Environment& env, const Resources&, const Parameters& params)
1321 {
1322 const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
1323 {
1324 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
1325 DE_NULL, // const void* pNext;
1326 params.flags, // VkDescriptorPoolCreateFlags flags;
1327 params.maxSets, // uint32_t maxSets;
1328 (deUint32)params.poolSizes.size(), // uint32_t poolSizeCount;
1329 (params.poolSizes.empty() ? DE_NULL : ¶ms.poolSizes[0]), // const VkDescriptorPoolSize* pPoolSizes;
1330 };
1331
1332 return createDescriptorPool(env.vkd, env.device, &descriptorPoolCreateInfo);
1333 }
1334 };
1335
1336 struct DescriptorSet
1337 {
1338 typedef VkDescriptorSet Type;
1339
1340 struct Parameters
1341 {
1342 DescriptorSetLayout::Parameters descriptorSetLayout;
1343
Parametersvkt::memory::__anona8f23c0c0111::DescriptorSet::Parameters1344 Parameters (const DescriptorSetLayout::Parameters& descriptorSetLayout_)
1345 : descriptorSetLayout(descriptorSetLayout_)
1346 {}
1347 };
1348
1349 struct Resources
1350 {
1351 Dependency<DescriptorPool> descriptorPool;
1352 Dependency<DescriptorSetLayout> descriptorSetLayout;
1353
computePoolSizesvkt::memory::__anona8f23c0c0111::DescriptorSet::Resources1354 static std::vector<VkDescriptorPoolSize> computePoolSizes (const DescriptorSetLayout::Parameters& layout, int maxSets)
1355 {
1356 deUint32 countByType[VK_DESCRIPTOR_TYPE_LAST];
1357 std::vector<VkDescriptorPoolSize> typeCounts;
1358
1359 std::fill(DE_ARRAY_BEGIN(countByType), DE_ARRAY_END(countByType), 0u);
1360
1361 for (std::vector<DescriptorSetLayout::Parameters::Binding>::const_iterator cur = layout.bindings.begin(); cur != layout.bindings.end(); cur++)
1362 {
1363 DE_ASSERT((deUint32)cur->descriptorType < VK_DESCRIPTOR_TYPE_LAST);
1364 countByType[cur->descriptorType] += cur->descriptorCount * maxSets;
1365 }
1366
1367 for (deUint32 type = 0; type < VK_DESCRIPTOR_TYPE_LAST; type++)
1368 {
1369 if (countByType[type] > 0)
1370 typeCounts.push_back(makeDescriptorPoolSize((VkDescriptorType)type, countByType[type]));
1371 }
1372
1373 return typeCounts;
1374 }
1375
Resourcesvkt::memory::__anona8f23c0c0111::DescriptorSet::Resources1376 Resources (const Environment& env, const Parameters& params)
1377 : descriptorPool (env, DescriptorPool::Parameters(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u, computePoolSizes(params.descriptorSetLayout, 1u)))
1378 , descriptorSetLayout (env, params.descriptorSetLayout)
1379 {
1380 }
1381 };
1382
createvkt::memory::__anona8f23c0c0111::DescriptorSet1383 static Move<VkDescriptorSet> create (const Environment& env, const Resources& res, const Parameters&)
1384 {
1385 const VkDescriptorSetAllocateInfo allocateInfo =
1386 {
1387 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
1388 DE_NULL, // const void* pNext;
1389 *res.descriptorPool.object, // VkDescriptorPool descriptorPool;
1390 1u, // uint32_t descriptorSetCount;
1391 &(*res.descriptorSetLayout.object), // const VkDescriptorSetLayout* pSetLayouts;
1392 };
1393
1394 return allocateDescriptorSet(env.vkd, env.device, &allocateInfo);
1395 }
1396 };
1397
1398 struct Framebuffer
1399 {
1400 typedef VkFramebuffer Type;
1401
1402 struct Parameters
1403 {
Parametersvkt::memory::__anona8f23c0c0111::Framebuffer::Parameters1404 Parameters (void)
1405 {}
1406 };
1407
1408 struct Resources
1409 {
1410 Dependency<ImageView> colorAttachment;
1411 Dependency<ImageView> depthStencilAttachment;
1412 Dependency<RenderPass> renderPass;
1413
Resourcesvkt::memory::__anona8f23c0c0111::Framebuffer::Resources1414 Resources (const Environment& env, const Parameters&)
1415 : colorAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
1416 makeExtent3D(256, 256, 1),
1417 1u, 1u,
1418 VK_SAMPLE_COUNT_1_BIT,
1419 VK_IMAGE_TILING_OPTIMAL,
1420 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1421 VK_IMAGE_LAYOUT_UNDEFINED),
1422 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
1423 makeComponentMappingRGBA(),
1424 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)))
1425 , depthStencilAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM,
1426 makeExtent3D(256, 256, 1),
1427 1u, 1u,
1428 VK_SAMPLE_COUNT_1_BIT,
1429 VK_IMAGE_TILING_OPTIMAL,
1430 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1431 VK_IMAGE_LAYOUT_UNDEFINED),
1432 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM,
1433 makeComponentMappingRGBA(),
1434 makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u)))
1435 , renderPass (env, RenderPass::Parameters())
1436 {}
1437 };
1438
createvkt::memory::__anona8f23c0c0111::Framebuffer1439 static Move<VkFramebuffer> create (const Environment& env, const Resources& res, const Parameters&)
1440 {
1441 const VkImageView attachments[] =
1442 {
1443 *res.colorAttachment.object,
1444 *res.depthStencilAttachment.object,
1445 };
1446 const VkFramebufferCreateInfo framebufferCreateInfo =
1447 {
1448 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1449 DE_NULL, // const void* pNext;
1450 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
1451 *res.renderPass.object, // VkRenderPass renderPass;
1452 (deUint32)DE_LENGTH_OF_ARRAY(attachments), // uint32_t attachmentCount;
1453 attachments, // const VkImageView* pAttachments;
1454 256u, // uint32_t width;
1455 256u, // uint32_t height;
1456 1u, // uint32_t layers;
1457 };
1458
1459 return createFramebuffer(env.vkd, env.device, &framebufferCreateInfo);
1460 }
1461 };
1462
1463 struct CommandPool
1464 {
1465 typedef VkCommandPool Type;
1466
1467 struct Parameters
1468 {
1469 VkCommandPoolCreateFlags flags;
1470
Parametersvkt::memory::__anona8f23c0c0111::CommandPool::Parameters1471 Parameters (VkCommandPoolCreateFlags flags_)
1472 : flags(flags_)
1473 {}
1474 };
1475
1476 struct Resources
1477 {
Resourcesvkt::memory::__anona8f23c0c0111::CommandPool::Resources1478 Resources (const Environment&, const Parameters&) {}
1479 };
1480
createvkt::memory::__anona8f23c0c0111::CommandPool1481 static Move<VkCommandPool> create (const Environment& env, const Resources&, const Parameters& params)
1482 {
1483 const VkCommandPoolCreateInfo commandPoolCreateInfo =
1484 {
1485 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
1486 DE_NULL, // const void* pNext;
1487 params.flags, // VkCommandPoolCreateFlags flags;
1488 env.queueFamilyIndex, // uint32_t queueFamilyIndex;
1489 };
1490
1491 return createCommandPool(env.vkd, env.device, &commandPoolCreateInfo);
1492 }
1493 };
1494
1495 struct CommandBuffer
1496 {
1497 typedef VkCommandBuffer Type;
1498
1499 struct Parameters
1500 {
1501 CommandPool::Parameters commandPool;
1502 VkCommandBufferLevel level;
1503
Parametersvkt::memory::__anona8f23c0c0111::CommandBuffer::Parameters1504 Parameters (const CommandPool::Parameters& commandPool_,
1505 VkCommandBufferLevel level_)
1506 : commandPool (commandPool_)
1507 , level (level_)
1508 {}
1509 };
1510
1511 struct Resources
1512 {
1513 Dependency<CommandPool> commandPool;
1514
Resourcesvkt::memory::__anona8f23c0c0111::CommandBuffer::Resources1515 Resources (const Environment& env, const Parameters& params)
1516 : commandPool(env, params.commandPool)
1517 {}
1518 };
1519
createvkt::memory::__anona8f23c0c0111::CommandBuffer1520 static Move<VkCommandBuffer> create (const Environment& env, const Resources& res, const Parameters& params)
1521 {
1522 const VkCommandBufferAllocateInfo allocateInfo =
1523 {
1524 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
1525 DE_NULL, // const void* pNext;
1526 *res.commandPool.object, // VkCommandPool commandPool;
1527 params.level, // VkCommandBufferLevel level;
1528 1, // uint32_t commandBufferCount;
1529 };
1530
1531 return allocateCommandBuffer(env.vkd, env.device, &allocateInfo);
1532 }
1533 };
1534
1535 template<typename Object>
1536 struct NamedParameters
1537 {
1538 const char* name;
1539 typename Object::Parameters parameters;
1540 };
1541
1542 template<typename Object>
1543 struct CaseDescription
1544 {
1545 typename FunctionInstance1<typename Object::Parameters>::Function function;
1546 const NamedParameters<Object>* paramsBegin;
1547 const NamedParameters<Object>* paramsEnd;
1548 };
1549
1550 #define CASE_DESC(FUNCTION, CASES) \
1551 { FUNCTION, DE_ARRAY_BEGIN(CASES), DE_ARRAY_END(CASES) }
1552
1553 struct CaseDescriptions
1554 {
1555 CaseDescription<Device> device;
1556 CaseDescription<DeviceMemory> deviceMemory;
1557 CaseDescription<Buffer> buffer;
1558 CaseDescription<BufferView> bufferView;
1559 CaseDescription<Image> image;
1560 CaseDescription<ImageView> imageView;
1561 CaseDescription<Semaphore> semaphore;
1562 CaseDescription<Event> event;
1563 CaseDescription<Fence> fence;
1564 CaseDescription<QueryPool> queryPool;
1565 CaseDescription<ShaderModule> shaderModule;
1566 CaseDescription<PipelineCache> pipelineCache;
1567 CaseDescription<Sampler> sampler;
1568 CaseDescription<DescriptorSetLayout> descriptorSetLayout;
1569 CaseDescription<PipelineLayout> pipelineLayout;
1570 CaseDescription<RenderPass> renderPass;
1571 CaseDescription<GraphicsPipeline> graphicsPipeline;
1572 CaseDescription<ComputePipeline> computePipeline;
1573 CaseDescription<DescriptorPool> descriptorPool;
1574 CaseDescription<DescriptorSet> descriptorSet;
1575 CaseDescription<Framebuffer> framebuffer;
1576 CaseDescription<CommandPool> commandPool;
1577 CaseDescription<CommandBuffer> commandBuffer;
1578 };
1579
1580 template<typename Object>
checkSupport(Context & context,typename Object::Parameters)1581 static void checkSupport (Context& context, typename Object::Parameters)
1582 {
1583 context.requireDeviceFunctionality("VK_EXT_device_memory_report");
1584 }
1585
1586 template<typename Object>
addCases(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1587 void addCases (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
1588 {
1589 for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1590 {
1591 addFunctionCase(group.get(), cur->name, "", checkSupport<Object>, cases.function, cur->parameters);
1592 }
1593 }
1594
1595 template<typename Object>
addCasesWithProgs(const MovePtr<tcu::TestCaseGroup> & group,const CaseDescription<Object> & cases)1596 void addCasesWithProgs (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
1597 {
1598 for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
1599 {
1600 addFunctionCaseWithPrograms(group.get(), cur->name, "", checkSupport<Object>, Object::initPrograms, cases.function, cur->parameters);
1601 }
1602 }
1603
createObjectTestsGroup(tcu::TestContext & testCtx,const char * name,const char * desc,const CaseDescriptions & cases)1604 tcu::TestCaseGroup* createObjectTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc, const CaseDescriptions& cases)
1605 {
1606 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
1607
1608 addCases (group, cases.device);
1609 addCases (group, cases.deviceMemory);
1610 addCases (group, cases.buffer);
1611 addCases (group, cases.bufferView);
1612 addCases (group, cases.image);
1613 addCases (group, cases.imageView);
1614 addCases (group, cases.semaphore);
1615 addCases (group, cases.event);
1616 addCases (group, cases.fence);
1617 addCases (group, cases.queryPool);
1618 addCasesWithProgs (group, cases.shaderModule);
1619 addCases (group, cases.pipelineCache);
1620 addCases (group, cases.sampler);
1621 addCases (group, cases.descriptorSetLayout);
1622 addCases (group, cases.pipelineLayout);
1623 addCases (group, cases.renderPass);
1624 addCasesWithProgs (group, cases.graphicsPipeline);
1625 addCasesWithProgs (group, cases.computePipeline);
1626 addCases (group, cases.descriptorPool);
1627 addCases (group, cases.descriptorSet);
1628 addCases (group, cases.framebuffer);
1629 addCases (group, cases.commandPool);
1630 addCases (group, cases.commandBuffer);
1631
1632 return group.release();
1633 }
1634
validateCallbackRecords(Context & context,const CallbackRecorder & recorder)1635 static deBool validateCallbackRecords (Context& context, const CallbackRecorder& recorder)
1636 {
1637 tcu::TestLog& log = context.getTestContext().getLog();
1638 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1639 const InstanceInterface& vki = context.getInstanceInterface();
1640 const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
1641 std::set<std::pair<deUint64, deUint64>> memoryObjectSet;
1642
1643 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
1644 {
1645 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
1646
1647 if ((record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
1648 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT) &&
1649 record.heapIndex >= memoryProperties.memoryHeapCount)
1650 {
1651 log << tcu::TestLog::Message << "memoryHeapCount: " << memoryProperties.memoryHeapCount << tcu::TestLog::EndMessage;
1652 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1653 return false;
1654 }
1655
1656 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT)
1657 {
1658 log << tcu::TestLog::Message << "Observed ALLOCATION_FAILED event" << tcu::TestLog::EndMessage;
1659 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1660 continue;
1661 }
1662
1663 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
1664 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
1665 {
1666 memoryObjectSet.insert(std::make_pair(record.memoryObjectId, record.objectHandle));
1667 continue;
1668 }
1669
1670 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT ||
1671 record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
1672 {
1673 const auto objectPair = std::make_pair(record.memoryObjectId, record.objectHandle);
1674 if (!memoryObjectSet.count(objectPair))
1675 {
1676 log << tcu::TestLog::Message << "Unpaired or out-of-order free/unimport event" << tcu::TestLog::EndMessage;
1677 log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
1678 return false;
1679 }
1680 memoryObjectSet.erase(objectPair);
1681 }
1682 }
1683
1684 if (!memoryObjectSet.empty())
1685 {
1686 log << tcu::TestLog::Message << "Unpaired alloc/import event" << tcu::TestLog::EndMessage;
1687 return false;
1688 }
1689
1690 return true;
1691 }
1692
1693 struct EnvClone
1694 {
1695 Unique<VkDevice> device;
1696 DeviceDriver vkd;
1697 Environment env;
1698
EnvClonevkt::memory::__anona8f23c0c0111::EnvClone1699 EnvClone (const Environment& parent)
1700 : device (Device::create(parent, Device::Resources(parent, Device::Parameters()), Device::Parameters()))
1701 , vkd (parent.vkp, parent.instance, *device)
1702 , env (parent.vkp, parent.vki, parent.instance, parent.physicalDevice, vkd, *device, parent.queueFamilyIndex, parent.programBinaries, parent.commandLine, nullptr)
1703 {
1704 }
1705 };
1706
1707 template<typename Object>
createDestroyObjectTest(Context & context,typename Object::Parameters params)1708 tcu::TestStatus createDestroyObjectTest (Context& context, typename Object::Parameters params)
1709 {
1710 CallbackRecorder recorder;
1711 const Environment env (context.getPlatformInterface(),
1712 context.getInstanceInterface(),
1713 context.getInstance(),
1714 context.getPhysicalDevice(),
1715 context.getDeviceInterface(),
1716 context.getDevice(),
1717 context.getUniversalQueueFamilyIndex(),
1718 context.getBinaryCollection(),
1719 context.getTestContext().getCommandLine(),
1720 &recorder);
1721
1722 if (std::is_same<Object, Device>::value)
1723 {
1724 const typename Object::Resources res (env, params);
1725 Unique<typename Object::Type> obj (Object::create(env, res, params));
1726 }
1727 else
1728 {
1729 const EnvClone envWithCustomDevice (env);
1730 const typename Object::Resources res (envWithCustomDevice.env, params);
1731 Unique<typename Object::Type> obj (Object::create(envWithCustomDevice.env, res, params));
1732 }
1733
1734 if (!validateCallbackRecords(context, recorder))
1735 {
1736 return tcu::TestStatus::fail("Invalid device memory report callback");
1737 }
1738
1739 return tcu::TestStatus::pass("Ok");
1740 }
1741
vkDeviceMemoryAllocateAndFreeTest(Context & context)1742 tcu::TestStatus vkDeviceMemoryAllocateAndFreeTest (Context& context)
1743 {
1744 CallbackRecorder recorder;
1745 const PlatformInterface& vkp = context.getPlatformInterface();
1746 const VkInstance instance = context.getInstance();
1747 const InstanceInterface& vki = context.getInstanceInterface();
1748 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1749 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1750 const deBool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
1751 const Unique<VkDevice> device (createDeviceWithMemoryReport(isValidationEnabled, vkp, instance, vki, physicalDevice, queueFamilyIndex, &recorder));
1752 const DeviceDriver vkd (vkp, instance, *device);
1753 const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
1754 const VkDeviceSize testSize = 1024;
1755 const deUint32 testTypeIndex = 0;
1756 const deUint32 testHeapIndex = memoryProperties.memoryTypes[testTypeIndex].heapIndex;
1757 deUint64 objectHandle = 0;
1758
1759 {
1760 recorder.setCallbackMarker(MARKER_ALLOCATE);
1761
1762 VkResult result = VK_SUCCESS;
1763 VkDeviceMemory memory = DE_NULL;
1764 const VkMemoryAllocateInfo memoryAllocateInfo =
1765 {
1766 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
1767 DE_NULL, // const void* pNext;
1768 testSize, // VkDeviceSize allocationSize;
1769 testHeapIndex, // uint32_t memoryTypeIndex;
1770 };
1771
1772 result = vkd.allocateMemory(*device, &memoryAllocateInfo, (const VkAllocationCallbacks*)DE_NULL, &memory);
1773 if (result != VK_SUCCESS)
1774 {
1775 return tcu::TestStatus::fail("Unable to allocate " + de::toString(testSize) + " bytes of memory");
1776 }
1777 objectHandle = memory.getInternal();
1778
1779 recorder.setCallbackMarker(MARKER_FREE);
1780 vkd.freeMemory(*device, memory, (const VkAllocationCallbacks*)DE_NULL);
1781 }
1782
1783 recorder.setCallbackMarker(MARKER_UNKNOWN);
1784
1785 deBool allocateEvent = false;
1786 deBool freeEvent = false;
1787 deUint64 memoryObjectId = 0;
1788
1789 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
1790 {
1791 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
1792 const CallbackMarker marker = iter->second;
1793
1794 if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
1795 {
1796 TCU_CHECK(marker == MARKER_ALLOCATE);
1797 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
1798 TCU_CHECK(memoryObjectId == 0);
1799 TCU_CHECK(record.memoryObjectId != 0);
1800 TCU_CHECK_MSG(record.size >= testSize, ("record.size=" + de::toString(record.size) + ", testSize=" + de::toString(testSize)).c_str());
1801 TCU_CHECK(record.heapIndex == testHeapIndex);
1802
1803 memoryObjectId = record.memoryObjectId;
1804 allocateEvent = true;
1805 }
1806 else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
1807 {
1808 TCU_CHECK(marker == MARKER_FREE);
1809 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
1810 ("record.memoryObjectId=" + de::toString(record.memoryObjectId) +
1811 ", memoryObjectId=" + de::toString(memoryObjectId)).c_str());
1812
1813 freeEvent = true;
1814 }
1815 }
1816
1817 TCU_CHECK(allocateEvent);
1818 TCU_CHECK(freeEvent);
1819
1820 return tcu::TestStatus::pass("Ok");
1821 }
1822
vkDeviceMemoryAllocationFailedTest(Context & context)1823 tcu::TestStatus vkDeviceMemoryAllocationFailedTest (Context& context)
1824 {
1825 CallbackRecorder recorder;
1826 const PlatformInterface& vkp = context.getPlatformInterface();
1827 const VkInstance instance = context.getInstance();
1828 const InstanceInterface& vki = context.getInstanceInterface();
1829 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1830 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1831 const deBool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
1832 const Unique<VkDevice> device (createDeviceWithMemoryReport(isValidationEnabled, vkp, instance, vki, physicalDevice, queueFamilyIndex, &recorder));
1833 const DeviceDriver vkd (vkp, instance, *device);
1834 const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
1835 const VkDeviceSize testSize = std::numeric_limits<deUint64>::max();
1836 const deUint32 testTypeIndex = 0;
1837 const deUint32 testHeapIndex = memoryProperties.memoryTypes[testTypeIndex].heapIndex;
1838
1839 {
1840 recorder.setCallbackMarker(MARKER_ALLOCATION_FAILED);
1841
1842 VkResult result = VK_SUCCESS;
1843 VkDeviceMemory memory = DE_NULL;
1844 const VkMemoryAllocateInfo memoryAllocateInfo =
1845 {
1846 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
1847 DE_NULL, // const void* pNext;
1848 testSize, // VkDeviceSize allocationSize;
1849 testHeapIndex, // uint32_t memoryTypeIndex;
1850 };
1851
1852 result = vkd.allocateMemory(*device, &memoryAllocateInfo, (const VkAllocationCallbacks*)DE_NULL, &memory);
1853 if (result == VK_SUCCESS)
1854 {
1855 return tcu::TestStatus::fail("Should not be able to allocate UINT64_MAX bytes of memory");
1856 }
1857
1858 recorder.setCallbackMarker(MARKER_UNKNOWN);
1859 }
1860
1861 deBool allocationFailedEvent = false;
1862
1863 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
1864 {
1865 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
1866 const CallbackMarker marker = iter->second;
1867
1868 if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT)
1869 {
1870 TCU_CHECK(marker == MARKER_ALLOCATION_FAILED);
1871 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
1872 TCU_CHECK_MSG(record.size >= testSize, ("record.size=" + de::toString(record.size) + ", testSize=" + de::toString(testSize)).c_str());
1873 TCU_CHECK(record.heapIndex == testHeapIndex);
1874
1875 allocationFailedEvent = true;
1876 }
1877 }
1878
1879 TCU_CHECK(allocationFailedEvent);
1880
1881 return tcu::TestStatus::pass("Ok");
1882 }
1883
checkSupport(Context & context)1884 static void checkSupport (Context& context)
1885 {
1886 context.requireDeviceFunctionality("VK_EXT_device_memory_report");
1887 }
1888
createVkDeviceMemoryTestsGroup(tcu::TestContext & testCtx,const char * name,const char * desc)1889 tcu::TestCaseGroup* createVkDeviceMemoryTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc)
1890 {
1891 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
1892
1893 addFunctionCase(group.get(), "allocate_and_free", "", checkSupport, vkDeviceMemoryAllocateAndFreeTest);
1894 addFunctionCase(group.get(), "allocation_failed", "", checkSupport, vkDeviceMemoryAllocationFailedTest);
1895
1896 return group.release();
1897 }
1898
checkSupport(Context & context,VkExternalMemoryHandleTypeFlagBits externalMemoryType)1899 static void checkSupport (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
1900 {
1901 context.requireInstanceFunctionality("VK_KHR_external_memory_capabilities");
1902 context.requireDeviceFunctionality("VK_EXT_device_memory_report");
1903 context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
1904 context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
1905
1906 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1907 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
1908 {
1909 context.requireDeviceFunctionality("VK_KHR_external_memory_fd");
1910 }
1911
1912 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
1913 {
1914 context.requireDeviceFunctionality("VK_EXT_external_memory_dma_buf");
1915 }
1916
1917 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
1918 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
1919 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
1920 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
1921 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
1922 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
1923 {
1924 context.requireDeviceFunctionality("VK_KHR_external_memory_win32");
1925 }
1926
1927 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
1928 {
1929 context.requireDeviceFunctionality("VK_ANDROID_external_memory_android_hardware_buffer");
1930 }
1931 }
1932
getInstanceExtensions(const deUint32 instanceVersion)1933 static std::vector<std::string> getInstanceExtensions (const deUint32 instanceVersion)
1934 {
1935 std::vector<std::string> instanceExtensions;
1936
1937 if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
1938 instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
1939
1940 if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_external_memory_capabilities"))
1941 instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
1942
1943 return instanceExtensions;
1944 }
1945
createExternalMemoryDevice(deBool isValidationEnabled,const PlatformInterface & vkp,VkInstance instance,const InstanceInterface & vki,VkPhysicalDevice physicalDevice,deUint32 apiVersion,deUint32 queueFamilyIndex,VkExternalMemoryHandleTypeFlagBits externalMemoryType,const CallbackRecorder * recorder)1946 static Move<VkDevice> createExternalMemoryDevice (deBool isValidationEnabled,
1947 const PlatformInterface& vkp,
1948 VkInstance instance,
1949 const InstanceInterface& vki,
1950 VkPhysicalDevice physicalDevice,
1951 deUint32 apiVersion,
1952 deUint32 queueFamilyIndex,
1953 VkExternalMemoryHandleTypeFlagBits externalMemoryType,
1954 const CallbackRecorder* recorder)
1955 {
1956 const deUint32 queueCount = 1;
1957 const float queuePriority = 1.0f;
1958 std::vector<const char*> enabledExtensions = {"VK_EXT_device_memory_report"};
1959
1960 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
1961 {
1962 enabledExtensions.push_back("VK_KHR_dedicated_allocation");
1963 }
1964 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
1965 {
1966 enabledExtensions.push_back("VK_KHR_get_memory_requirements2");
1967 }
1968
1969 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1970 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
1971 {
1972 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_external_memory_fd"))
1973 {
1974 enabledExtensions.push_back("VK_KHR_external_memory_fd");
1975 }
1976 }
1977
1978 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
1979 {
1980 enabledExtensions.push_back("VK_EXT_external_memory_dma_buf");
1981 }
1982
1983 if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
1984 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
1985 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
1986 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
1987 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
1988 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
1989 {
1990 enabledExtensions.push_back("VK_KHR_external_memory_win32");
1991 }
1992
1993 if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
1994 {
1995 enabledExtensions.push_back("VK_ANDROID_external_memory_android_hardware_buffer");
1996 enabledExtensions.push_back("VK_EXT_queue_family_foreign");
1997 if (!isCoreDeviceExtension(apiVersion, "VK_KHR_sampler_ycbcr_conversion"))
1998 {
1999 enabledExtensions.push_back("VK_KHR_sampler_ycbcr_conversion");
2000 }
2001 }
2002
2003 const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
2004 {
2005 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, // VkStructureType sType;
2006 DE_NULL, // void* pNext;
2007 VK_TRUE // VkBool32 deviceMemoryReport;
2008 };
2009 const VkDeviceDeviceMemoryReportCreateInfoEXT deviceMemoryReportCreateInfo =
2010 {
2011 VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, // VkStructureType sType;
2012 &deviceMemoryReportFeatures, // void* pNext;
2013 (VkDeviceMemoryReportFlagsEXT)0, // VkDeviceMemoryReportFlagsEXT flags;
2014 recorder->callback, // PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
2015 (void*)recorder, // void* pUserData;
2016 };
2017 const VkDeviceQueueCreateInfo queueCreateInfo =
2018 {
2019 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
2020 DE_NULL, // const void* pNext;
2021 (VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
2022 queueFamilyIndex, // deUint32 queueFamilyIndex;
2023 queueCount, // deUint32 queueCount;
2024 &queuePriority, // const float* pQueuePriorities;
2025 };
2026 const VkDeviceCreateInfo deviceCreateInfo =
2027 {
2028 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
2029 &deviceMemoryReportCreateInfo, // const void* pNext;
2030 (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
2031 queueCount, // uint32_t queueCreateInfoCount;
2032 &queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
2033 0u, // uint32_t enabledLayerCount;
2034 DE_NULL, // const char* const* ppEnabledLayerNames;
2035 (deUint32)enabledExtensions.size(), // uint32_t enabledExtensionCount;
2036 enabledExtensions.data(), // const char* const* ppEnabledExtensionNames;
2037 DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
2038 };
2039
2040 return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
2041 }
2042
checkBufferSupport(const InstanceInterface & vki,VkPhysicalDevice device,VkBufferUsageFlags usage,VkExternalMemoryHandleTypeFlagBits externalMemoryType)2043 static void checkBufferSupport (const InstanceInterface& vki,
2044 VkPhysicalDevice device,
2045 VkBufferUsageFlags usage,
2046 VkExternalMemoryHandleTypeFlagBits externalMemoryType)
2047 {
2048 const VkPhysicalDeviceExternalBufferInfo info =
2049 {
2050 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, // VkStructureType sType;
2051 DE_NULL, // void* pNext;
2052 (VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
2053 usage, // VkBufferUsageFlags usage;
2054 externalMemoryType, // VkExternalMemoryHandleTypeFlagBits handleType;
2055 };
2056 VkExternalBufferProperties properties =
2057 {
2058 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, // VkStructureType sType;
2059 DE_NULL, // void* pNext;
2060 { 0u, 0u, 0u }, // VkExternalMemoryProperties externalMemoryProperties;
2061 };
2062
2063 vki.getPhysicalDeviceExternalBufferProperties(device, &info, &properties);
2064
2065 if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
2066 TCU_THROW(NotSupportedError, "External handle type doesn't support exporting buffer");
2067
2068 if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
2069 TCU_THROW(NotSupportedError, "External handle type doesn't support importing buffer");
2070 }
2071
testImportAndUnimportExternalMemory(Context & context,VkExternalMemoryHandleTypeFlagBits externalMemoryType)2072 tcu::TestStatus testImportAndUnimportExternalMemory (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
2073 {
2074 CallbackRecorder recorder;
2075 const PlatformInterface& vkp (context.getPlatformInterface());
2076 const CustomInstance instance (createCustomInstanceWithExtensions(context, getInstanceExtensions(context.getUsedApiVersion())));
2077 const InstanceDriver& vki (instance.getDriver());
2078 const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
2079 const deUint32 queueFamilyIndex (context.getUniversalQueueFamilyIndex());
2080 const Unique<VkDevice> device (createExternalMemoryDevice(context.getTestContext().getCommandLine().isValidationEnabled(),
2081 vkp,
2082 instance,
2083 vki,
2084 physicalDevice,
2085 context.getUsedApiVersion(),
2086 queueFamilyIndex,
2087 externalMemoryType,
2088 &recorder));
2089 const DeviceDriver vkd (vkp, instance, *device);
2090 const VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
2091 const VkDeviceSize bufferSize = 1024;
2092
2093 checkBufferSupport(vki, physicalDevice, usage, externalMemoryType);
2094
2095 const Unique<VkBuffer> buffer (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2096 const VkMemoryRequirements requirements (getBufferMemoryRequirements(vkd, *device, *buffer));
2097 const deUint32 memoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
2098 deUint64 objectHandle = 0;
2099 deUint64 objectHandleA = 0;
2100 deUint64 objectHandleB = 0;
2101
2102 {
2103 recorder.setCallbackMarker(MARKER_ALLOCATE);
2104 const Unique<VkDeviceMemory> memory (allocateExportableMemory(vkd, *device, requirements.size, memoryTypeIndex, externalMemoryType, *buffer));
2105 objectHandle = (*memory).getInternal();
2106 NativeHandle handleA;
2107
2108 getMemoryNative(vkd, *device, *memory, externalMemoryType, handleA);
2109
2110 NativeHandle handleB (handleA);
2111 const Unique<VkBuffer> bufferA (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2112 const Unique<VkBuffer> bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
2113
2114 {
2115 recorder.setCallbackMarker(MARKER_IMPORT);
2116 const Unique<VkDeviceMemory> memoryA (importDedicatedMemory(vkd, *device, *bufferA, requirements, externalMemoryType, memoryTypeIndex, handleA));
2117 const Unique<VkDeviceMemory> memoryB (importDedicatedMemory(vkd, *device, *bufferB, requirements, externalMemoryType, memoryTypeIndex, handleB));
2118 objectHandleA = (*memoryA).getInternal();
2119 objectHandleB = (*memoryB).getInternal();
2120 recorder.setCallbackMarker(MARKER_UNIMPORT);
2121 }
2122
2123 recorder.setCallbackMarker(MARKER_FREE);
2124 }
2125
2126 recorder.setCallbackMarker(MARKER_UNKNOWN);
2127
2128 deBool allocateEvent = false;
2129 deBool freeEvent = false;
2130 deBool importA = false;
2131 deBool importB = false;
2132 deBool unimportA = false;
2133 deBool unimportB = false;
2134 deUint64 memoryObjectId = 0;
2135
2136 for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
2137 {
2138 const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
2139 const CallbackMarker marker = iter->second;
2140
2141 if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
2142 {
2143 TCU_CHECK(marker == MARKER_ALLOCATE);
2144 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2145 TCU_CHECK(memoryObjectId == 0);
2146 TCU_CHECK(record.memoryObjectId != 0);
2147 TCU_CHECK_MSG(record.size >= requirements.size,
2148 ("size: record=" + de::toString(record.size) +
2149 ", requirements=" + de::toString(requirements.size)).c_str());
2150
2151 allocateEvent = true;
2152 memoryObjectId = record.memoryObjectId;
2153 }
2154 else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
2155 {
2156 TCU_CHECK(marker == MARKER_IMPORT);
2157 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2158 TCU_CHECK_MSG(record.size >= requirements.size,
2159 ("sizeA: record=" + de::toString(record.size) +
2160 ", requirements=" + de::toString(requirements.size)).c_str());
2161 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2162 ("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
2163 ", original=" + de::toString(memoryObjectId)).c_str());
2164
2165 importA = true;
2166 }
2167 else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
2168 {
2169 TCU_CHECK(marker == MARKER_IMPORT);
2170 TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
2171 TCU_CHECK_MSG(record.size >= requirements.size,
2172 ("sizeB: record=" + de::toString(record.size) +
2173 ", requirements=" + de::toString(requirements.size)).c_str());
2174 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2175 ("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
2176 ", original=" + de::toString(memoryObjectId)).c_str());
2177
2178 importB = true;
2179 }
2180 else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
2181 {
2182 TCU_CHECK(marker == MARKER_UNIMPORT);
2183 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2184 ("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
2185 ", original=" + de::toString(memoryObjectId)).c_str());
2186
2187 unimportB = true;
2188 }
2189 else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
2190 {
2191 TCU_CHECK(marker == MARKER_UNIMPORT);
2192 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2193 ("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
2194 ", original=" + de::toString(memoryObjectId)).c_str());
2195
2196 unimportA = true;
2197 }
2198 else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
2199 {
2200 TCU_CHECK(marker == MARKER_FREE);
2201 TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
2202 ("memoryObjectId: record=" + de::toString(record.memoryObjectId) +
2203 ", original=" + de::toString(memoryObjectId)).c_str());
2204
2205 freeEvent = true;
2206 }
2207 }
2208
2209 TCU_CHECK(allocateEvent);
2210 TCU_CHECK(importA);
2211 TCU_CHECK(importB);
2212 TCU_CHECK(unimportB);
2213 TCU_CHECK(unimportA);
2214 TCU_CHECK(freeEvent);
2215
2216 return tcu::TestStatus::pass("Pass");
2217 }
2218
createExternalMemoryTestsGroup(tcu::TestContext & testCtx,const char * name,const char * desc)2219 tcu::TestCaseGroup* createExternalMemoryTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc)
2220 {
2221 MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
2222
2223 const std::vector<VkExternalMemoryHandleTypeFlagBits> externalMemoryTypes =
2224 {
2225 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
2226 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
2227 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
2228 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
2229 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
2230 };
2231
2232 for (const auto externalMemoryType : externalMemoryTypes)
2233 {
2234 const std::string testName = std::string("import_and_unimport_") + std::string(externalMemoryTypeToName(externalMemoryType));
2235
2236 addFunctionCase(group.get(), testName.c_str(), "", checkSupport, testImportAndUnimportExternalMemory, externalMemoryType);
2237 }
2238
2239 return group.release();
2240 }
2241
2242 } // anonymous
2243
createDeviceMemoryReportTests(tcu::TestContext & testCtx)2244 tcu::TestCaseGroup* createDeviceMemoryReportTests (tcu::TestContext& testCtx)
2245 {
2246 MovePtr<tcu::TestCaseGroup> deviceMemoryReportTests (new tcu::TestCaseGroup(testCtx, "device_memory_report", "Device Memory Report tests"));
2247
2248 const Image::Parameters img1D (0u,
2249 VK_IMAGE_TYPE_1D,
2250 VK_FORMAT_R8G8B8A8_UNORM,
2251 makeExtent3D(256, 1, 1),
2252 1u,
2253 4u,
2254 VK_SAMPLE_COUNT_1_BIT,
2255 VK_IMAGE_TILING_OPTIMAL,
2256 VK_IMAGE_USAGE_SAMPLED_BIT,
2257 VK_IMAGE_LAYOUT_UNDEFINED);
2258 const Image::Parameters img2D (0u,
2259 VK_IMAGE_TYPE_2D,
2260 VK_FORMAT_R8G8B8A8_UNORM,
2261 makeExtent3D(64, 64, 1),
2262 1u,
2263 12u,
2264 VK_SAMPLE_COUNT_1_BIT,
2265 VK_IMAGE_TILING_OPTIMAL,
2266 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
2267 VK_IMAGE_LAYOUT_UNDEFINED);
2268 const Image::Parameters imgCube (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
2269 VK_IMAGE_TYPE_2D,
2270 VK_FORMAT_R8G8B8A8_UNORM,
2271 makeExtent3D(64, 64, 1),
2272 1u,
2273 12u,
2274 VK_SAMPLE_COUNT_1_BIT,
2275 VK_IMAGE_TILING_OPTIMAL,
2276 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
2277 VK_IMAGE_LAYOUT_UNDEFINED);
2278 const Image::Parameters img3D (0u,
2279 VK_IMAGE_TYPE_3D,
2280 VK_FORMAT_R8G8B8A8_UNORM,
2281 makeExtent3D(64, 64, 4),
2282 1u,
2283 1u,
2284 VK_SAMPLE_COUNT_1_BIT,
2285 VK_IMAGE_TILING_OPTIMAL,
2286 VK_IMAGE_USAGE_SAMPLED_BIT,
2287 VK_IMAGE_LAYOUT_UNDEFINED);
2288 const ImageView::Parameters imgView1D (img1D,
2289 VK_IMAGE_VIEW_TYPE_1D,
2290 img1D.format,
2291 makeComponentMappingRGBA(),
2292 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2293 const ImageView::Parameters imgView1DArr (img1D,
2294 VK_IMAGE_VIEW_TYPE_1D_ARRAY,
2295 img1D.format,
2296 makeComponentMappingRGBA(),
2297 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 4u));
2298 const ImageView::Parameters imgView2D (img2D,
2299 VK_IMAGE_VIEW_TYPE_2D,
2300 img2D.format,
2301 makeComponentMappingRGBA(),
2302 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2303 const ImageView::Parameters imgView2DArr (img2D,
2304 VK_IMAGE_VIEW_TYPE_2D_ARRAY,
2305 img2D.format,
2306 makeComponentMappingRGBA(),
2307 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 8u));
2308 const ImageView::Parameters imgViewCube (imgCube,VK_IMAGE_VIEW_TYPE_CUBE,
2309 img2D.format,
2310 makeComponentMappingRGBA(),
2311 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 6u));
2312 const ImageView::Parameters imgViewCubeArr (imgCube,
2313 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
2314 img2D.format,
2315 makeComponentMappingRGBA(),
2316 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 12u));
2317 const ImageView::Parameters imgView3D (img3D,
2318 VK_IMAGE_VIEW_TYPE_3D,
2319 img3D.format,
2320 makeComponentMappingRGBA(),
2321 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
2322
2323 const DescriptorSetLayout::Parameters singleUboDescLayout = DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, VK_SHADER_STAGE_VERTEX_BIT);
2324
2325 const NamedParameters<Device> s_deviceCases[] =
2326 {
2327 { "device", Device::Parameters() },
2328 };
2329 static const NamedParameters<DeviceMemory> s_deviceMemCases[] =
2330 {
2331 { "device_memory_small", DeviceMemory::Parameters(1024, 0u) },
2332 };
2333 static const NamedParameters<Buffer> s_bufferCases[] =
2334 {
2335 { "buffer_uniform_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
2336 { "buffer_uniform_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
2337 { "buffer_storage_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
2338 { "buffer_storage_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
2339 };
2340 static const NamedParameters<BufferView> s_bufferViewCases[] =
2341 {
2342 { "buffer_view_uniform_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
2343 { "buffer_view_storage_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
2344 };
2345 static const NamedParameters<Image> s_imageCases[] =
2346 {
2347 { "image_1d", img1D },
2348 { "image_2d", img2D },
2349 { "image_3d", img3D },
2350 };
2351 static const NamedParameters<ImageView> s_imageViewCases[] =
2352 {
2353 { "image_view_1d", imgView1D },
2354 { "image_view_1d_arr", imgView1DArr },
2355 { "image_view_2d", imgView2D },
2356 { "image_view_2d_arr", imgView2DArr },
2357 { "image_view_cube", imgViewCube },
2358 { "image_view_cube_arr", imgViewCubeArr },
2359 { "image_view_3d", imgView3D },
2360 };
2361 static const NamedParameters<Semaphore> s_semaphoreCases[] =
2362 {
2363 { "semaphore", Semaphore::Parameters(0u), }
2364 };
2365 static const NamedParameters<Event> s_eventCases[] =
2366 {
2367 { "event", Event::Parameters(0u) }
2368 };
2369 static const NamedParameters<Fence> s_fenceCases[] =
2370 {
2371 { "fence", Fence::Parameters(0u) },
2372 { "fence_signaled", Fence::Parameters(VK_FENCE_CREATE_SIGNALED_BIT) }
2373 };
2374 static const NamedParameters<QueryPool> s_queryPoolCases[] =
2375 {
2376 { "query_pool", QueryPool::Parameters(VK_QUERY_TYPE_OCCLUSION, 1u, 0u) }
2377 };
2378 static const NamedParameters<ShaderModule> s_shaderModuleCases[] =
2379 {
2380 { "shader_module", ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "test") }
2381 };
2382 static const NamedParameters<PipelineCache> s_pipelineCacheCases[] =
2383 {
2384 { "pipeline_cache", PipelineCache::Parameters() }
2385 };
2386 static const NamedParameters<Sampler> s_samplerCases[] =
2387 {
2388 { "sampler", Sampler::Parameters() }
2389 };
2390 static const NamedParameters<DescriptorSetLayout> s_descriptorSetLayoutCases[] =
2391 {
2392 { "descriptor_set_layout_empty", DescriptorSetLayout::Parameters::empty() },
2393 { "descriptor_set_layout_single", singleUboDescLayout }
2394 };
2395 static const NamedParameters<PipelineLayout> s_pipelineLayoutCases[] =
2396 {
2397 { "pipeline_layout_empty", PipelineLayout::Parameters::empty() },
2398 { "pipeline_layout_single", PipelineLayout::Parameters::singleDescriptorSet(singleUboDescLayout) }
2399 };
2400 static const NamedParameters<RenderPass> s_renderPassCases[] =
2401 {
2402 { "render_pass", RenderPass::Parameters() }
2403 };
2404 static const NamedParameters<GraphicsPipeline> s_graphicsPipelineCases[] =
2405 {
2406 { "graphics_pipeline", GraphicsPipeline::Parameters() }
2407 };
2408 static const NamedParameters<ComputePipeline> s_computePipelineCases[] =
2409 {
2410 { "compute_pipeline", ComputePipeline::Parameters() }
2411 };
2412 static const NamedParameters<DescriptorPool> s_descriptorPoolCases[] =
2413 {
2414 { "descriptor_pool", DescriptorPool::Parameters::singleType((VkDescriptorPoolCreateFlags)0, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) },
2415 { "descriptor_pool_free_descriptor_set", DescriptorPool::Parameters::singleType(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) }
2416 };
2417 static const NamedParameters<DescriptorSet> s_descriptorSetCases[] =
2418 {
2419 { "descriptor_set", DescriptorSet::Parameters(singleUboDescLayout) }
2420 };
2421 static const NamedParameters<Framebuffer> s_framebufferCases[] =
2422 {
2423 { "framebuffer", Framebuffer::Parameters() }
2424 };
2425 static const NamedParameters<CommandPool> s_commandPoolCases[] =
2426 {
2427 { "command_pool", CommandPool::Parameters((VkCommandPoolCreateFlags)0) },
2428 { "command_pool_transient", CommandPool::Parameters(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) }
2429 };
2430 static const NamedParameters<CommandBuffer> s_commandBufferCases[] =
2431 {
2432 { "command_buffer_primary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_PRIMARY) },
2433 { "command_buffer_secondary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_SECONDARY) }
2434 };
2435
2436 const CaseDescriptions s_createDestroyObjectGroup =
2437 {
2438 CASE_DESC(createDestroyObjectTest <Device>, s_deviceCases),
2439 CASE_DESC(createDestroyObjectTest <DeviceMemory>, s_deviceMemCases),
2440 CASE_DESC(createDestroyObjectTest <Buffer>, s_bufferCases),
2441 CASE_DESC(createDestroyObjectTest <BufferView>, s_bufferViewCases),
2442 CASE_DESC(createDestroyObjectTest <Image>, s_imageCases),
2443 CASE_DESC(createDestroyObjectTest <ImageView>, s_imageViewCases),
2444 CASE_DESC(createDestroyObjectTest <Semaphore>, s_semaphoreCases),
2445 CASE_DESC(createDestroyObjectTest <Event>, s_eventCases),
2446 CASE_DESC(createDestroyObjectTest <Fence>, s_fenceCases),
2447 CASE_DESC(createDestroyObjectTest <QueryPool>, s_queryPoolCases),
2448 CASE_DESC(createDestroyObjectTest <ShaderModule>, s_shaderModuleCases),
2449 CASE_DESC(createDestroyObjectTest <PipelineCache>, s_pipelineCacheCases),
2450 CASE_DESC(createDestroyObjectTest <Sampler>, s_samplerCases),
2451 CASE_DESC(createDestroyObjectTest <DescriptorSetLayout>, s_descriptorSetLayoutCases),
2452 CASE_DESC(createDestroyObjectTest <PipelineLayout>, s_pipelineLayoutCases),
2453 CASE_DESC(createDestroyObjectTest <RenderPass>, s_renderPassCases),
2454 CASE_DESC(createDestroyObjectTest <GraphicsPipeline>, s_graphicsPipelineCases),
2455 CASE_DESC(createDestroyObjectTest <ComputePipeline>, s_computePipelineCases),
2456 CASE_DESC(createDestroyObjectTest <DescriptorPool>, s_descriptorPoolCases),
2457 CASE_DESC(createDestroyObjectTest <DescriptorSet>, s_descriptorSetCases),
2458 CASE_DESC(createDestroyObjectTest <Framebuffer>, s_framebufferCases),
2459 CASE_DESC(createDestroyObjectTest <CommandPool>, s_commandPoolCases),
2460 CASE_DESC(createDestroyObjectTest <CommandBuffer>, s_commandBufferCases),
2461 };
2462 deviceMemoryReportTests->addChild(createObjectTestsGroup(testCtx, "create_and_destroy_object", "Check emitted callbacks are properly paired", s_createDestroyObjectGroup));
2463 deviceMemoryReportTests->addChild(createVkDeviceMemoryTestsGroup(testCtx, "vk_device_memory", "Check callbacks are emitted properly for VkDeviceMemory"));
2464 deviceMemoryReportTests->addChild(createExternalMemoryTestsGroup(testCtx, "external_memory", "Check callbacks are emitted properly for external memory"));
2465
2466 return deviceMemoryReportTests.release();
2467 }
2468
2469 } // memory
2470 } // vkt
2471