1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 * \file vktSparseResourcesShaderIntrinsicsBase.cpp
21 * \brief Sparse Resources Shader Intrinsics Base Classes
22 *//*--------------------------------------------------------------------*/
24 #include "vktSparseResourcesShaderIntrinsicsBase.hpp"
33 tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor)
37 result.x() = extent.width / divisor.width + ((extent.width % divisor.width) ? 1u : 0u);
38 result.y() = extent.height / divisor.height + ((extent.height % divisor.height) ? 1u : 0u);
39 result.z() = extent.depth / divisor.depth + ((extent.depth % divisor.depth) ? 1u : 0u);
44 std::string getOpTypeImageComponent (const tcu::TextureFormat& format)
46 switch (tcu::getTextureChannelClass(format.type))
48 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
49 return "OpTypeInt 32 0";
50 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
51 return "OpTypeInt 32 1";
58 std::string getOpTypeImageSparse (const ImageType imageType,
59 const tcu::TextureFormat& format,
60 const std::string& componentType,
61 const bool requiresSampler)
63 std::ostringstream src;
65 src << "OpTypeImage " << componentType << " ";
72 case IMAGE_TYPE_1D_ARRAY :
78 case IMAGE_TYPE_2D_ARRAY :
84 case IMAGE_TYPE_CUBE :
87 case IMAGE_TYPE_CUBE_ARRAY :
100 switch (format.order)
102 case tcu::TextureFormat::R:
105 case tcu::TextureFormat::RG:
108 case tcu::TextureFormat::RGB:
111 case tcu::TextureFormat::RGBA:
121 case tcu::TextureFormat::SIGNED_INT8:
124 case tcu::TextureFormat::SIGNED_INT16:
127 case tcu::TextureFormat::SIGNED_INT32:
130 case tcu::TextureFormat::UNSIGNED_INT8:
133 case tcu::TextureFormat::UNSIGNED_INT16:
136 case tcu::TextureFormat::UNSIGNED_INT32:
147 std::string getOpTypeImageResidency (const ImageType imageType)
149 std::ostringstream src;
151 src << "OpTypeImage %type_uint ";
156 src << "1D 0 0 0 2 R32ui";
158 case IMAGE_TYPE_1D_ARRAY :
159 src << "1D 0 1 0 2 R32ui";
162 src << "2D 0 0 0 2 R32ui";
164 case IMAGE_TYPE_2D_ARRAY :
165 src << "2D 0 1 0 2 R32ui";
168 src << "3D 0 0 0 2 R32ui";
170 case IMAGE_TYPE_CUBE :
171 src << "Cube 0 0 0 2 R32ui";
173 case IMAGE_TYPE_CUBE_ARRAY :
174 src << "Cube 0 1 0 2 R32ui";
184 tcu::TestStatus SparseShaderIntrinsicsInstanceBase::iterate (void)
186 const InstanceInterface& instance = m_context.getInstanceInterface();
187 const DeviceInterface& deviceInterface = m_context.getDeviceInterface();
188 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
189 VkImageCreateInfo imageSparseInfo;
190 VkImageCreateInfo imageTexelsInfo;
191 VkImageCreateInfo imageResidencyInfo;
192 VkSparseImageMemoryRequirements aspectRequirements;
193 std::vector <deUint32> residencyReferenceData;
194 std::vector<DeviceMemorySp> deviceMemUniquePtrVec;
196 // Check if image size does not exceed device limits
197 if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
198 TCU_THROW(NotSupportedError, "Image size not supported for device");
200 // Check if device supports sparse operations for image type
201 if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
202 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
204 if (!getPhysicalDeviceFeatures(instance, physicalDevice).shaderResourceResidency)
205 TCU_THROW(NotSupportedError, "Sparse resource residency information not supported in shader code.");
207 imageSparseInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
208 imageSparseInfo.pNext = DE_NULL;
209 imageSparseInfo.flags = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
210 imageSparseInfo.imageType = mapImageType(m_imageType);
211 imageSparseInfo.format = mapTextureFormat(m_format);
212 imageSparseInfo.extent = makeExtent3D(getLayerSize(m_imageType, m_imageSize));
213 imageSparseInfo.arrayLayers = getNumLayers(m_imageType, m_imageSize);
214 imageSparseInfo.samples = VK_SAMPLE_COUNT_1_BIT;
215 imageSparseInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
216 imageSparseInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
217 imageSparseInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | imageSparseUsageFlags();
218 imageSparseInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
219 imageSparseInfo.queueFamilyIndexCount = 0u;
220 imageSparseInfo.pQueueFamilyIndices = DE_NULL;
222 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
224 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
228 // Assign maximum allowed mipmap levels to image
229 VkImageFormatProperties imageFormatProperties;
230 instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
231 imageSparseInfo.format,
232 imageSparseInfo.imageType,
233 imageSparseInfo.tiling,
234 imageSparseInfo.usage,
235 imageSparseInfo.flags,
236 &imageFormatProperties);
238 imageSparseInfo.mipLevels = getImageMaxMipLevels(imageFormatProperties, imageSparseInfo.extent);
241 // Check if device supports sparse operations for image format
242 if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
243 TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
246 // Create logical device supporting both sparse and compute/graphics queues
247 QueueRequirementsVec queueRequirements;
248 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
249 queueRequirements.push_back(QueueRequirements(getQueueFlags(), 1u));
251 createDeviceSupportingQueues(queueRequirements);
254 // Create queues supporting sparse binding operations and compute/graphics operations
255 const Queue& sparseQueue = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
256 const Queue& extractQueue = getQueue(getQueueFlags(), 0);
258 // Create sparse image
259 const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
261 // Create sparse image memory bind semaphore
262 const Unique<VkSemaphore> memoryBindSemaphore(makeSemaphore(deviceInterface, getDevice()));
264 const deUint32 imageSparseSizeInBytes = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
265 const deUint32 imageSizeInPixels = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels) / tcu::getPixelSize(m_format);
267 residencyReferenceData.assign(imageSizeInPixels, MEMORY_BLOCK_NOT_BOUND_VALUE);
270 // Get sparse image general memory requirements
271 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
273 // Check if required image memory size does not exceed device limits
274 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
275 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
277 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
279 // Get sparse image sparse memory requirements
280 const std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
282 DE_ASSERT(sparseMemoryRequirements.size() != 0);
284 const deUint32 colorAspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_COLOR_BIT);
286 if (colorAspectIndex == NO_MATCH_FOUND)
287 TCU_THROW(NotSupportedError, "Not supported image aspect - the test supports currently only VK_IMAGE_ASPECT_COLOR_BIT");
289 aspectRequirements = sparseMemoryRequirements[colorAspectIndex];
291 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
293 const VkImageAspectFlags aspectMask = aspectRequirements.formatProperties.aspectMask;
294 const VkExtent3D imageGranularity = aspectRequirements.formatProperties.imageGranularity;
295 const deUint32 memoryType = findMatchingMemoryType(instance, physicalDevice, imageMemoryRequirements, MemoryRequirement::Any);
297 if (memoryType == NO_MATCH_FOUND)
298 return tcu::TestStatus::fail("No matching memory type found");
300 deUint32 pixelOffset = 0u;
302 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
303 std::vector<VkSparseMemoryBind> imageMipTailBinds;
305 // Bind memory for each mipmap level
306 for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
308 const deUint32 mipLevelSizeInPixels = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx) / tcu::getPixelSize(m_format);
310 if (mipLevelNdx % MEMORY_BLOCK_TYPE_COUNT == MEMORY_BLOCK_NOT_BOUND)
312 pixelOffset += mipLevelSizeInPixels;
316 for (deUint32 pixelNdx = 0u; pixelNdx < mipLevelSizeInPixels; ++pixelNdx)
318 residencyReferenceData[pixelOffset + pixelNdx] = MEMORY_BLOCK_BOUND_VALUE;
321 pixelOffset += mipLevelSizeInPixels;
323 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
325 const VkExtent3D mipExtent = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
326 const tcu::UVec3 sparseBlocks = alignedDivide(mipExtent, imageGranularity);
327 const deUint32 numSparseBlocks = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
328 const VkImageSubresource subresource = { aspectMask, mipLevelNdx, layerNdx };
330 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(),
331 imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
333 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
335 imageResidencyMemoryBinds.push_back(imageMemoryBind);
339 if (aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
341 if (aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
343 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
344 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
346 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
348 imageMipTailBinds.push_back(imageMipTailMemoryBind);
352 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
354 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
355 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
357 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
359 imageMipTailBinds.push_back(imageMipTailMemoryBind);
363 for (deUint32 pixelNdx = pixelOffset; pixelNdx < residencyReferenceData.size(); ++pixelNdx)
365 residencyReferenceData[pixelNdx] = MEMORY_BLOCK_BOUND_VALUE;
369 VkBindSparseInfo bindSparseInfo =
371 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
372 DE_NULL, //const void* pNext;
373 0u, //deUint32 waitSemaphoreCount;
374 DE_NULL, //const VkSemaphore* pWaitSemaphores;
375 0u, //deUint32 bufferBindCount;
376 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
377 0u, //deUint32 imageOpaqueBindCount;
378 DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
379 0u, //deUint32 imageBindCount;
380 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
381 1u, //deUint32 signalSemaphoreCount;
382 &memoryBindSemaphore.get() //const VkSemaphore* pSignalSemaphores;
385 VkSparseImageMemoryBindInfo imageResidencyBindInfo;
386 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
388 if (imageResidencyMemoryBinds.size() > 0)
390 imageResidencyBindInfo.image = *imageSparse;
391 imageResidencyBindInfo.bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size());
392 imageResidencyBindInfo.pBinds = &imageResidencyMemoryBinds[0];
394 bindSparseInfo.imageBindCount = 1u;
395 bindSparseInfo.pImageBinds = &imageResidencyBindInfo;
398 if (imageMipTailBinds.size() > 0)
400 imageMipTailBindInfo.image = *imageSparse;
401 imageMipTailBindInfo.bindCount = static_cast<deUint32>(imageMipTailBinds.size());
402 imageMipTailBindInfo.pBinds = &imageMipTailBinds[0];
404 bindSparseInfo.imageOpaqueBindCount = 1u;
405 bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo;
408 // Submit sparse bind commands for execution
409 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
412 // Create image to store texels copied from sparse image
413 imageTexelsInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
414 imageTexelsInfo.pNext = DE_NULL;
415 imageTexelsInfo.flags = 0u;
416 imageTexelsInfo.imageType = imageSparseInfo.imageType;
417 imageTexelsInfo.format = imageSparseInfo.format;
418 imageTexelsInfo.extent = imageSparseInfo.extent;
419 imageTexelsInfo.arrayLayers = imageSparseInfo.arrayLayers;
420 imageTexelsInfo.mipLevels = imageSparseInfo.mipLevels;
421 imageTexelsInfo.samples = imageSparseInfo.samples;
422 imageTexelsInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
423 imageTexelsInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
424 imageTexelsInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | imageOutputUsageFlags();
425 imageTexelsInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
426 imageTexelsInfo.queueFamilyIndexCount = 0u;
427 imageTexelsInfo.pQueueFamilyIndices = DE_NULL;
429 if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
431 imageTexelsInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
434 const Unique<VkImage> imageTexels (createImage(deviceInterface, getDevice(), &imageTexelsInfo));
435 const de::UniquePtr<Allocation> imageTexelsAlloc (bindImage(deviceInterface, getDevice(), getAllocator(), *imageTexels, MemoryRequirement::Any));
437 // Create image to store residency info copied from sparse image
438 imageResidencyInfo = imageTexelsInfo;
439 imageResidencyInfo.format = mapTextureFormat(m_residencyFormat);
441 const Unique<VkImage> imageResidency (createImage(deviceInterface, getDevice(), &imageResidencyInfo));
442 const de::UniquePtr<Allocation> imageResidencyAlloc (bindImage(deviceInterface, getDevice(), getAllocator(), *imageResidency, MemoryRequirement::Any));
444 // Create command buffer for compute and transfer oparations
445 const Unique<VkCommandPool> commandPool(makeCommandPool(deviceInterface, getDevice(), extractQueue.queueFamilyIndex));
446 const Unique<VkCommandBuffer> commandBuffer(makeCommandBuffer(deviceInterface, getDevice(), *commandPool));
448 std::vector <VkBufferImageCopy> bufferImageSparseCopy(imageSparseInfo.mipLevels);
451 deUint32 bufferOffset = 0u;
452 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
454 bufferImageSparseCopy[mipLevelNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipLevelNdx), imageSparseInfo.arrayLayers, mipLevelNdx, static_cast<VkDeviceSize>(bufferOffset));
455 bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
459 // Start recording commands
460 beginCommandBuffer(deviceInterface, *commandBuffer);
462 // Create input buffer
463 const VkBufferCreateInfo inputBufferCreateInfo = makeBufferCreateInfo(imageSparseSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
464 const Unique<VkBuffer> inputBuffer (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
465 const de::UniquePtr<Allocation> inputBufferAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
467 // Fill input buffer with reference data
468 std::vector<deUint8> referenceData(imageSparseSizeInBytes);
470 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
472 const deUint32 mipLevelSizeinBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx);
473 const deUint32 bufferOffset = static_cast<deUint32>(bufferImageSparseCopy[mipLevelNdx].bufferOffset);
475 for (deUint32 byteNdx = 0u; byteNdx < mipLevelSizeinBytes; ++byteNdx)
477 referenceData[bufferOffset + byteNdx] = (deUint8)(mipLevelNdx + byteNdx);
481 deMemcpy(inputBufferAlloc->getHostPtr(), &referenceData[0], imageSparseSizeInBytes);
482 flushMappedMemoryRange(deviceInterface, getDevice(), inputBufferAlloc->getMemory(), inputBufferAlloc->getOffset(), imageSparseSizeInBytes);
485 // Prepare input buffer for data transfer operation
486 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
488 VK_ACCESS_HOST_WRITE_BIT,
489 VK_ACCESS_TRANSFER_READ_BIT,
492 imageSparseSizeInBytes
495 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
498 const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
501 // Prepare sparse image for data transfer operation
502 const VkImageMemoryBarrier imageSparseTransferDstBarrier = makeImageMemoryBarrier
505 VK_ACCESS_TRANSFER_WRITE_BIT,
506 VK_IMAGE_LAYOUT_UNDEFINED,
507 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
508 sparseQueue.queueFamilyIndex != extractQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
509 sparseQueue.queueFamilyIndex != extractQueue.queueFamilyIndex ? extractQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
511 fullImageSubresourceRange
514 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
517 // Copy reference data from input buffer to sparse image
518 deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageSparseCopy.size()), &bufferImageSparseCopy[0]);
520 recordCommands(*commandBuffer, imageSparseInfo, *imageSparse, *imageTexels, *imageResidency);
522 const VkBufferCreateInfo bufferTexelsCreateInfo = makeBufferCreateInfo(imageSparseSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
523 const Unique<VkBuffer> bufferTexels (createBuffer(deviceInterface, getDevice(), &bufferTexelsCreateInfo));
524 const de::UniquePtr<Allocation> bufferTexelsAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *bufferTexels, MemoryRequirement::HostVisible));
526 // Copy data from texels image to buffer
527 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageTexels, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *bufferTexels, static_cast<deUint32>(bufferImageSparseCopy.size()), &bufferImageSparseCopy[0]);
529 const deUint32 imageResidencySizeInBytes = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, imageSparseInfo.mipLevels, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
531 const VkBufferCreateInfo bufferResidencyCreateInfo = makeBufferCreateInfo(imageResidencySizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
532 const Unique<VkBuffer> bufferResidency (createBuffer(deviceInterface, getDevice(), &bufferResidencyCreateInfo));
533 const de::UniquePtr<Allocation> bufferResidencyAlloc (bindBuffer(deviceInterface, getDevice(), getAllocator(), *bufferResidency, MemoryRequirement::HostVisible));
535 // Copy data from residency image to buffer
536 std::vector <VkBufferImageCopy> bufferImageResidencyCopy(imageSparseInfo.mipLevels);
539 deUint32 bufferOffset = 0u;
540 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
542 bufferImageResidencyCopy[mipLevelNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipLevelNdx), imageSparseInfo.arrayLayers, mipLevelNdx, static_cast<VkDeviceSize>(bufferOffset));
543 bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, mipLevelNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
547 deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageResidency, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *bufferResidency, static_cast<deUint32>(bufferImageResidencyCopy.size()), &bufferImageResidencyCopy[0]);
550 VkBufferMemoryBarrier bufferOutputHostReadBarriers[2];
552 bufferOutputHostReadBarriers[0] = makeBufferMemoryBarrier
554 VK_ACCESS_TRANSFER_WRITE_BIT,
555 VK_ACCESS_HOST_READ_BIT,
558 imageSparseSizeInBytes
561 bufferOutputHostReadBarriers[1] = makeBufferMemoryBarrier
563 VK_ACCESS_TRANSFER_WRITE_BIT,
564 VK_ACCESS_HOST_READ_BIT,
567 imageResidencySizeInBytes
570 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 2u, bufferOutputHostReadBarriers, 0u, DE_NULL);
573 // End recording commands
574 endCommandBuffer(deviceInterface, *commandBuffer);
576 const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
578 // Submit commands for execution and wait for completion
579 submitCommandsAndWait(deviceInterface, getDevice(), extractQueue.queueHandle, *commandBuffer, 1u, &memoryBindSemaphore.get(), stageBits);
581 // Wait for sparse queue to become idle
582 deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
584 // Retrieve data from residency buffer to host memory
585 invalidateMappedMemoryRange(deviceInterface, getDevice(), bufferResidencyAlloc->getMemory(), bufferResidencyAlloc->getOffset(), imageResidencySizeInBytes);
587 const deUint32* bufferResidencyData = static_cast<const deUint32*>(bufferResidencyAlloc->getHostPtr());
589 deUint32 pixelOffsetNotAligned = 0u;
590 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
592 const deUint32 mipLevelSizeInBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, mipmapNdx);
593 const deUint32 pixelOffsetAligned = static_cast<deUint32>(bufferImageResidencyCopy[mipmapNdx].bufferOffset) / tcu::getPixelSize(m_residencyFormat);
595 if (deMemCmp(&bufferResidencyData[pixelOffsetAligned], &residencyReferenceData[pixelOffsetNotAligned], mipLevelSizeInBytes) != 0)
596 return tcu::TestStatus::fail("Failed");
598 pixelOffsetNotAligned += mipLevelSizeInBytes / tcu::getPixelSize(m_residencyFormat);
601 // Retrieve data from texels buffer to host memory
602 invalidateMappedMemoryRange(deviceInterface, getDevice(), bufferTexelsAlloc->getMemory(), bufferTexelsAlloc->getOffset(), imageSparseSizeInBytes);
604 const deUint8* bufferTexelsData = static_cast<const deUint8*>(bufferTexelsAlloc->getHostPtr());
606 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
608 const deUint32 mipLevelSizeInBytes = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx);
609 const deUint32 bufferOffset = static_cast<deUint32>(bufferImageSparseCopy[mipmapNdx].bufferOffset);
611 if (mipmapNdx < aspectRequirements.imageMipTailFirstLod)
613 if (mipmapNdx % MEMORY_BLOCK_TYPE_COUNT == MEMORY_BLOCK_BOUND)
615 if (deMemCmp(&bufferTexelsData[bufferOffset], &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
616 return tcu::TestStatus::fail("Failed");
618 else if (getPhysicalDeviceProperties(instance, physicalDevice).sparseProperties.residencyNonResidentStrict)
620 std::vector<deUint8> zeroData;
621 zeroData.assign(mipLevelSizeInBytes, 0u);
623 if (deMemCmp(&bufferTexelsData[bufferOffset], &zeroData[0], mipLevelSizeInBytes) != 0)
624 return tcu::TestStatus::fail("Failed");
629 if (deMemCmp(&bufferTexelsData[bufferOffset], &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
630 return tcu::TestStatus::fail("Failed");
634 return tcu::TestStatus::pass("Passed");