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