external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesShaderIntrinsicsBase.cpp

   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  vktSparseResourcesShaderIntrinsicsBase.cpp
  21  * \brief Sparse Resources Shader Intrinsics Base Classes
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktSparseResourcesShaderIntrinsicsBase.hpp"
  25
  26 using namespace vk;
  27
  28 namespace vkt
  29 {
  30 namespace sparse
  31 {
  32
  33 tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor)
  34 {
  35         tcu::UVec3 result;
  36
  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);
  40
  41         return result;
  42 }
  43
  44 std::string getOpTypeImageComponent (const tcu::TextureFormat& format)
  45 {
  46         switch (tcu::getTextureChannelClass(format.type))
  47         {
  48                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
  49                         return "OpTypeInt 32 0";
  50                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
  51                         return "OpTypeInt 32 1";
  52                 default:
  53                         DE_ASSERT(0);
  54                         return "";
  55         }
  56 }
  57
  58 std::string getImageComponentTypeName (const tcu::TextureFormat& format)
  59 {
  60         switch (tcu::getTextureChannelClass(format.type))
  61         {
  62                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
  63                         return "%type_uint";
  64                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
  65                         return "%type_int";
  66                 default:
  67                         DE_ASSERT(0);
  68                         return "";
  69         }
  70 }
  71
  72 std::string getImageComponentVec4TypeName (const tcu::TextureFormat& format)
  73 {
  74         switch (tcu::getTextureChannelClass(format.type))
  75         {
  76                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
  77                         return "%type_uvec4";
  78                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
  79                         return "%type_ivec4";
  80                 default:
  81                         DE_ASSERT(0);
  82                         return "";
  83         }
  84 }
  85
  86 std::string getOpTypeImageSparse (const ImageType                       imageType,
  87                                                                   const tcu::TextureFormat&     format,
  88                                                                   const std::string&            componentType,
  89                                                                   const bool                            requiresSampler)
  90 {
  91         std::ostringstream      src;
  92
  93         src << "OpTypeImage " << componentType << " ";
  94
  95         switch (imageType)
  96         {
  97                 case IMAGE_TYPE_1D :
  98                         src << "1D 0 0 0 ";
  99                 break;
 100                 case IMAGE_TYPE_1D_ARRAY :
 101                         src << "1D 0 1 0 ";
 102                 break;
 103                 case IMAGE_TYPE_2D :
 104                         src << "2D 0 0 0 ";
 105                 break;
 106                 case IMAGE_TYPE_2D_ARRAY :
 107                         src << "2D 0 1 0 ";
 108                 break;
 109                 case IMAGE_TYPE_3D :
 110                         src << "3D 0 0 0 ";
 111                 break;
 112                 case IMAGE_TYPE_CUBE :
 113                         src << "Cube 0 0 0 ";
 114                 break;
 115                 case IMAGE_TYPE_CUBE_ARRAY :
 116                         src << "Cube 0 1 0 ";
 117                 break;
 118                 default :
 119                         DE_ASSERT(0);
 120                 break;
 121         };
 122
 123         if (requiresSampler)
 124                 src << "1 ";
 125         else
 126                 src << "2 ";
 127
 128         switch (format.order)
 129         {
 130                 case tcu::TextureFormat::R:
 131                         src << "R";
 132                 break;
 133                 case tcu::TextureFormat::RG:
 134                         src << "Rg";
 135                         break;
 136                 case tcu::TextureFormat::RGB:
 137                         src << "Rgb";
 138                         break;
 139                 case tcu::TextureFormat::RGBA:
 140                         src << "Rgba";
 141                 break;
 142                 default:
 143                         DE_ASSERT(0);
 144                 break;
 145         }
 146
 147         switch (format.type)
 148         {
 149                 case tcu::TextureFormat::SIGNED_INT8:
 150                         src << "8i";
 151                 break;
 152                 case tcu::TextureFormat::SIGNED_INT16:
 153                         src << "16i";
 154                 break;
 155                 case tcu::TextureFormat::SIGNED_INT32:
 156                         src << "32i";
 157                 break;
 158                 case tcu::TextureFormat::UNSIGNED_INT8:
 159                         src << "8ui";
 160                 break;
 161                 case tcu::TextureFormat::UNSIGNED_INT16:
 162                         src << "16ui";
 163                 break;
 164                 case tcu::TextureFormat::UNSIGNED_INT32:
 165                         src << "32ui";
 166                 break;
 167                 default:
 168                         DE_ASSERT(0);
 169                 break;
 170         };
 171
 172         return src.str();
 173 }
 174
 175 std::string getOpTypeImageResidency (const ImageType imageType)
 176 {
 177         std::ostringstream      src;
 178
 179         src << "OpTypeImage %type_uint ";
 180
 181         switch (imageType)
 182         {
 183                 case IMAGE_TYPE_1D :
 184                         src << "1D 0 0 0 2 R32ui";
 185                 break;
 186                 case IMAGE_TYPE_1D_ARRAY :
 187                         src << "1D 0 1 0 2 R32ui";
 188                 break;
 189                 case IMAGE_TYPE_2D :
 190                         src << "2D 0 0 0 2 R32ui";
 191                 break;
 192                 case IMAGE_TYPE_2D_ARRAY :
 193                         src << "2D 0 1 0 2 R32ui";
 194                 break;
 195                 case IMAGE_TYPE_3D :
 196                         src << "3D 0 0 0 2 R32ui";
 197                 break;
 198                 case IMAGE_TYPE_CUBE :
 199                         src << "Cube 0 0 0 2 R32ui";
 200                 break;
 201                 case IMAGE_TYPE_CUBE_ARRAY :
 202                         src << "Cube 0 1 0 2 R32ui";
 203                 break;
 204                 default :
 205                         DE_ASSERT(0);
 206                 break;
 207         };
 208
 209         return src.str();
 210 }
 211
 212 tcu::TestStatus SparseShaderIntrinsicsInstanceBase::iterate (void)
 213 {
 214         const InstanceInterface&                        instance                                = m_context.getInstanceInterface();
 215         const DeviceInterface&                          deviceInterface                 = m_context.getDeviceInterface();
 216         const VkPhysicalDevice                          physicalDevice                  = m_context.getPhysicalDevice();
 217         VkImageCreateInfo                                       imageSparseInfo;
 218         VkImageCreateInfo                                       imageTexelsInfo;
 219         VkImageCreateInfo                                       imageResidencyInfo;
 220         VkSparseImageMemoryRequirements         aspectRequirements;
 221         std::vector <deUint32>                          residencyReferenceData;
 222         std::vector<DeviceMemoryUniquePtr>      deviceMemUniquePtrVec;
 223
 224         // Check if image size does not exceed device limits
 225         if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
 226                 TCU_THROW(NotSupportedError, "Image size not supported for device");
 227
 228         // Check if device supports sparse operations for image type
 229         if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
 230                 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
 231
 232         if (!getPhysicalDeviceFeatures(instance, physicalDevice).shaderResourceResidency)
 233                 TCU_THROW(NotSupportedError, "Sparse resource residency information not supported in shader code.");
 234
 235         imageSparseInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 236         imageSparseInfo.pNext                                   = DE_NULL;
 237         imageSparseInfo.flags                                   = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
 238         imageSparseInfo.imageType                               = mapImageType(m_imageType);
 239         imageSparseInfo.format                                  = mapTextureFormat(m_format);
 240         imageSparseInfo.extent                                  = makeExtent3D(getLayerSize(m_imageType, m_imageSize));
 241         imageSparseInfo.arrayLayers                             = getNumLayers(m_imageType, m_imageSize);
 242         imageSparseInfo.samples                                 = VK_SAMPLE_COUNT_1_BIT;
 243         imageSparseInfo.tiling                                  = VK_IMAGE_TILING_OPTIMAL;
 244         imageSparseInfo.initialLayout                   = VK_IMAGE_LAYOUT_UNDEFINED;
 245         imageSparseInfo.usage                                   = VK_IMAGE_USAGE_TRANSFER_DST_BIT | imageSparseUsageFlags();
 246         imageSparseInfo.sharingMode                             = VK_SHARING_MODE_EXCLUSIVE;
 247         imageSparseInfo.queueFamilyIndexCount   = 0u;
 248         imageSparseInfo.pQueueFamilyIndices             = DE_NULL;
 249
 250         if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
 251         {
 252                 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 253         }
 254
 255         {
 256                 // Assign maximum allowed mipmap levels to image
 257                 VkImageFormatProperties imageFormatProperties;
 258                 instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
 259                         imageSparseInfo.format,
 260                         imageSparseInfo.imageType,
 261                         imageSparseInfo.tiling,
 262                         imageSparseInfo.usage,
 263                         imageSparseInfo.flags,
 264                         &imageFormatProperties);
 265
 266                 imageSparseInfo.mipLevels = getImageMaxMipLevels(imageFormatProperties, imageSparseInfo.extent);
 267         }
 268
 269         // Check if device supports sparse operations for image format
 270         if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
 271                 TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
 272
 273         {
 274                 // Create logical device supporting both sparse and compute/graphics queues
 275                 QueueRequirementsVec queueRequirements;
 276                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
 277                 queueRequirements.push_back(QueueRequirements(getQueueFlags(), 1u));
 278
 279                 createDeviceSupportingQueues(queueRequirements);
 280         }
 281
 282         // Create queues supporting sparse binding operations and compute/graphics operations
 283         const Queue& sparseQueue        = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
 284         const Queue& extractQueue       = getQueue(getQueueFlags(), 0);
 285
 286         // Create memory allocator for logical device
 287         const de::UniquePtr<Allocator> allocator(new SimpleAllocator(deviceInterface, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instance, physicalDevice)));
 288
 289         // Create sparse image
 290         const Unique<VkImage> imageSparse(createImage(deviceInterface, *m_logicalDevice, &imageSparseInfo));
 291
 292         // Create sparse image memory bind semaphore
 293         const Unique<VkSemaphore> memoryBindSemaphore(makeSemaphore(deviceInterface, *m_logicalDevice));
 294
 295         const deUint32                    imageSparseSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 296         const deUint32                    imageSizeInPixels                             = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels) / tcu::getPixelSize(m_format);
 297
 298         residencyReferenceData.assign(imageSizeInPixels, MEMORY_BLOCK_NOT_BOUND_VALUE);
 299
 300         {
 301                 // Get sparse image general memory requirements
 302                 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, *m_logicalDevice, *imageSparse);
 303
 304                 // Check if required image memory size does not exceed device limits
 305                 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
 306                         TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
 307
 308                 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
 309
 310                 // Get sparse image sparse memory requirements
 311                 const std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, *m_logicalDevice, *imageSparse);
 312
 313                 DE_ASSERT(sparseMemoryRequirements.size() != 0);
 314
 315                 const deUint32 colorAspectIndex = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_COLOR_BIT);
 316
 317                 if (colorAspectIndex == NO_MATCH_FOUND)
 318                         TCU_THROW(NotSupportedError, "Not supported image aspect - the test supports currently only VK_IMAGE_ASPECT_COLOR_BIT");
 319
 320                 aspectRequirements = sparseMemoryRequirements[colorAspectIndex];
 321
 322                 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
 323
 324                 const VkImageAspectFlags aspectMask                     = aspectRequirements.formatProperties.aspectMask;
 325                 const VkExtent3D                 imageGranularity       = aspectRequirements.formatProperties.imageGranularity;
 326                 const deUint32                   memoryType                     = findMatchingMemoryType(instance, physicalDevice, imageMemoryRequirements, MemoryRequirement::Any);
 327
 328                 if (memoryType == NO_MATCH_FOUND)
 329                         return tcu::TestStatus::fail("No matching memory type found");
 330
 331                 deUint32 pixelOffset = 0u;
 332
 333                 std::vector<VkSparseImageMemoryBind>  imageResidencyMemoryBinds;
 334                 std::vector<VkSparseMemoryBind>           imageMipTailBinds;
 335
 336                 // Bind memory for each mipmap level
 337                 for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
 338                 {
 339                         const deUint32 mipLevelSizeInPixels = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx) / tcu::getPixelSize(m_format);
 340
 341                         if (mipLevelNdx % MEMORY_BLOCK_TYPE_COUNT == MEMORY_BLOCK_NOT_BOUND)
 342                         {
 343                                 pixelOffset += mipLevelSizeInPixels;
 344                                 continue;
 345                         }
 346
 347                         for (deUint32 pixelNdx = 0u; pixelNdx < mipLevelSizeInPixels; ++pixelNdx)
 348                         {
 349                                 residencyReferenceData[pixelOffset + pixelNdx] = MEMORY_BLOCK_BOUND_VALUE;
 350                         }
 351
 352                         pixelOffset += mipLevelSizeInPixels;
 353
 354                         for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
 355                         {
 356                                 const VkExtent3D                 mipExtent                      = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
 357                                 const tcu::UVec3                 sparseBlocks           = alignedDivide(mipExtent, imageGranularity);
 358                                 const deUint32                   numSparseBlocks        = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
 359                                 const VkImageSubresource subresource            = { aspectMask, mipLevelNdx, layerNdx };
 360
 361                                 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, *m_logicalDevice,
 362                                         imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
 363
 364                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, *m_logicalDevice, DE_NULL))));
 365
 366                                 imageResidencyMemoryBinds.push_back(imageMemoryBind);
 367                         }
 368                 }
 369
 370                 if (aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
 371                 {
 372                         if (aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
 373                         {
 374                                 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, *m_logicalDevice,
 375                                         aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
 376
 377                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, *m_logicalDevice, DE_NULL))));
 378
 379                                 imageMipTailBinds.push_back(imageMipTailMemoryBind);
 380                         }
 381                         else
 382                         {
 383                                 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
 384                                 {
 385                                         const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, *m_logicalDevice,
 386                                                 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
 387
 388                                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, *m_logicalDevice, DE_NULL))));
 389
 390                                         imageMipTailBinds.push_back(imageMipTailMemoryBind);
 391                                 }
 392                         }
 393
 394                         for (deUint32 pixelNdx = pixelOffset; pixelNdx < residencyReferenceData.size(); ++pixelNdx)
 395                         {
 396                                 residencyReferenceData[pixelNdx] = MEMORY_BLOCK_BOUND_VALUE;
 397                         }
 398                 }
 399
 400                 VkBindSparseInfo bindSparseInfo =
 401                 {
 402                         VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,     //VkStructureType                                                       sType;
 403                         DE_NULL,                                                        //const void*                                                           pNext;
 404                         0u,                                                                     //deUint32                                                                      waitSemaphoreCount;
 405                         DE_NULL,                                                        //const VkSemaphore*                                            pWaitSemaphores;
 406                         0u,                                                                     //deUint32                                                                      bufferBindCount;
 407                         DE_NULL,                                                        //const VkSparseBufferMemoryBindInfo*           pBufferBinds;
 408                         0u,                                                                     //deUint32                                                                      imageOpaqueBindCount;
 409                         DE_NULL,                                                        //const VkSparseImageOpaqueMemoryBindInfo*      pImageOpaqueBinds;
 410                         0u,                                                                     //deUint32                                                                      imageBindCount;
 411                         DE_NULL,                                                        //const VkSparseImageMemoryBindInfo*            pImageBinds;
 412                         1u,                                                                     //deUint32                                                                      signalSemaphoreCount;
 413                         &memoryBindSemaphore.get()                      //const VkSemaphore*                                            pSignalSemaphores;
 414                 };
 415
 416                 VkSparseImageMemoryBindInfo               imageResidencyBindInfo;
 417                 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
 418
 419                 if (imageResidencyMemoryBinds.size() > 0)
 420                 {
 421                         imageResidencyBindInfo.image            = *imageSparse;
 422                         imageResidencyBindInfo.bindCount        = static_cast<deUint32>(imageResidencyMemoryBinds.size());
 423                         imageResidencyBindInfo.pBinds           = &imageResidencyMemoryBinds[0];
 424
 425                         bindSparseInfo.imageBindCount           = 1u;
 426                         bindSparseInfo.pImageBinds                      = &imageResidencyBindInfo;
 427                 }
 428
 429                 if (imageMipTailBinds.size() > 0)
 430                 {
 431                         imageMipTailBindInfo.image                      = *imageSparse;
 432                         imageMipTailBindInfo.bindCount          = static_cast<deUint32>(imageMipTailBinds.size());
 433                         imageMipTailBindInfo.pBinds                     = &imageMipTailBinds[0];
 434
 435                         bindSparseInfo.imageOpaqueBindCount = 1u;
 436                         bindSparseInfo.pImageOpaqueBinds        = &imageMipTailBindInfo;
 437                 }
 438
 439                 // Submit sparse bind commands for execution
 440                 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
 441         }
 442
 443         // Create image to store texels copied from sparse image
 444         imageTexelsInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 445         imageTexelsInfo.pNext                                   = DE_NULL;
 446         imageTexelsInfo.flags                                   = 0u;
 447         imageTexelsInfo.imageType                               = imageSparseInfo.imageType;
 448         imageTexelsInfo.format                                  = imageSparseInfo.format;
 449         imageTexelsInfo.extent                                  = imageSparseInfo.extent;
 450         imageTexelsInfo.arrayLayers                             = imageSparseInfo.arrayLayers;
 451         imageTexelsInfo.mipLevels                               = imageSparseInfo.mipLevels;
 452         imageTexelsInfo.samples                                 = imageSparseInfo.samples;
 453         imageTexelsInfo.tiling                                  = VK_IMAGE_TILING_OPTIMAL;
 454         imageTexelsInfo.initialLayout                   = VK_IMAGE_LAYOUT_UNDEFINED;
 455         imageTexelsInfo.usage                                   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | imageOutputUsageFlags();
 456         imageTexelsInfo.sharingMode                             = VK_SHARING_MODE_EXCLUSIVE;
 457         imageTexelsInfo.queueFamilyIndexCount   = 0u;
 458         imageTexelsInfo.pQueueFamilyIndices             = DE_NULL;
 459
 460         if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
 461         {
 462                 imageTexelsInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 463         }
 464
 465         const de::UniquePtr<Image> imageTexels(new Image(deviceInterface, *m_logicalDevice, *allocator, imageTexelsInfo, MemoryRequirement::Any));
 466
 467         // Create image to store residency info copied from sparse image
 468         imageResidencyInfo                      = imageTexelsInfo;
 469         imageResidencyInfo.format       = mapTextureFormat(m_residencyFormat);
 470
 471         const de::UniquePtr<Image> imageResidency(new Image(deviceInterface, *m_logicalDevice, *allocator, imageResidencyInfo, MemoryRequirement::Any));
 472
 473         // Create command buffer for compute and transfer oparations
 474         const Unique<VkCommandPool>       commandPool(makeCommandPool(deviceInterface, *m_logicalDevice, extractQueue.queueFamilyIndex));
 475         const Unique<VkCommandBuffer> commandBuffer(makeCommandBuffer(deviceInterface, *m_logicalDevice, *commandPool));
 476
 477         std::vector <VkBufferImageCopy> bufferImageSparseCopy(imageSparseInfo.mipLevels);
 478
 479         {
 480                 deUint32 bufferOffset = 0u;
 481                 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
 482                 {
 483                         bufferImageSparseCopy[mipLevelNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipLevelNdx), imageSparseInfo.arrayLayers, mipLevelNdx, static_cast<VkDeviceSize>(bufferOffset));
 484                         bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 485                 }
 486         }
 487
 488         // Start recording commands
 489         beginCommandBuffer(deviceInterface, *commandBuffer);
 490
 491         // Create input buffer
 492         const VkBufferCreateInfo        inputBufferCreateInfo = makeBufferCreateInfo(imageSparseSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
 493         const de::UniquePtr<Buffer>     inputBuffer(new Buffer(deviceInterface, *m_logicalDevice, *allocator, inputBufferCreateInfo, MemoryRequirement::HostVisible));
 494
 495         // Fill input buffer with reference data
 496         std::vector<deUint8> referenceData(imageSparseSizeInBytes);
 497
 498         for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
 499         {
 500                 const deUint32 mipLevelSizeinBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipLevelNdx);
 501                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageSparseCopy[mipLevelNdx].bufferOffset);
 502
 503                 for (deUint32 byteNdx = 0u; byteNdx < mipLevelSizeinBytes; ++byteNdx)
 504                 {
 505                         referenceData[bufferOffset + byteNdx] = (deUint8)(mipLevelNdx + byteNdx);
 506                 }
 507         }
 508
 509         deMemcpy(inputBuffer->getAllocation().getHostPtr(), &referenceData[0], imageSparseSizeInBytes);
 510         flushMappedMemoryRange(deviceInterface, *m_logicalDevice, inputBuffer->getAllocation().getMemory(), inputBuffer->getAllocation().getOffset(), imageSparseSizeInBytes);
 511
 512         {
 513                 // Prepare input buffer for data transfer operation
 514                 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
 515                 (
 516                         VK_ACCESS_HOST_WRITE_BIT,
 517                         VK_ACCESS_TRANSFER_READ_BIT,
 518                         inputBuffer->get(),
 519                         0u,
 520                         imageSparseSizeInBytes
 521                 );
 522
 523                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
 524         }
 525
 526         const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
 527
 528         {
 529                 // Prepare sparse image for data transfer operation
 530                 const VkImageMemoryBarrier imageSparseTransferDstBarrier = makeImageMemoryBarrier
 531                 (
 532                         0u,
 533                         VK_ACCESS_TRANSFER_WRITE_BIT,
 534                         VK_IMAGE_LAYOUT_UNDEFINED,
 535                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 536                         sparseQueue.queueFamilyIndex != extractQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex  : VK_QUEUE_FAMILY_IGNORED,
 537                         sparseQueue.queueFamilyIndex != extractQueue.queueFamilyIndex ? extractQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
 538                         *imageSparse,
 539                         fullImageSubresourceRange
 540                 );
 541
 542                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
 543         }
 544
 545         // Copy reference data from input buffer to sparse image
 546         deviceInterface.cmdCopyBufferToImage(*commandBuffer, inputBuffer->get(), *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageSparseCopy.size()), &bufferImageSparseCopy[0]);
 547
 548         recordCommands(*allocator, *commandBuffer, imageSparseInfo, *imageSparse, imageTexels->get(), imageResidency->get());
 549
 550         const VkBufferCreateInfo        bufferTexelsInfo = makeBufferCreateInfo(imageSparseSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 551         const de::UniquePtr<Buffer>     bufferTexels(new Buffer(deviceInterface, *m_logicalDevice, *allocator, bufferTexelsInfo, MemoryRequirement::HostVisible));
 552
 553         // Copy data from texels image to buffer
 554         deviceInterface.cmdCopyImageToBuffer(*commandBuffer, imageTexels->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, bufferTexels->get(), static_cast<deUint32>(bufferImageSparseCopy.size()), &bufferImageSparseCopy[0]);
 555
 556         const deUint32                          imageResidencySizeInBytes = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, imageSparseInfo.mipLevels, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 557
 558         const VkBufferCreateInfo        bufferResidencyInfo = makeBufferCreateInfo(imageResidencySizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 559         const de::UniquePtr<Buffer>     bufferResidency(new Buffer(deviceInterface, *m_logicalDevice, *allocator, bufferResidencyInfo, MemoryRequirement::HostVisible));
 560
 561         // Copy data from residency image to buffer
 562         std::vector <VkBufferImageCopy> bufferImageResidencyCopy(imageSparseInfo.mipLevels);
 563
 564         {
 565                 deUint32 bufferOffset = 0u;
 566                 for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
 567                 {
 568                         bufferImageResidencyCopy[mipLevelNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipLevelNdx), imageSparseInfo.arrayLayers, mipLevelNdx, static_cast<VkDeviceSize>(bufferOffset));
 569                         bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, mipLevelNdx, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 570                 }
 571         }
 572
 573         deviceInterface.cmdCopyImageToBuffer(*commandBuffer, imageResidency->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, bufferResidency->get(), static_cast<deUint32>(bufferImageResidencyCopy.size()), &bufferImageResidencyCopy[0]);
 574
 575         {
 576                 VkBufferMemoryBarrier bufferOutputHostReadBarriers[2];
 577
 578                 bufferOutputHostReadBarriers[0] = makeBufferMemoryBarrier
 579                 (
 580                         VK_ACCESS_TRANSFER_WRITE_BIT,
 581                         VK_ACCESS_HOST_READ_BIT,
 582                         bufferTexels->get(),
 583                         0u,
 584                         imageSparseSizeInBytes
 585                 );
 586
 587                 bufferOutputHostReadBarriers[1] = makeBufferMemoryBarrier
 588                 (
 589                         VK_ACCESS_TRANSFER_WRITE_BIT,
 590                         VK_ACCESS_HOST_READ_BIT,
 591                         bufferResidency->get(),
 592                         0u,
 593                         imageResidencySizeInBytes
 594                 );
 595
 596                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 2u, bufferOutputHostReadBarriers, 0u, DE_NULL);
 597         }
 598
 599         // End recording commands
 600         endCommandBuffer(deviceInterface, *commandBuffer);
 601
 602         const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
 603
 604         // Submit commands for execution and wait for completion
 605         submitCommandsAndWait(deviceInterface, *m_logicalDevice, extractQueue.queueHandle, *commandBuffer, 1u, &memoryBindSemaphore.get(), stageBits);
 606
 607         // Wait for sparse queue to become idle
 608         deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
 609
 610         // Retrieve data from residency buffer to host memory
 611         const Allocation& bufferResidencyAllocation = bufferResidency->getAllocation();
 612         invalidateMappedMemoryRange(deviceInterface, *m_logicalDevice, bufferResidencyAllocation.getMemory(), bufferResidencyAllocation.getOffset(), imageResidencySizeInBytes);
 613
 614         const deUint32* bufferResidencyData = static_cast<const deUint32*>(bufferResidencyAllocation.getHostPtr());
 615
 616         deUint32 pixelOffsetNotAligned = 0u;
 617         for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
 618         {
 619                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_residencyFormat, mipmapNdx);
 620                 const deUint32 pixelOffsetAligned       = static_cast<deUint32>(bufferImageResidencyCopy[mipmapNdx].bufferOffset) / tcu::getPixelSize(m_residencyFormat);
 621
 622                 if (deMemCmp(&bufferResidencyData[pixelOffsetAligned], &residencyReferenceData[pixelOffsetNotAligned], mipLevelSizeInBytes) != 0)
 623                         return tcu::TestStatus::fail("Failed");
 624
 625                 pixelOffsetNotAligned += mipLevelSizeInBytes / tcu::getPixelSize(m_residencyFormat);
 626         }
 627
 628         // Retrieve data from texels buffer to host memory
 629         const Allocation& bufferTexelsAllocation = bufferTexels->getAllocation();
 630         invalidateMappedMemoryRange(deviceInterface, *m_logicalDevice, bufferTexelsAllocation.getMemory(), bufferTexelsAllocation.getOffset(), imageSparseSizeInBytes);
 631
 632         const deUint8* bufferTexelsData = static_cast<const deUint8*>(bufferTexelsAllocation.getHostPtr());
 633
 634         for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
 635         {
 636                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx);
 637                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageSparseCopy[mipmapNdx].bufferOffset);
 638
 639                 if (mipmapNdx < aspectRequirements.imageMipTailFirstLod)
 640                 {
 641                         if (mipmapNdx % MEMORY_BLOCK_TYPE_COUNT == MEMORY_BLOCK_BOUND)
 642                         {
 643                                 if (deMemCmp(&bufferTexelsData[bufferOffset], &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
 644                                         return tcu::TestStatus::fail("Failed");
 645                         }
 646                         else if (getPhysicalDeviceProperties(instance, physicalDevice).sparseProperties.residencyNonResidentStrict)
 647                         {
 648                                 std::vector<deUint8> zeroData;
 649                                 zeroData.assign(mipLevelSizeInBytes, 0u);
 650
 651                                 if (deMemCmp(&bufferTexelsData[bufferOffset], &zeroData[0], mipLevelSizeInBytes) != 0)
 652                                         return tcu::TestStatus::fail("Failed");
 653                         }
 654                 }
 655                 else
 656                 {
 657                         if (deMemCmp(&bufferTexelsData[bufferOffset], &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
 658                                 return tcu::TestStatus::fail("Failed");
 659                 }
 660         }
 661
 662         return tcu::TestStatus::pass("Passed");
 663 }
 664
 665 } // sparse
 666 } // vkt