1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 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 vktSparseResourcesImageSparseBinding.cpp
21 * \brief Sparse fully resident images with mipmaps 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
46 #include <string>
47 #include <vector>
48
49 using namespace vk;
50
51 namespace vkt
52 {
53 namespace sparse
54 {
55 namespace
56 {
57
58 class ImageSparseBindingCase : public TestCase
59 {
60 public:
61 ImageSparseBindingCase (tcu::TestContext& testCtx,
62 const std::string& name,
63 const ImageType imageType,
64 const tcu::UVec3& imageSize,
65 const VkFormat format,
66 const bool useDeviceGroups = false);
67
68 TestInstance* createInstance (Context& context) const;
69 virtual void checkSupport (Context& context) const;
70
71 private:
72 const bool m_useDeviceGroups;
73 const ImageType m_imageType;
74 const tcu::UVec3 m_imageSize;
75 const VkFormat m_format;
76 };
77
ImageSparseBindingCase(tcu::TestContext & testCtx,const std::string & name,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)78 ImageSparseBindingCase::ImageSparseBindingCase (tcu::TestContext& testCtx,
79 const std::string& name,
80 const ImageType imageType,
81 const tcu::UVec3& imageSize,
82 const VkFormat format,
83 const bool useDeviceGroups)
84
85 : TestCase (testCtx, name)
86 , m_useDeviceGroups (useDeviceGroups)
87 , m_imageType (imageType)
88 , m_imageSize (imageSize)
89 , m_format (format)
90 {
91 }
92
checkSupport(Context & context) const93 void ImageSparseBindingCase::checkSupport (Context& context) const
94 {
95 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
96
97 #ifndef CTS_USES_VULKANSC
98 if (m_format == VK_FORMAT_A8_UNORM_KHR)
99 context.requireDeviceFunctionality("VK_KHR_maintenance5");
100 #endif // CTS_USES_VULKANSC
101
102 if (!isImageSizeSupported(context.getInstanceInterface(), context.getPhysicalDevice(), m_imageType, m_imageSize))
103 TCU_THROW(NotSupportedError, "Image size not supported for device");
104
105 if (formatIsR64(m_format))
106 {
107 context.requireDeviceFunctionality("VK_EXT_shader_image_atomic_int64");
108
109 if (context.getShaderImageAtomicInt64FeaturesEXT().sparseImageInt64Atomics == VK_FALSE)
110 {
111 TCU_THROW(NotSupportedError, "sparseImageInt64Atomics is not supported for device");
112 }
113 }
114 }
115
116 class ImageSparseBindingInstance : public SparseResourcesBaseInstance
117 {
118 public:
119 ImageSparseBindingInstance (Context& context,
120 const ImageType imageType,
121 const tcu::UVec3& imageSize,
122 const VkFormat format,
123 const bool useDeviceGroups);
124
125 tcu::TestStatus iterate (void);
126
127 private:
128 const bool m_useDeviceGroups;
129 const ImageType m_imageType;
130 const tcu::UVec3 m_imageSize;
131 const VkFormat m_format;
132 };
133
ImageSparseBindingInstance(Context & context,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)134 ImageSparseBindingInstance::ImageSparseBindingInstance (Context& context,
135 const ImageType imageType,
136 const tcu::UVec3& imageSize,
137 const VkFormat format,
138 const bool useDeviceGroups)
139
140 : SparseResourcesBaseInstance (context, useDeviceGroups)
141 , m_useDeviceGroups (useDeviceGroups)
142 , m_imageType (imageType)
143 , m_imageSize (imageSize)
144 , m_format (format)
145 {
146 }
147
iterate(void)148 tcu::TestStatus ImageSparseBindingInstance::iterate (void)
149 {
150 const InstanceInterface& instance = m_context.getInstanceInterface();
151
152 {
153 // Create logical device supporting both sparse and compute queues
154 QueueRequirementsVec queueRequirements;
155 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
156 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
157
158 createDeviceSupportingQueues(queueRequirements, false, m_format == VK_FORMAT_A8_UNORM_KHR);
159 }
160
161 const VkPhysicalDevice physicalDevice = getPhysicalDevice();
162 VkImageCreateInfo imageSparseInfo;
163 std::vector<DeviceMemorySp> deviceMemUniquePtrVec;
164
165 const DeviceInterface& deviceInterface = getDeviceInterface();
166 const Queue& sparseQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
167 const Queue& computeQueue = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
168 const PlanarFormatDescription formatDescription = getPlanarFormatDescription(m_format);
169
170 // Go through all physical devices
171 for (deUint32 physDevID = 0; physDevID < m_numPhysicalDevices; ++physDevID)
172 {
173 const deUint32 firstDeviceID = physDevID;
174 const deUint32 secondDeviceID = (firstDeviceID + 1) % m_numPhysicalDevices;
175
176 imageSparseInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; //VkStructureType sType;
177 imageSparseInfo.pNext = DE_NULL; //const void* pNext;
178 imageSparseInfo.flags = VK_IMAGE_CREATE_SPARSE_BINDING_BIT; //VkImageCreateFlags flags;
179 imageSparseInfo.imageType = mapImageType(m_imageType); //VkImageType imageType;
180 imageSparseInfo.format = m_format; //VkFormat format;
181 imageSparseInfo.extent = makeExtent3D(getLayerSize(m_imageType, m_imageSize)); //VkExtent3D extent;
182 imageSparseInfo.arrayLayers = getNumLayers(m_imageType, m_imageSize); //deUint32 arrayLayers;
183 imageSparseInfo.samples = VK_SAMPLE_COUNT_1_BIT; //VkSampleCountFlagBits samples;
184 imageSparseInfo.tiling = VK_IMAGE_TILING_OPTIMAL; //VkImageTiling tiling;
185 imageSparseInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; //VkImageLayout initialLayout;
186 imageSparseInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
187 VK_IMAGE_USAGE_TRANSFER_DST_BIT; //VkImageUsageFlags usage;
188 imageSparseInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; //VkSharingMode sharingMode;
189 imageSparseInfo.queueFamilyIndexCount = 0u; //deUint32 queueFamilyIndexCount;
190 imageSparseInfo.pQueueFamilyIndices = DE_NULL; //const deUint32* pQueueFamilyIndices;
191
192 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
193 {
194 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
195 }
196
197 {
198 VkImageFormatProperties imageFormatProperties;
199 if (instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
200 imageSparseInfo.format,
201 imageSparseInfo.imageType,
202 imageSparseInfo.tiling,
203 imageSparseInfo.usage,
204 imageSparseInfo.flags,
205 &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
206 {
207 TCU_THROW(NotSupportedError, "Image format does not support sparse binding operations");
208 }
209
210 imageSparseInfo.mipLevels = getMipmapCount(m_format, formatDescription, imageFormatProperties, imageSparseInfo.extent);
211 }
212
213 // Create sparse image
214 const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
215
216 // Create sparse image memory bind semaphore
217 const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
218
219 // Get sparse image general memory requirements
220 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
221
222 // Check if required image memory size does not exceed device limits
223 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, getPhysicalDevice(secondDeviceID)).limits.sparseAddressSpaceSize)
224 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
225
226 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
227
228 {
229 std::vector<VkSparseMemoryBind> sparseMemoryBinds;
230 const deUint32 numSparseBinds = static_cast<deUint32>(imageMemoryRequirements.size / imageMemoryRequirements.alignment);
231 const deUint32 memoryType = findMatchingMemoryType(instance, getPhysicalDevice(secondDeviceID), imageMemoryRequirements, MemoryRequirement::Any);
232
233 if (memoryType == NO_MATCH_FOUND)
234 return tcu::TestStatus::fail("No matching memory type found");
235
236 if (firstDeviceID != secondDeviceID)
237 {
238 VkPeerMemoryFeatureFlags peerMemoryFeatureFlags = (VkPeerMemoryFeatureFlags)0;
239 const deUint32 heapIndex = getHeapIndexForMemoryType(instance, getPhysicalDevice(secondDeviceID), memoryType);
240 deviceInterface.getDeviceGroupPeerMemoryFeatures(getDevice(), heapIndex, firstDeviceID, secondDeviceID, &peerMemoryFeatureFlags);
241
242 if (((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) == 0) ||
243 ((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) == 0))
244 {
245 TCU_THROW(NotSupportedError, "Peer memory does not support COPY_SRC and COPY_DST");
246 }
247 }
248
249 for (deUint32 sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
250 {
251 const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
252 imageMemoryRequirements.alignment, memoryType, imageMemoryRequirements.alignment * sparseBindNdx);
253
254 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
255
256 sparseMemoryBinds.push_back(sparseMemoryBind);
257 }
258
259 const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo = makeSparseImageOpaqueMemoryBindInfo(*imageSparse, static_cast<deUint32>(sparseMemoryBinds.size()), sparseMemoryBinds.data());
260
261 const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
262 {
263 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, //VkStructureType sType;
264 DE_NULL, //const void* pNext;
265 firstDeviceID, //deUint32 resourceDeviceIndex;
266 secondDeviceID, //deUint32 memoryDeviceIndex;
267 };
268
269 const VkBindSparseInfo bindSparseInfo =
270 {
271 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
272 m_useDeviceGroups ? &devGroupBindSparseInfo : DE_NULL, //const void* pNext;
273 0u, //deUint32 waitSemaphoreCount;
274 DE_NULL, //const VkSemaphore* pWaitSemaphores;
275 0u, //deUint32 bufferBindCount;
276 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
277 1u, //deUint32 imageOpaqueBindCount;
278 &opaqueBindInfo, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
279 0u, //deUint32 imageBindCount;
280 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
281 1u, //deUint32 signalSemaphoreCount;
282 &imageMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores;
283 };
284
285 // Submit sparse bind commands for execution
286 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
287 }
288
289 deUint32 imageSizeInBytes = 0;
290
291 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
292 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
293 imageSizeInBytes += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
294
295 std::vector<VkBufferImageCopy> bufferImageCopy(formatDescription.numPlanes * imageSparseInfo.mipLevels);
296 {
297 deUint32 bufferOffset = 0;
298 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
299 {
300 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
301
302 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
303 {
304 bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx] =
305 {
306 bufferOffset, // VkDeviceSize bufferOffset;
307 0u, // deUint32 bufferRowLength;
308 0u, // deUint32 bufferImageHeight;
309 makeImageSubresourceLayers(aspect, mipmapNdx, 0u, imageSparseInfo.arrayLayers), // VkImageSubresourceLayers imageSubresource;
310 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
311 vk::getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipmapNdx) // VkExtent3D imageExtent;
312 };
313 bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
314 }
315 }
316 }
317
318 // Create command buffer for compute and transfer operations
319 const Unique<VkCommandPool> commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
320 const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
321
322 // Start recording commands
323 beginCommandBuffer(deviceInterface, *commandBuffer);
324
325 const VkBufferCreateInfo inputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
326 const Unique<VkBuffer> inputBuffer (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
327 const de::UniquePtr<Allocation> inputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
328
329 std::vector<deUint8> referenceData(imageSizeInBytes);
330 for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
331 {
332 referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageMemoryRequirements.alignment) + 1u);
333 }
334
335 {
336 deMemcpy(inputBufferAlloc->getHostPtr(), referenceData.data(), imageSizeInBytes);
337 flushAlloc(deviceInterface, getDevice(), *inputBufferAlloc);
338
339 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier (
340 VK_ACCESS_HOST_WRITE_BIT,
341 VK_ACCESS_TRANSFER_READ_BIT,
342 *inputBuffer,
343 0u,
344 imageSizeInBytes
345 );
346 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
347 }
348
349 {
350 std::vector<VkImageMemoryBarrier> imageSparseTransferDstBarriers;
351
352 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
353 {
354 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
355
356 imageSparseTransferDstBarriers.push_back( makeImageMemoryBarrier (
357 0u,
358 VK_ACCESS_TRANSFER_WRITE_BIT,
359 VK_IMAGE_LAYOUT_UNDEFINED,
360 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
361 *imageSparse,
362 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers),
363 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
364 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED
365 ));
366 }
367 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferDstBarriers.size()), imageSparseTransferDstBarriers.data());
368 }
369
370 deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), bufferImageCopy.data());
371
372 {
373 std::vector<VkImageMemoryBarrier> imageSparseTransferSrcBarriers;
374
375 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
376 {
377 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
378
379 imageSparseTransferSrcBarriers.push_back( makeImageMemoryBarrier (
380 VK_ACCESS_TRANSFER_WRITE_BIT,
381 VK_ACCESS_TRANSFER_READ_BIT,
382 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
383 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
384 *imageSparse,
385 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
386 ));
387 }
388
389 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferSrcBarriers.size()), imageSparseTransferSrcBarriers.data());
390 }
391
392 const VkBufferCreateInfo outputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
393 const Unique<VkBuffer> outputBuffer (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
394 const de::UniquePtr<Allocation> outputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
395
396 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), bufferImageCopy.data());
397
398 {
399 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
400 (
401 VK_ACCESS_TRANSFER_WRITE_BIT,
402 VK_ACCESS_HOST_READ_BIT,
403 *outputBuffer,
404 0u,
405 imageSizeInBytes
406 );
407
408 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
409 }
410
411 // End recording commands
412 endCommandBuffer(deviceInterface, *commandBuffer);
413
414 const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
415
416 // Submit commands for execution and wait for completion
417 submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits,
418 0, DE_NULL, m_useDeviceGroups, firstDeviceID);
419
420 // Retrieve data from buffer to host memory
421 invalidateAlloc(deviceInterface, getDevice(), *outputBufferAlloc);
422
423 // Wait for sparse queue to become idle
424 deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
425
426 const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
427 bool ignoreLsb6Bits = areLsb6BitsDontCare(imageSparseInfo.format);
428 bool ignoreLsb4Bits = areLsb4BitsDontCare(imageSparseInfo.format);
429
430 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
431 {
432 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
433 {
434 const deUint32 mipLevelSizeInBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx);
435 const deUint32 bufferOffset = static_cast<deUint32>(bufferImageCopy[ planeNdx * imageSparseInfo.mipLevels + mipmapNdx].bufferOffset);
436
437 // Validate results
438 for (size_t byteNdx = 0; byteNdx < mipLevelSizeInBytes; byteNdx++)
439 {
440 const deUint8 res = *(outputData + bufferOffset + byteNdx);
441 const deUint8 ref = referenceData[bufferOffset + byteNdx];
442
443 deUint8 mask = 0xFF;
444
445 if (!(byteNdx & 0x01) && (ignoreLsb6Bits))
446 mask = 0xC0;
447 else if (!(byteNdx & 0x01) && (ignoreLsb4Bits))
448 mask = 0xF0;
449
450 if ((res & mask) != (ref & mask))
451 {
452 return tcu::TestStatus::fail("Failed");
453 }
454 }
455 }
456 }
457 }
458
459 return tcu::TestStatus::pass("Passed");
460 }
461
createInstance(Context & context) const462 TestInstance* ImageSparseBindingCase::createInstance (Context& context) const
463 {
464 return new ImageSparseBindingInstance(context, m_imageType, m_imageSize, m_format, m_useDeviceGroups);
465 }
466
getSparseBindingTestFormats(ImageType imageType,bool addExtraFormat)467 std::vector<TestFormat> getSparseBindingTestFormats (ImageType imageType, bool addExtraFormat)
468 {
469 auto formats = getTestFormats(imageType);
470 #ifndef CTS_USES_VULKANSC
471 if (addExtraFormat)
472 formats.push_back(TestFormat{ VK_FORMAT_A8_UNORM_KHR });
473 #endif // CTS_USES_VULKANSC
474 return formats;
475 }
476
477 } // anonymous ns
478
createImageSparseBindingTestsCommon(tcu::TestContext & testCtx,de::MovePtr<tcu::TestCaseGroup> testGroup,const bool useDeviceGroup=false)479 tcu::TestCaseGroup* createImageSparseBindingTestsCommon(tcu::TestContext& testCtx, de::MovePtr<tcu::TestCaseGroup> testGroup, const bool useDeviceGroup = false)
480 {
481 const std::vector<TestImageParameters> imageParameters
482 {
483 { IMAGE_TYPE_1D, { tcu::UVec3(512u, 1u, 1u ), tcu::UVec3(1024u, 1u, 1u), tcu::UVec3(11u, 1u, 1u) }, getSparseBindingTestFormats(IMAGE_TYPE_1D, !useDeviceGroup) },
484 { IMAGE_TYPE_1D_ARRAY, { tcu::UVec3(512u, 1u, 64u), tcu::UVec3(1024u, 1u, 8u), tcu::UVec3(11u, 1u, 3u) }, getSparseBindingTestFormats(IMAGE_TYPE_1D_ARRAY, !useDeviceGroup) },
485 { IMAGE_TYPE_2D, { tcu::UVec3(512u, 256u, 1u ), tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u, 137u, 1u) }, getSparseBindingTestFormats(IMAGE_TYPE_2D, !useDeviceGroup) },
486 { IMAGE_TYPE_2D_ARRAY, { tcu::UVec3(512u, 256u, 6u ), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getSparseBindingTestFormats(IMAGE_TYPE_2D_ARRAY, !useDeviceGroup) },
487 { IMAGE_TYPE_3D, { tcu::UVec3(512u, 256u, 6u ), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getSparseBindingTestFormats(IMAGE_TYPE_3D, !useDeviceGroup) },
488 { IMAGE_TYPE_CUBE, { tcu::UVec3(256u, 256u, 1u ), tcu::UVec3(128u, 128u, 1u), tcu::UVec3(137u, 137u, 1u) }, getSparseBindingTestFormats(IMAGE_TYPE_CUBE, !useDeviceGroup) },
489 { IMAGE_TYPE_CUBE_ARRAY, { tcu::UVec3(256u, 256u, 6u ), tcu::UVec3(128u, 128u, 8u), tcu::UVec3(137u, 137u, 3u) }, getSparseBindingTestFormats(IMAGE_TYPE_CUBE_ARRAY, !useDeviceGroup) }
490 };
491
492 for (size_t imageTypeNdx = 0; imageTypeNdx < imageParameters.size(); ++imageTypeNdx)
493 {
494 const ImageType imageType = imageParameters[imageTypeNdx].imageType;
495 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup (new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str()));
496
497 for (size_t formatNdx = 0; formatNdx < imageParameters[imageTypeNdx].formats.size(); ++formatNdx)
498 {
499 VkFormat format = imageParameters[imageTypeNdx].formats[formatNdx].format;
500 tcu::UVec3 imageSizeAlignment = getImageSizeAlignment(format);
501 de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, getImageFormatID(format).c_str()));
502
503 for (size_t imageSizeNdx = 0; imageSizeNdx < imageParameters[imageTypeNdx].imageSizes.size(); ++imageSizeNdx)
504 {
505 const tcu::UVec3 imageSize = imageParameters[imageTypeNdx].imageSizes[imageSizeNdx];
506
507 // skip test for images with odd sizes for some YCbCr formats
508 if ((imageSize.x() % imageSizeAlignment.x()) != 0)
509 continue;
510 if ((imageSize.y() % imageSizeAlignment.y()) != 0)
511 continue;
512
513 std::ostringstream stream;
514 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
515
516 formatGroup->addChild(new ImageSparseBindingCase(testCtx, stream.str(), imageType, imageSize, format, useDeviceGroup));
517 }
518 imageTypeGroup->addChild(formatGroup.release());
519 }
520 testGroup->addChild(imageTypeGroup.release());
521 }
522
523 return testGroup.release();
524 }
525
createImageSparseBindingTests(tcu::TestContext & testCtx)526 tcu::TestCaseGroup* createImageSparseBindingTests(tcu::TestContext& testCtx)
527 {
528 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "image_sparse_binding"));
529 return createImageSparseBindingTestsCommon(testCtx, testGroup);
530 }
531
createDeviceGroupImageSparseBindingTests(tcu::TestContext & testCtx)532 tcu::TestCaseGroup* createDeviceGroupImageSparseBindingTests(tcu::TestContext& testCtx)
533 {
534 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "device_group_image_sparse_binding"));
535 return createImageSparseBindingTestsCommon(testCtx, testGroup, true);
536 }
537
538 } // sparse
539 } // vkt
540