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 vktSparseResourcesMipmapSparseResidency.cpp
21 * \brief Sparse partially resident images with mipmaps tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktSparseResourcesMipmapSparseResidency.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
45 #include <string>
46 #include <vector>
47
48 using namespace vk;
49
50 namespace vkt
51 {
52 namespace sparse
53 {
54 namespace
55 {
56
57 class MipmapSparseResidencyCase : public TestCase
58 {
59 public:
60 MipmapSparseResidencyCase (tcu::TestContext& testCtx,
61 const std::string& name,
62 const std::string& description,
63 const ImageType imageType,
64 const tcu::UVec3& imageSize,
65 const VkFormat format,
66 const bool useDeviceGroups);
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
MipmapSparseResidencyCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)78 MipmapSparseResidencyCase::MipmapSparseResidencyCase (tcu::TestContext& testCtx,
79 const std::string& name,
80 const std::string& description,
81 const ImageType imageType,
82 const tcu::UVec3& imageSize,
83 const VkFormat format,
84 const bool useDeviceGroups)
85 : TestCase (testCtx, name, description)
86 , m_useDeviceGroups (useDeviceGroups)
87 , m_imageType (imageType)
88 , m_imageSize (imageSize)
89 , m_format (format)
90 {
91 }
92
checkSupport(Context & context) const93 void MipmapSparseResidencyCase::checkSupport (Context& context) const
94 {
95 const InstanceInterface& instance = context.getInstanceInterface();
96 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
97
98 // Check if image size does not exceed device limits
99 if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
100 TCU_THROW(NotSupportedError, "Image size not supported for device");
101
102 // Check if device supports sparse operations for image type
103 if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
104 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
105 }
106
107 class MipmapSparseResidencyInstance : public SparseResourcesBaseInstance
108 {
109 public:
110 MipmapSparseResidencyInstance (Context& context,
111 const ImageType imageType,
112 const tcu::UVec3& imageSize,
113 const VkFormat format,
114 const bool useDeviceGroups);
115
116
117 tcu::TestStatus iterate (void);
118
119 private:
120 const bool m_useDeviceGroups;
121 const ImageType m_imageType;
122 const tcu::UVec3 m_imageSize;
123 const VkFormat m_format;
124 };
125
MipmapSparseResidencyInstance(Context & context,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)126 MipmapSparseResidencyInstance::MipmapSparseResidencyInstance (Context& context,
127 const ImageType imageType,
128 const tcu::UVec3& imageSize,
129 const VkFormat format,
130 const bool useDeviceGroups)
131 : SparseResourcesBaseInstance (context, useDeviceGroups)
132 , m_useDeviceGroups (useDeviceGroups)
133 , m_imageType (imageType)
134 , m_imageSize (imageSize)
135 , m_format (format)
136 {
137 }
138
iterate(void)139 tcu::TestStatus MipmapSparseResidencyInstance::iterate (void)
140 {
141 const InstanceInterface& instance = m_context.getInstanceInterface();
142 {
143 // Create logical device supporting both sparse and compute operations
144 QueueRequirementsVec queueRequirements;
145 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
146 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
147
148 createDeviceSupportingQueues(queueRequirements);
149 }
150
151 const VkPhysicalDevice physicalDevice = getPhysicalDevice();
152 VkImageCreateInfo imageSparseInfo;
153 std::vector<DeviceMemorySp> deviceMemUniquePtrVec;
154
155 const DeviceInterface& deviceInterface = getDeviceInterface();
156 const Queue& sparseQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
157 const Queue& computeQueue = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
158 const PlanarFormatDescription formatDescription = getPlanarFormatDescription(m_format);
159
160 // Go through all physical devices
161 for (deUint32 physDevID = 0; physDevID < m_numPhysicalDevices; physDevID++)
162 {
163 const deUint32 firstDeviceID = physDevID;
164 const deUint32 secondDeviceID = (firstDeviceID + 1) % m_numPhysicalDevices;
165
166 imageSparseInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
167 imageSparseInfo.pNext = DE_NULL;
168 imageSparseInfo.flags = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
169 imageSparseInfo.imageType = mapImageType(m_imageType);
170 imageSparseInfo.format = m_format;
171 imageSparseInfo.extent = makeExtent3D(getLayerSize(m_imageType, m_imageSize));
172 imageSparseInfo.arrayLayers = getNumLayers(m_imageType, m_imageSize);
173 imageSparseInfo.samples = VK_SAMPLE_COUNT_1_BIT;
174 imageSparseInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
175 imageSparseInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
176 imageSparseInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
177 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
178 imageSparseInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
179 imageSparseInfo.queueFamilyIndexCount = 0u;
180 imageSparseInfo.pQueueFamilyIndices = DE_NULL;
181
182 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
183 {
184 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
185 }
186
187 // Check if device supports sparse operations for image format
188 if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
189 TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
190
191 {
192 VkImageFormatProperties imageFormatProperties;
193 if (instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
194 imageSparseInfo.format,
195 imageSparseInfo.imageType,
196 imageSparseInfo.tiling,
197 imageSparseInfo.usage,
198 imageSparseInfo.flags,
199 &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
200 {
201 TCU_THROW(NotSupportedError, "Image format does not support sparse operations");
202 }
203
204 imageSparseInfo.mipLevels = getMipmapCount(m_format, formatDescription, imageFormatProperties, imageSparseInfo.extent);
205 }
206
207 // Create sparse image
208 const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
209
210 // Create sparse image memory bind semaphore
211 const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
212
213 std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements;
214
215 {
216 // Get sparse image general memory requirements
217 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
218
219 // Check if required image memory size does not exceed device limits
220 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
221 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
222
223 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
224
225 const deUint32 memoryType = findMatchingMemoryType(instance, getPhysicalDevice(secondDeviceID), imageMemoryRequirements, MemoryRequirement::Any);
226
227 if (memoryType == NO_MATCH_FOUND)
228 return tcu::TestStatus::fail("No matching memory type found");
229
230 if (firstDeviceID != secondDeviceID)
231 {
232 VkPeerMemoryFeatureFlags peerMemoryFeatureFlags = (VkPeerMemoryFeatureFlags)0;
233 const deUint32 heapIndex = getHeapIndexForMemoryType(instance, getPhysicalDevice(secondDeviceID), memoryType);
234 deviceInterface.getDeviceGroupPeerMemoryFeatures(getDevice(), heapIndex, firstDeviceID, secondDeviceID, &peerMemoryFeatureFlags);
235
236 if (((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) == 0) ||
237 ((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) == 0))
238 {
239 TCU_THROW(NotSupportedError, "Peer memory does not support COPY_SRC and COPY_DST");
240 }
241 }
242
243 // Get sparse image sparse memory requirements
244 sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
245 DE_ASSERT(sparseMemoryRequirements.size() != 0);
246
247 const deUint32 metadataAspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_METADATA_BIT);
248
249 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
250 std::vector<VkSparseMemoryBind> imageMipTailMemoryBinds;
251
252 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
253 {
254 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
255 const deUint32 aspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, aspect);
256
257 if (aspectIndex == NO_MATCH_FOUND)
258 TCU_THROW(NotSupportedError, "Not supported image aspect");
259
260 VkSparseImageMemoryRequirements aspectRequirements = sparseMemoryRequirements[aspectIndex];
261
262 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
263
264 VkExtent3D imageGranularity = aspectRequirements.formatProperties.imageGranularity;
265
266 // Bind memory for each layer
267 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
268 {
269 for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
270 {
271 const VkExtent3D mipExtent = getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipLevelNdx);
272 const tcu::UVec3 sparseBlocks = alignedDivide(mipExtent, imageGranularity);
273 const deUint32 numSparseBlocks = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
274 const VkImageSubresource subresource = { aspect, mipLevelNdx, layerNdx };
275
276 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(),
277 imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
278
279 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
280
281 imageResidencyMemoryBinds.push_back(imageMemoryBind);
282 }
283
284 if (!(aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
285 {
286 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
287 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
288
289 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
290
291 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
292 }
293
294 // Metadata
295 if (metadataAspectIndex != NO_MATCH_FOUND)
296 {
297 const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
298
299 if (!(metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT))
300 {
301 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
302 metadataAspectRequirements.imageMipTailSize, memoryType,
303 metadataAspectRequirements.imageMipTailOffset + layerNdx * metadataAspectRequirements.imageMipTailStride,
304 VK_SPARSE_MEMORY_BIND_METADATA_BIT);
305
306 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
307
308 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
309 }
310 }
311 }
312
313 if ((aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
314 {
315 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
316 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
317
318 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
319
320 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
321 }
322 }
323
324 // Metadata
325 if (metadataAspectIndex != NO_MATCH_FOUND)
326 {
327 const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
328
329 if (metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
330 {
331 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
332 metadataAspectRequirements.imageMipTailSize, memoryType, metadataAspectRequirements.imageMipTailOffset,
333 VK_SPARSE_MEMORY_BIND_METADATA_BIT);
334
335 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
336
337 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
338 }
339 }
340
341 const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
342 {
343 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
344 DE_NULL, //const void* pNext;
345 firstDeviceID, //deUint32 resourceDeviceIndex;
346 secondDeviceID, //deUint32 memoryDeviceIndex;
347 };
348
349 VkBindSparseInfo bindSparseInfo =
350 {
351 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
352 m_useDeviceGroups ? &devGroupBindSparseInfo : DE_NULL, //const void* pNext;
353 0u, //deUint32 waitSemaphoreCount;
354 DE_NULL, //const VkSemaphore* pWaitSemaphores;
355 0u, //deUint32 bufferBindCount;
356 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
357 0u, //deUint32 imageOpaqueBindCount;
358 DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
359 0u, //deUint32 imageBindCount;
360 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
361 1u, //deUint32 signalSemaphoreCount;
362 &imageMemoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores;
363 };
364
365 VkSparseImageMemoryBindInfo imageResidencyBindInfo;
366 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
367
368 if (imageResidencyMemoryBinds.size() > 0)
369 {
370 imageResidencyBindInfo.image = *imageSparse;
371 imageResidencyBindInfo.bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size());
372 imageResidencyBindInfo.pBinds = imageResidencyMemoryBinds.data();
373
374 bindSparseInfo.imageBindCount = 1u;
375 bindSparseInfo.pImageBinds = &imageResidencyBindInfo;
376 }
377
378 if (imageMipTailMemoryBinds.size() > 0)
379 {
380 imageMipTailBindInfo.image = *imageSparse;
381 imageMipTailBindInfo.bindCount = static_cast<deUint32>(imageMipTailMemoryBinds.size());
382 imageMipTailBindInfo.pBinds = imageMipTailMemoryBinds.data();
383
384 bindSparseInfo.imageOpaqueBindCount = 1u;
385 bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo;
386 }
387
388 // Submit sparse bind commands for execution
389 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
390 }
391
392 deUint32 imageSizeInBytes = 0;
393
394 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
395 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
396 imageSizeInBytes += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
397
398 std::vector <VkBufferImageCopy> bufferImageCopy(formatDescription.numPlanes*imageSparseInfo.mipLevels);
399 {
400 deUint32 bufferOffset = 0;
401
402 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
403 {
404 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
405
406 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
407 {
408 bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx] =
409 {
410 bufferOffset, // VkDeviceSize bufferOffset;
411 0u, // deUint32 bufferRowLength;
412 0u, // deUint32 bufferImageHeight;
413 makeImageSubresourceLayers(aspect, mipmapNdx, 0u, imageSparseInfo.arrayLayers), // VkImageSubresourceLayers imageSubresource;
414 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
415 vk::getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipmapNdx) // VkExtent3D imageExtent;
416 };
417 bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
418 }
419 }
420 }
421
422 // Create command buffer for compute and transfer operations
423 const Unique<VkCommandPool> commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
424 const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
425
426 // Start recording commands
427 beginCommandBuffer(deviceInterface, *commandBuffer);
428
429 const VkBufferCreateInfo inputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
430 const Unique<VkBuffer> inputBuffer (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
431 const de::UniquePtr<Allocation> inputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
432
433 std::vector<deUint8> referenceData(imageSizeInBytes);
434
435 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
436
437 for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
438 {
439 referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageMemoryRequirements.alignment) + 1u);
440 }
441
442 {
443 deMemcpy(inputBufferAlloc->getHostPtr(), referenceData.data(), imageSizeInBytes);
444 flushAlloc(deviceInterface, getDevice(), *inputBufferAlloc);
445
446 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
447 (
448 VK_ACCESS_HOST_WRITE_BIT,
449 VK_ACCESS_TRANSFER_READ_BIT,
450 *inputBuffer,
451 0u,
452 imageSizeInBytes
453 );
454
455 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
456 }
457
458 {
459 std::vector<VkImageMemoryBarrier> imageSparseTransferDstBarriers;
460
461 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
462 {
463 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
464
465 imageSparseTransferDstBarriers.emplace_back ( makeImageMemoryBarrier
466 (
467 0u,
468 VK_ACCESS_TRANSFER_WRITE_BIT,
469 VK_IMAGE_LAYOUT_UNDEFINED,
470 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
471 *imageSparse,
472 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers),
473 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
474 sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED
475 ));
476 }
477 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());
478 }
479
480 deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
481
482 {
483 std::vector<VkImageMemoryBarrier> imageSparseTransferSrcBarriers;
484
485 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
486 {
487 const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
488
489 imageSparseTransferSrcBarriers.emplace_back(makeImageMemoryBarrier
490 (
491 VK_ACCESS_TRANSFER_WRITE_BIT,
492 VK_ACCESS_TRANSFER_READ_BIT,
493 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
494 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
495 *imageSparse,
496 makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
497 ));
498 }
499
500 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());
501 }
502
503 const VkBufferCreateInfo outputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
504 const Unique<VkBuffer> outputBuffer (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
505 const de::UniquePtr<Allocation> outputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
506
507 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), bufferImageCopy.data());
508
509 {
510 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
511 (
512 VK_ACCESS_TRANSFER_WRITE_BIT,
513 VK_ACCESS_HOST_READ_BIT,
514 *outputBuffer,
515 0u,
516 imageSizeInBytes
517 );
518
519 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
520 }
521
522 // End recording commands
523 endCommandBuffer(deviceInterface, *commandBuffer);
524
525 const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
526
527 // Submit commands for execution and wait for completion
528 submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits,
529 0, DE_NULL, m_useDeviceGroups, firstDeviceID);
530
531 // Retrieve data from buffer to host memory
532 invalidateAlloc(deviceInterface, getDevice(), *outputBufferAlloc);
533
534 const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
535
536 // Wait for sparse queue to become idle
537 deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
538
539 for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
540 {
541 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
542 {
543 const deUint32 mipLevelSizeInBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx);
544 const deUint32 bufferOffset = static_cast<deUint32>(bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx].bufferOffset);
545
546 if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
547 return tcu::TestStatus::fail("Failed");
548 }
549 }
550 }
551 return tcu::TestStatus::pass("Passed");
552 }
553
createInstance(Context & context) const554 TestInstance* MipmapSparseResidencyCase::createInstance (Context& context) const
555 {
556 return new MipmapSparseResidencyInstance(context, m_imageType, m_imageSize, m_format, m_useDeviceGroups);
557 }
558
559 } // anonymous ns
560
createMipmapSparseResidencyTestsCommon(tcu::TestContext & testCtx,de::MovePtr<tcu::TestCaseGroup> testGroup,const bool useDeviceGroup=false)561 tcu::TestCaseGroup* createMipmapSparseResidencyTestsCommon (tcu::TestContext& testCtx, de::MovePtr<tcu::TestCaseGroup> testGroup, const bool useDeviceGroup = false)
562 {
563 const std::vector<TestImageParameters> imageParameters =
564 {
565 { IMAGE_TYPE_2D, { tcu::UVec3(512u, 256u, 1u), tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u, 137u, 1u) }, getTestFormats(IMAGE_TYPE_2D) },
566 { IMAGE_TYPE_2D_ARRAY, { tcu::UVec3(512u, 256u, 6u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_2D_ARRAY) },
567 { IMAGE_TYPE_CUBE, { tcu::UVec3(256u, 256u, 1u), tcu::UVec3(128u, 128u, 1u), tcu::UVec3(137u, 137u, 1u) }, getTestFormats(IMAGE_TYPE_CUBE) },
568 { IMAGE_TYPE_CUBE_ARRAY, { tcu::UVec3(256u, 256u, 6u), tcu::UVec3(128u, 128u, 8u), tcu::UVec3(137u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_CUBE_ARRAY) },
569 { IMAGE_TYPE_3D, { tcu::UVec3(256u, 256u, 16u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u, 137u, 3u) }, getTestFormats(IMAGE_TYPE_3D) }
570 };
571
572 for (size_t imageTypeNdx = 0; imageTypeNdx < imageParameters.size(); ++imageTypeNdx)
573 {
574 const ImageType imageType = imageParameters[imageTypeNdx].imageType;
575 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str(), ""));
576
577 for (size_t formatNdx = 0; formatNdx < imageParameters[imageTypeNdx].formats.size(); ++formatNdx)
578 {
579 VkFormat format = imageParameters[imageTypeNdx].formats[formatNdx].format;
580 tcu::UVec3 imageSizeAlignment = getImageSizeAlignment(format);
581 de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, getImageFormatID(format).c_str(), ""));
582
583 for (size_t imageSizeNdx = 0; imageSizeNdx < imageParameters[imageTypeNdx].imageSizes.size(); ++imageSizeNdx)
584 {
585 const tcu::UVec3 imageSize = imageParameters[imageTypeNdx].imageSizes[imageSizeNdx];
586
587 // skip test for images with odd sizes for some YCbCr formats
588 if ((imageSize.x() % imageSizeAlignment.x()) != 0)
589 continue;
590 if ((imageSize.y() % imageSizeAlignment.y()) != 0)
591 continue;
592
593 std::ostringstream stream;
594 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
595
596 formatGroup->addChild(new MipmapSparseResidencyCase(testCtx, stream.str(), "", imageType, imageSize, format, useDeviceGroup));
597 }
598 imageTypeGroup->addChild(formatGroup.release());
599 }
600 testGroup->addChild(imageTypeGroup.release());
601 }
602
603 return testGroup.release();
604 }
605
createMipmapSparseResidencyTests(tcu::TestContext & testCtx)606 tcu::TestCaseGroup* createMipmapSparseResidencyTests (tcu::TestContext& testCtx)
607 {
608 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mipmap_sparse_residency", "Mipmap Sparse Residency"));
609 return createMipmapSparseResidencyTestsCommon(testCtx, testGroup);
610 }
611
createDeviceGroupMipmapSparseResidencyTests(tcu::TestContext & testCtx)612 tcu::TestCaseGroup* createDeviceGroupMipmapSparseResidencyTests (tcu::TestContext& testCtx)
613 {
614 de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "device_group_mipmap_sparse_residency", "Mipmap Sparse Residency"));
615 return createMipmapSparseResidencyTestsCommon(testCtx, testGroup, true);
616 }
617
618 } // sparse
619 } // vkt
620