1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2023 The Khronos Group Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Sparse resource operations on transfer queue tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktSparseResourcesBufferSparseBinding.hpp"
25 #include "vktSparseResourcesTestsUtil.hpp"
26 #include "vktSparseResourcesBase.hpp"
27 #include "vktTestCaseUtil.hpp"
28
29 #include "vkDefs.hpp"
30 #include "vkRef.hpp"
31 #include "vkRefUtil.hpp"
32 #include "vkPlatform.hpp"
33 #include "vkPrograms.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vkBarrierUtil.hpp"
36 #include "vkBuilderUtil.hpp"
37 #include "vkImageUtil.hpp"
38 #include "vkQueryUtil.hpp"
39 #include "vkTypeUtil.hpp"
40 #include "vkCmdUtil.hpp"
41
42 #include "deUniquePtr.hpp"
43 #include "deStringUtil.hpp"
44 #include "tcuTextureUtil.hpp"
45 #include "tcuImageCompare.hpp"
46 #include "tcuTestContext.hpp"
47 #include "tcuTestLog.hpp"
48
49 #include <string>
50 #include <vector>
51
52 using namespace vk;
53
54 namespace vkt
55 {
56 namespace sparse
57 {
58 namespace
59 {
60
61 class SparseResourceTransferQueueCase : public TestCase
62 {
63 public:
64 SparseResourceTransferQueueCase(tcu::TestContext &testCtx, const std::string &name, const ImageType imageType,
65 const tcu::UVec3 &imageSize, const VkFormat format);
66
67 TestInstance *createInstance(Context &context) const;
68 virtual void checkSupport(Context &context) const;
69
70 private:
71 const ImageType m_imageType;
72 const tcu::UVec3 m_imageSize;
73 const VkFormat m_format;
74 };
75
SparseResourceTransferQueueCase(tcu::TestContext & testCtx,const std::string & name,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format)76 SparseResourceTransferQueueCase::SparseResourceTransferQueueCase(tcu::TestContext &testCtx, const std::string &name,
77 const ImageType imageType, const tcu::UVec3 &imageSize,
78 const VkFormat format)
79
80 : TestCase(testCtx, name)
81 , m_imageType(imageType)
82 , m_imageSize(imageSize)
83 , m_format(format)
84 {
85 }
86
checkSupport(Context & context) const87 void SparseResourceTransferQueueCase::checkSupport(Context &context) const
88 {
89 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
90
91 if (!isImageSizeSupported(context.getInstanceInterface(), context.getPhysicalDevice(), m_imageType, m_imageSize))
92 TCU_THROW(NotSupportedError, "Image size not supported for device");
93
94 if (formatIsR64(m_format))
95 {
96 context.requireDeviceFunctionality("VK_EXT_shader_image_atomic_int64");
97
98 if (context.getShaderImageAtomicInt64FeaturesEXT().sparseImageInt64Atomics == VK_FALSE)
99 {
100 TCU_THROW(NotSupportedError, "sparseImageInt64Atomics is not supported for device");
101 }
102 }
103 }
104
105 class SparseResourceTransferQueueInstance : public SparseResourcesBaseInstance
106 {
107 public:
108 SparseResourceTransferQueueInstance(Context &context, const ImageType imageType, const tcu::UVec3 &imageSize,
109 const VkFormat format);
110
111 tcu::TestStatus iterate(void);
112
113 private:
114 // Test params
115 const ImageType m_imageType;
116 const tcu::UVec3 m_imageSize;
117 const VkFormat m_format;
118
119 // Copy
120 Move<VkImage> m_sparseImage;
121 std::vector<DeviceMemorySp> m_deviceMemUniquePtrVec;
122 VkImageCreateInfo m_sparseInfo;
123 };
124
SparseResourceTransferQueueInstance(Context & context,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format)125 SparseResourceTransferQueueInstance::SparseResourceTransferQueueInstance(Context &context, const ImageType imageType,
126 const tcu::UVec3 &imageSize,
127 const VkFormat format)
128
129 : SparseResourcesBaseInstance(context, false)
130 , m_imageType(imageType)
131 , m_imageSize(imageSize)
132 , m_format(format)
133 , m_sparseImage()
134 , m_deviceMemUniquePtrVec()
135 , m_sparseInfo()
136 {
137 }
138
iterate(void)139 tcu::TestStatus SparseResourceTransferQueueInstance::iterate(void)
140 {
141 const InstanceInterface &instance = m_context.getInstanceInterface();
142
143 {
144 // Create logical device supporting both sparse and compute queues
145 QueueRequirementsVec queueRequirements;
146 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_GRAPHICS_BIT, 1u));
147 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
148
149 createDeviceSupportingQueues(queueRequirements);
150 }
151
152 const VkPhysicalDevice physicalDevice = getPhysicalDevice();
153 const DeviceInterface &deviceInterface = getDeviceInterface();
154 const Queue &universalQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_GRAPHICS_BIT, 0);
155 const Queue &transferQueue = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
156
157 const PlanarFormatDescription formatDescription = getPlanarFormatDescription(m_format);
158
159 // Filling sparse image info
160 {
161 m_sparseInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; //VkStructureType sType;
162 m_sparseInfo.pNext = DE_NULL; //const void* pNext;
163 m_sparseInfo.flags = VK_IMAGE_CREATE_SPARSE_BINDING_BIT; //VkImageCreateFlags flags;
164 m_sparseInfo.imageType = mapImageType(m_imageType); //VkImageType imageType;
165 m_sparseInfo.format = m_format; //VkFormat format;
166 m_sparseInfo.extent = makeExtent3D(getLayerSize(m_imageType, m_imageSize)); //VkExtent3D extent;
167 m_sparseInfo.arrayLayers = getNumLayers(m_imageType, m_imageSize); //uint32_t arrayLayers;
168 m_sparseInfo.samples = VK_SAMPLE_COUNT_1_BIT; //VkSampleCountFlagBits samples;
169 m_sparseInfo.tiling = VK_IMAGE_TILING_OPTIMAL; //VkImageTiling tiling;
170 m_sparseInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //VkImageLayout initialLayout;
171 m_sparseInfo.usage =
172 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, //VkImageUsageFlags usage;
173 m_sparseInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; //VkSharingMode sharingMode;
174 m_sparseInfo.queueFamilyIndexCount = 0u; //uint32_t queueFamilyIndexCount;
175 m_sparseInfo.pQueueFamilyIndices = DE_NULL; //const uint32_t* pQueueFamilyIndices;
176
177 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
178 {
179 m_sparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
180 }
181
182 VkImageFormatProperties imageFormatProperties;
183 if (instance.getPhysicalDeviceImageFormatProperties(physicalDevice, m_sparseInfo.format, m_sparseInfo.imageType,
184 m_sparseInfo.tiling, m_sparseInfo.usage, m_sparseInfo.flags,
185 &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
186 {
187 TCU_THROW(NotSupportedError, "Image format does not support sparse binding operations");
188 }
189
190 m_sparseInfo.mipLevels =
191 getMipmapCount(m_format, formatDescription, imageFormatProperties, m_sparseInfo.extent);
192 }
193
194 // Creating and binding sparse image
195 m_sparseImage = createImage(deviceInterface, getDevice(), &m_sparseInfo);
196 const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
197 const VkMemoryRequirements imageMemoryRequirements =
198 getImageMemoryRequirements(deviceInterface, getDevice(), *m_sparseImage);
199 if (imageMemoryRequirements.size >
200 getPhysicalDeviceProperties(instance, getPhysicalDevice()).limits.sparseAddressSpaceSize)
201 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
202
203 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
204
205 {
206 std::vector<VkSparseMemoryBind> sparseMemoryBinds;
207 const uint32_t numSparseBinds =
208 static_cast<uint32_t>(imageMemoryRequirements.size / imageMemoryRequirements.alignment);
209 const uint32_t memoryType =
210 findMatchingMemoryType(instance, getPhysicalDevice(), imageMemoryRequirements, MemoryRequirement::Any);
211
212 if (memoryType == NO_MATCH_FOUND)
213 return tcu::TestStatus::fail("No matching memory type found");
214
215 for (uint32_t sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
216 {
217 const VkSparseMemoryBind sparseMemoryBind =
218 makeSparseMemoryBind(deviceInterface, getDevice(), imageMemoryRequirements.alignment, memoryType,
219 imageMemoryRequirements.alignment * sparseBindNdx);
220
221 m_deviceMemUniquePtrVec.push_back(
222 makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory),
223 Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
224
225 sparseMemoryBinds.push_back(sparseMemoryBind);
226 }
227
228 const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo = makeSparseImageOpaqueMemoryBindInfo(
229 *m_sparseImage, static_cast<uint32_t>(sparseMemoryBinds.size()), sparseMemoryBinds.data());
230
231 const VkBindSparseInfo bindSparseInfo = {
232 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
233 DE_NULL, //const void* pNext;
234 0u, //uint32_t waitSemaphoreCount;
235 DE_NULL, //const VkSemaphore* pWaitSemaphores;
236 0u, //uint32_t bufferBindCount;
237 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
238 1u, //uint32_t imageOpaqueBindCount;
239 &opaqueBindInfo, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
240 0u, //uint32_t imageBindCount;
241 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
242 1u, //uint32_t signalSemaphoreCount;
243 &imageMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores;
244 };
245
246 // Submit sparse bind commands for execution
247 VK_CHECK(deviceInterface.queueBindSparse(universalQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
248 }
249
250 // Uploading
251 uint32_t imageSizeInBytes = 0;
252
253 for (uint32_t planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
254 for (uint32_t mipmapNdx = 0; mipmapNdx < m_sparseInfo.mipLevels; ++mipmapNdx)
255 imageSizeInBytes +=
256 getImageMipLevelSizeInBytes(m_sparseInfo.extent, m_sparseInfo.arrayLayers, formatDescription, planeNdx,
257 mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
258
259 std::vector<VkBufferImageCopy> bufferImageCopy(formatDescription.numPlanes * m_sparseInfo.mipLevels);
260 {
261 uint32_t bufferOffset = 0;
262 for (uint32_t planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
263 {
264 const VkImageAspectFlags aspect =
265 (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
266
267 for (uint32_t mipmapNdx = 0; mipmapNdx < m_sparseInfo.mipLevels; ++mipmapNdx)
268 {
269 bufferImageCopy[planeNdx * m_sparseInfo.mipLevels + mipmapNdx] = {
270 bufferOffset, // VkDeviceSize bufferOffset;
271 0u, // uint32_t bufferRowLength;
272 0u, // uint32_t bufferImageHeight;
273 makeImageSubresourceLayers(aspect, mipmapNdx, 0u,
274 m_sparseInfo.arrayLayers), // VkImageSubresourceLayers imageSubresource;
275 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
276 vk::getPlaneExtent(formatDescription, m_sparseInfo.extent, planeNdx,
277 mipmapNdx) // VkExtent3D imageExtent;
278 };
279 bufferOffset +=
280 getImageMipLevelSizeInBytes(m_sparseInfo.extent, m_sparseInfo.arrayLayers, formatDescription,
281 planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
282 }
283 }
284 }
285
286 // Create command buffer for compute and transfer operations
287 const Unique<VkCommandPool> commandPool(
288 makeCommandPool(deviceInterface, getDevice(), transferQueue.queueFamilyIndex));
289 const Unique<VkCommandBuffer> commandBuffer(
290 allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
291
292 // Start recording commands
293 beginCommandBuffer(deviceInterface, *commandBuffer);
294
295 const VkBufferCreateInfo inputBufferCreateInfo =
296 makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
297 const Unique<VkBuffer> inputBuffer(createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
298 const de::UniquePtr<Allocation> inputBufferAlloc(
299 bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
300
301 std::vector<uint8_t> referenceData(imageSizeInBytes);
302 for (uint32_t valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
303 {
304 referenceData[valueNdx] = static_cast<uint8_t>((valueNdx % imageMemoryRequirements.alignment) + 1u);
305 }
306
307 {
308 deMemcpy(inputBufferAlloc->getHostPtr(), referenceData.data(), imageSizeInBytes);
309 flushAlloc(deviceInterface, getDevice(), *inputBufferAlloc);
310
311 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier(
312 VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, *inputBuffer, 0u, imageSizeInBytes);
313 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
314 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
315 }
316
317 {
318 std::vector<VkImageMemoryBarrier> imageSparseTransferDstBarriers;
319
320 for (uint32_t planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
321 {
322 const VkImageAspectFlags aspect =
323 (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
324
325 imageSparseTransferDstBarriers.push_back(makeImageMemoryBarrier(
326 0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
327 *m_sparseImage,
328 makeImageSubresourceRange(aspect, 0u, m_sparseInfo.mipLevels, 0u, m_sparseInfo.arrayLayers),
329 universalQueue.queueFamilyIndex != transferQueue.queueFamilyIndex ? universalQueue.queueFamilyIndex :
330 VK_QUEUE_FAMILY_IGNORED,
331 universalQueue.queueFamilyIndex != transferQueue.queueFamilyIndex ? transferQueue.queueFamilyIndex :
332 VK_QUEUE_FAMILY_IGNORED));
333 }
334 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
335 VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL,
336 static_cast<uint32_t>(imageSparseTransferDstBarriers.size()),
337 imageSparseTransferDstBarriers.data());
338 }
339
340 deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *m_sparseImage,
341 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
342 static_cast<uint32_t>(bufferImageCopy.size()), bufferImageCopy.data());
343
344 const VkBufferCreateInfo outputBufferCreateInfo =
345 makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
346 const Unique<VkBuffer> outputBuffer(createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
347 const de::UniquePtr<Allocation> outputBufferAlloc(
348 bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
349 // Reading back from sparse image
350 {
351 std::vector<VkImageMemoryBarrier> imageSparseTransferSrcBarriers;
352
353 for (uint32_t planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
354 {
355 const VkImageAspectFlags aspect =
356 (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
357
358 imageSparseTransferSrcBarriers.push_back(makeImageMemoryBarrier(
359 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
360 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_sparseImage,
361 makeImageSubresourceRange(aspect, 0u, m_sparseInfo.mipLevels, 0u, m_sparseInfo.arrayLayers)));
362 }
363
364 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
365 VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL,
366 static_cast<uint32_t>(imageSparseTransferSrcBarriers.size()),
367 imageSparseTransferSrcBarriers.data());
368 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *m_sparseImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
369 *outputBuffer, static_cast<uint32_t>(bufferImageCopy.size()),
370 bufferImageCopy.data());
371 }
372
373 {
374 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier(
375 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0u, imageSizeInBytes);
376
377 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
378 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
379 }
380
381 // End recording commands
382 endCommandBuffer(deviceInterface, *commandBuffer);
383
384 const VkPipelineStageFlags stageBits[] = {VK_PIPELINE_STAGE_TRANSFER_BIT};
385
386 // Submit commands for execution and wait for completion
387 submitCommandsAndWait(deviceInterface, getDevice(), transferQueue.queueHandle, *commandBuffer, 1u,
388 &imageMemoryBindSemaphore.get(), stageBits, 0, DE_NULL);
389
390 // Retrieve data from buffer to host memory
391 invalidateAlloc(deviceInterface, getDevice(), *outputBufferAlloc);
392
393 // Wait for sparse queue to become idle
394 deviceInterface.queueWaitIdle(universalQueue.queueHandle);
395
396 const uint8_t *outputData = static_cast<const uint8_t *>(outputBufferAlloc->getHostPtr());
397 bool ignoreLsb6Bits = areLsb6BitsDontCare(m_sparseInfo.format);
398 bool ignoreLsb4Bits = areLsb4BitsDontCare(m_sparseInfo.format);
399
400 for (uint32_t planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
401 {
402 for (uint32_t mipmapNdx = 0; mipmapNdx < m_sparseInfo.mipLevels; ++mipmapNdx)
403 {
404 const uint32_t mipLevelSizeInBytes = getImageMipLevelSizeInBytes(
405 m_sparseInfo.extent, m_sparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx);
406 const uint32_t bufferOffset =
407 static_cast<uint32_t>(bufferImageCopy[planeNdx * m_sparseInfo.mipLevels + mipmapNdx].bufferOffset);
408
409 // Validate results
410 for (size_t byteNdx = 0; byteNdx < mipLevelSizeInBytes; byteNdx++)
411 {
412 const uint8_t res = *(outputData + bufferOffset + byteNdx);
413 const uint8_t ref = referenceData[bufferOffset + byteNdx];
414
415 uint8_t mask = 0xFF;
416
417 if (!(byteNdx & 0x01) && (ignoreLsb6Bits))
418 mask = 0xC0;
419 else if (!(byteNdx & 0x01) && (ignoreLsb4Bits))
420 mask = 0xF0;
421
422 if ((res & mask) != (ref & mask))
423 {
424 return tcu::TestStatus::fail("Failed");
425 }
426 }
427 }
428 }
429
430 return tcu::TestStatus::pass("Passed");
431 }
432
createInstance(Context & context) const433 TestInstance *SparseResourceTransferQueueCase::createInstance(Context &context) const
434 {
435 return new SparseResourceTransferQueueInstance(context, m_imageType, m_imageSize, m_format);
436 }
437
438 } // namespace
439
createTransferQueueTests(tcu::TestContext & testCtx)440 tcu::TestCaseGroup *createTransferQueueTests(tcu::TestContext &testCtx)
441 {
442 const std::vector<TestImageParameters> imageParameters{
443 {IMAGE_TYPE_1D,
444 {tcu::UVec3(512u, 1u, 1u), tcu::UVec3(1024u, 1u, 1u), tcu::UVec3(11u, 1u, 1u)},
445 getTestFormats(IMAGE_TYPE_1D)},
446 {IMAGE_TYPE_1D_ARRAY,
447 {tcu::UVec3(512u, 1u, 64u), tcu::UVec3(1024u, 1u, 8u), tcu::UVec3(11u, 1u, 3u)},
448 getTestFormats(IMAGE_TYPE_1D_ARRAY)},
449 {IMAGE_TYPE_2D,
450 {tcu::UVec3(512u, 256u, 1u), tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u, 137u, 1u)},
451 getTestFormats(IMAGE_TYPE_2D)},
452 {IMAGE_TYPE_2D_ARRAY,
453 {tcu::UVec3(512u, 256u, 6u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u)},
454 getTestFormats(IMAGE_TYPE_2D_ARRAY)},
455 {IMAGE_TYPE_3D,
456 {tcu::UVec3(512u, 256u, 6u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u)},
457 getTestFormats(IMAGE_TYPE_3D)},
458 {IMAGE_TYPE_CUBE,
459 {tcu::UVec3(256u, 256u, 1u), tcu::UVec3(128u, 128u, 1u), tcu::UVec3(137u, 137u, 1u)},
460 getTestFormats(IMAGE_TYPE_CUBE)},
461 {IMAGE_TYPE_CUBE_ARRAY,
462 {tcu::UVec3(256u, 256u, 6u), tcu::UVec3(128u, 128u, 8u), tcu::UVec3(137u, 137u, 3u)},
463 getTestFormats(IMAGE_TYPE_CUBE_ARRAY)}};
464
465 // Sparse resources on transfer queue operation tests.
466 de::MovePtr<tcu::TestCaseGroup> transferGroup(new tcu::TestCaseGroup(testCtx, "transfer_queue"));
467
468 for (size_t imageTypeNdx = 0; imageTypeNdx < imageParameters.size(); ++imageTypeNdx)
469 {
470 const ImageType imageType = imageParameters[imageTypeNdx].imageType;
471 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(
472 new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str()));
473
474 for (size_t formatNdx = 0; formatNdx < imageParameters[imageTypeNdx].formats.size(); ++formatNdx)
475 {
476 VkFormat format = imageParameters[imageTypeNdx].formats[formatNdx].format;
477 tcu::UVec3 imageSizeAlignment = getImageSizeAlignment(format);
478 de::MovePtr<tcu::TestCaseGroup> formatGroup(
479 new tcu::TestCaseGroup(testCtx, getImageFormatID(format).c_str()));
480
481 for (size_t imageSizeNdx = 0; imageSizeNdx < imageParameters[imageTypeNdx].imageSizes.size();
482 ++imageSizeNdx)
483 {
484 const tcu::UVec3 imageSize = imageParameters[imageTypeNdx].imageSizes[imageSizeNdx];
485
486 // skip test for images with odd sizes for some YCbCr formats
487 if ((imageSize.x() % imageSizeAlignment.x()) != 0)
488 continue;
489 if ((imageSize.y() % imageSizeAlignment.y()) != 0)
490 continue;
491
492 std::ostringstream stream;
493 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
494
495 formatGroup->addChild(
496 new SparseResourceTransferQueueCase(testCtx, stream.str(), imageType, imageSize, format));
497 }
498 imageTypeGroup->addChild(formatGroup.release());
499 }
500 transferGroup->addChild(imageTypeGroup.release());
501 }
502
503 return transferGroup.release();
504 }
505
506 } // namespace sparse
507 } // namespace vkt
508