external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesMipmapSparseResidency.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  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 "vkBuilderUtil.hpp"
  36 #include "vkImageUtil.hpp"
  37 #include "vkQueryUtil.hpp"
  38 #include "vkTypeUtil.hpp"
  39
  40 #include "deUniquePtr.hpp"
  41 #include "deStringUtil.hpp"
  42
  43 #include <string>
  44 #include <vector>
  45
  46 using namespace vk;
  47
  48 namespace vkt
  49 {
  50 namespace sparse
  51 {
  52 namespace
  53 {
  54
  55 tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor)
  56 {
  57         tcu::UVec3 result;
  58
  59         result.x() = extent.width  / divisor.width  + ((extent.width  % divisor.width)  ? 1u : 0u);
  60         result.y() = extent.height / divisor.height + ((extent.height % divisor.height) ? 1u : 0u);
  61         result.z() = extent.depth  / divisor.depth  + ((extent.depth  % divisor.depth)  ? 1u : 0u);
  62
  63         return result;
  64 }
  65
  66 class MipmapSparseResidencyCase : public TestCase
  67 {
  68 public:
  69                                         MipmapSparseResidencyCase       (tcu::TestContext&                      testCtx,
  70                                                                                                  const std::string&                     name,
  71                                                                                                  const std::string&                     description,
  72                                                                                                  const ImageType                        imageType,
  73                                                                                                  const tcu::UVec3&                      imageSize,
  74                                                                                                  const tcu::TextureFormat&      format);
  75
  76         TestInstance*   createInstance                          (Context&                                       context) const;
  77
  78 private:
  79         const ImageType                         m_imageType;
  80         const tcu::UVec3                        m_imageSize;
  81         const tcu::TextureFormat        m_format;
  82 };
  83
  84 MipmapSparseResidencyCase::MipmapSparseResidencyCase (tcu::TestContext&                 testCtx,
  85                                                                                                           const std::string&            name,
  86                                                                                                           const std::string&            description,
  87                                                                                                           const ImageType                       imageType,
  88                                                                                                           const tcu::UVec3&                     imageSize,
  89                                                                                                           const tcu::TextureFormat&     format)
  90         : TestCase                              (testCtx, name, description)
  91         , m_imageType                   (imageType)
  92         , m_imageSize                   (imageSize)
  93         , m_format                              (format)
  94 {
  95 }
  96
  97 class MipmapSparseResidencyInstance : public SparseResourcesBaseInstance
  98 {
  99 public:
 100                                         MipmapSparseResidencyInstance   (Context&                                                                        context,
 101                                                                                                          const ImageType                                                         imageType,
 102                                                                                                          const tcu::UVec3&                                                       imageSize,
 103                                                                                                          const tcu::TextureFormat&                                       format);
 104
 105         tcu::TestStatus iterate                                                 (void);
 106
 107 private:
 108
 109         const ImageType                         m_imageType;
 110         const tcu::UVec3                        m_imageSize;
 111         const tcu::TextureFormat        m_format;
 112 };
 113
 114 MipmapSparseResidencyInstance::MipmapSparseResidencyInstance (Context&                                  context,
 115                                                                                                                           const ImageType                       imageType,
 116                                                                                                                           const tcu::UVec3&                     imageSize,
 117                                                                                                                           const tcu::TextureFormat&     format)
 118         : SparseResourcesBaseInstance   (context)
 119         , m_imageType                                   (imageType)
 120         , m_imageSize                                   (imageSize)
 121         , m_format                                              (format)
 122 {
 123 }
 124
 125 tcu::TestStatus MipmapSparseResidencyInstance::iterate (void)
 126 {
 127         const InstanceInterface&        instance                = m_context.getInstanceInterface();
 128         const VkPhysicalDevice          physicalDevice  = m_context.getPhysicalDevice();
 129         VkImageCreateInfo                       imageSparseInfo;
 130         std::vector<DeviceMemorySp>     deviceMemUniquePtrVec;
 131
 132         // Check if image size does not exceed device limits
 133         if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
 134                 TCU_THROW(NotSupportedError, "Image size not supported for device");
 135
 136         // Check if device supports sparse operations for image type
 137         if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
 138                 TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
 139
 140         imageSparseInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 141         imageSparseInfo.pNext                                   = DE_NULL;
 142         imageSparseInfo.flags                                   = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
 143         imageSparseInfo.imageType                               = mapImageType(m_imageType);
 144         imageSparseInfo.format                                  = mapTextureFormat(m_format);
 145         imageSparseInfo.extent                                  = makeExtent3D(getLayerSize(m_imageType, m_imageSize));
 146         imageSparseInfo.arrayLayers                             = getNumLayers(m_imageType, m_imageSize);
 147         imageSparseInfo.samples                                 = VK_SAMPLE_COUNT_1_BIT;
 148         imageSparseInfo.tiling                                  = VK_IMAGE_TILING_OPTIMAL;
 149         imageSparseInfo.initialLayout                   = VK_IMAGE_LAYOUT_UNDEFINED;
 150         imageSparseInfo.usage                                   = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
 151                                                                                           VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 152         imageSparseInfo.sharingMode                             = VK_SHARING_MODE_EXCLUSIVE;
 153         imageSparseInfo.queueFamilyIndexCount   = 0u;
 154         imageSparseInfo.pQueueFamilyIndices             = DE_NULL;
 155
 156         if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
 157         {
 158                 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 159         }
 160
 161         {
 162                 VkImageFormatProperties imageFormatProperties;
 163                 instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
 164                         imageSparseInfo.format,
 165                         imageSparseInfo.imageType,
 166                         imageSparseInfo.tiling,
 167                         imageSparseInfo.usage,
 168                         imageSparseInfo.flags,
 169                         &imageFormatProperties);
 170
 171                 imageSparseInfo.mipLevels = getImageMaxMipLevels(imageFormatProperties, imageSparseInfo.extent);
 172         }
 173
 174         // Check if device supports sparse operations for image format
 175         if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
 176                 TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
 177
 178         {
 179                 // Create logical device supporting both sparse and compute operations
 180                 QueueRequirementsVec queueRequirements;
 181                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
 182                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
 183
 184                 createDeviceSupportingQueues(queueRequirements);
 185         }
 186
 187         const DeviceInterface&  deviceInterface = getDeviceInterface();
 188         const Queue&                    sparseQueue             = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
 189         const Queue&                    computeQueue    = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
 190
 191         // Create sparse image
 192         const Unique<VkImage> imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
 193
 194         // Create sparse image memory bind semaphore
 195         const Unique<VkSemaphore> imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
 196
 197         {
 198                 // Get sparse image general memory requirements
 199                 const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
 200
 201                 // Check if required image memory size does not exceed device limits
 202                 if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
 203                         TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
 204
 205                 DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
 206
 207                 // Get sparse image sparse memory requirements
 208                 const std::vector<VkSparseImageMemoryRequirements> sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
 209
 210                 DE_ASSERT(sparseMemoryRequirements.size() != 0);
 211
 212                 const deUint32 colorAspectIndex         = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_COLOR_BIT);
 213                 const deUint32 metadataAspectIndex      = getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_METADATA_BIT);
 214
 215                 if (colorAspectIndex == NO_MATCH_FOUND)
 216                         TCU_THROW(NotSupportedError, "Not supported image aspect - the test supports currently only VK_IMAGE_ASPECT_COLOR_BIT");
 217
 218                 const VkSparseImageMemoryRequirements   aspectRequirements      = sparseMemoryRequirements[colorAspectIndex];
 219                 const VkImageAspectFlags                                aspectMask                      = aspectRequirements.formatProperties.aspectMask;
 220                 const VkExtent3D                                                imageGranularity        = aspectRequirements.formatProperties.imageGranularity;
 221
 222                 DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
 223
 224                 std::vector<VkSparseImageMemoryBind>    imageResidencyMemoryBinds;
 225                 std::vector<VkSparseMemoryBind>                 imageMipTailMemoryBinds;
 226
 227                 const deUint32                                                  memoryType = findMatchingMemoryType(instance, physicalDevice, imageMemoryRequirements, MemoryRequirement::Any);
 228
 229                 if (memoryType == NO_MATCH_FOUND)
 230                         return tcu::TestStatus::fail("No matching memory type found");
 231
 232                 // Bind memory for each layer
 233                 for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
 234                 {
 235                         for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
 236                         {
 237                                 const VkExtent3D                        mipExtent                       = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
 238                                 const tcu::UVec3                        sparseBlocks            = alignedDivide(mipExtent, imageGranularity);
 239                                 const deUint32                          numSparseBlocks         = sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
 240                                 const VkImageSubresource        subresource                     = { aspectMask, mipLevelNdx, layerNdx };
 241
 242                                 const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(),
 243                                         imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
 244
 245                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 246
 247                                 imageResidencyMemoryBinds.push_back(imageMemoryBind);
 248                         }
 249
 250                         if (!(aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
 251                         {
 252                                 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
 253                                         aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
 254
 255                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 256
 257                                 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
 258                         }
 259
 260                         // Metadata
 261                         if (metadataAspectIndex != NO_MATCH_FOUND)
 262                         {
 263                                 const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
 264
 265                                 if (!(metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT))
 266                                 {
 267                                         const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
 268                                                 metadataAspectRequirements.imageMipTailSize, memoryType,
 269                                                 metadataAspectRequirements.imageMipTailOffset + layerNdx * metadataAspectRequirements.imageMipTailStride,
 270                                                 VK_SPARSE_MEMORY_BIND_METADATA_BIT);
 271
 272                                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 273
 274                                         imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
 275                                 }
 276                         }
 277                 }
 278
 279                 if ((aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
 280                 {
 281                         const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
 282                                 aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
 283
 284                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 285
 286                         imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
 287                 }
 288
 289                 // Metadata
 290                 if (metadataAspectIndex != NO_MATCH_FOUND)
 291                 {
 292                         const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
 293
 294                         if (metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
 295                         {
 296                                 const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
 297                                         metadataAspectRequirements.imageMipTailSize, memoryType, metadataAspectRequirements.imageMipTailOffset,
 298                                         VK_SPARSE_MEMORY_BIND_METADATA_BIT);
 299
 300                                 deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
 301
 302                                 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
 303                         }
 304                 }
 305
 306                 VkBindSparseInfo bindSparseInfo =
 307                 {
 308                         VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,                     //VkStructureType                                                       sType;
 309                         DE_NULL,                                                                        //const void*                                                           pNext;
 310                         0u,                                                                                     //deUint32                                                                      waitSemaphoreCount;
 311                         DE_NULL,                                                                        //const VkSemaphore*                                            pWaitSemaphores;
 312                         0u,                                                                                     //deUint32                                                                      bufferBindCount;
 313                         DE_NULL,                                                                        //const VkSparseBufferMemoryBindInfo*           pBufferBinds;
 314                         0u,                                                                                     //deUint32                                                                      imageOpaqueBindCount;
 315                         DE_NULL,                                                                        //const VkSparseImageOpaqueMemoryBindInfo*      pImageOpaqueBinds;
 316                         0u,                                                                                     //deUint32                                                                      imageBindCount;
 317                         DE_NULL,                                                                        //const VkSparseImageMemoryBindInfo*            pImageBinds;
 318                         1u,                                                                                     //deUint32                                                                      signalSemaphoreCount;
 319                         &imageMemoryBindSemaphore.get()                         //const VkSemaphore*                                            pSignalSemaphores;
 320                 };
 321
 322                 VkSparseImageMemoryBindInfo                     imageResidencyBindInfo;
 323                 VkSparseImageOpaqueMemoryBindInfo       imageMipTailBindInfo;
 324
 325                 if (imageResidencyMemoryBinds.size() > 0)
 326                 {
 327                         imageResidencyBindInfo.image            = *imageSparse;
 328                         imageResidencyBindInfo.bindCount        = static_cast<deUint32>(imageResidencyMemoryBinds.size());
 329                         imageResidencyBindInfo.pBinds           = &imageResidencyMemoryBinds[0];
 330
 331                         bindSparseInfo.imageBindCount           = 1u;
 332                         bindSparseInfo.pImageBinds                      = &imageResidencyBindInfo;
 333                 }
 334
 335                 if (imageMipTailMemoryBinds.size() > 0)
 336                 {
 337                         imageMipTailBindInfo.image                      = *imageSparse;
 338                         imageMipTailBindInfo.bindCount          = static_cast<deUint32>(imageMipTailMemoryBinds.size());
 339                         imageMipTailBindInfo.pBinds                     = &imageMipTailMemoryBinds[0];
 340
 341                         bindSparseInfo.imageOpaqueBindCount     = 1u;
 342                         bindSparseInfo.pImageOpaqueBinds        = &imageMipTailBindInfo;
 343                 }
 344
 345                 // Submit sparse bind commands for execution
 346                 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
 347         }
 348
 349         // Create command buffer for compute and transfer oparations
 350         const Unique<VkCommandPool>       commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
 351         const Unique<VkCommandBuffer> commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 352
 353         std::vector <VkBufferImageCopy> bufferImageCopy(imageSparseInfo.mipLevels);
 354
 355         {
 356                 deUint32 bufferOffset = 0;
 357                 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; mipmapNdx++)
 358                 {
 359                         bufferImageCopy[mipmapNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipmapNdx), imageSparseInfo.arrayLayers, mipmapNdx, static_cast<VkDeviceSize>(bufferOffset));
 360                         bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
 361                 }
 362         }
 363
 364         // Start recording commands
 365         beginCommandBuffer(deviceInterface, *commandBuffer);
 366
 367         const deUint32                                  imageSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
 368         const VkBufferCreateInfo                inputBufferCreateInfo   = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
 369         const Unique<VkBuffer>                  inputBuffer                             (createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
 370         const de::UniquePtr<Allocation> inputBufferAlloc                (bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
 371
 372         std::vector<deUint8> referenceData(imageSizeInBytes);
 373
 374         const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
 375
 376         for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
 377         {
 378                 referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageMemoryRequirements.alignment) + 1u);
 379         }
 380
 381         deMemcpy(inputBufferAlloc->getHostPtr(), &referenceData[0], imageSizeInBytes);
 382
 383         flushMappedMemoryRange(deviceInterface, getDevice(), inputBufferAlloc->getMemory(), inputBufferAlloc->getOffset(), imageSizeInBytes);
 384
 385         {
 386                 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
 387                 (
 388                         VK_ACCESS_HOST_WRITE_BIT,
 389                         VK_ACCESS_TRANSFER_READ_BIT,
 390                         *inputBuffer,
 391                         0u,
 392                         imageSizeInBytes
 393                 );
 394
 395                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
 396         }
 397
 398         {
 399                 const VkImageMemoryBarrier imageSparseTransferDstBarrier = makeImageMemoryBarrier
 400                 (
 401                         0u,
 402                         VK_ACCESS_TRANSFER_WRITE_BIT,
 403                         VK_IMAGE_LAYOUT_UNDEFINED,
 404                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 405                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
 406                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
 407                         *imageSparse,
 408                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
 409                 );
 410
 411                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
 412         }
 413
 414         deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 415
 416         {
 417                 const VkImageMemoryBarrier imageSparseTransferSrcBarrier = makeImageMemoryBarrier
 418                 (
 419                         VK_ACCESS_TRANSFER_WRITE_BIT,
 420                         VK_ACCESS_TRANSFER_READ_BIT,
 421                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 422                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 423                         *imageSparse,
 424                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
 425                 );
 426
 427                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferSrcBarrier);
 428         }
 429
 430         const VkBufferCreateInfo                outputBufferCreateInfo  = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 431         const Unique<VkBuffer>                  outputBuffer                    (createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
 432         const de::UniquePtr<Allocation> outputBufferAlloc               (bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
 433
 434         deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 435
 436         {
 437                 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
 438                 (
 439                         VK_ACCESS_TRANSFER_WRITE_BIT,
 440                         VK_ACCESS_HOST_READ_BIT,
 441                         *outputBuffer,
 442                         0u,
 443                         imageSizeInBytes
 444                 );
 445
 446                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
 447         }
 448
 449         // End recording commands
 450         endCommandBuffer(deviceInterface, *commandBuffer);
 451
 452         const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
 453
 454         // Submit commands for execution and wait for completion
 455         submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits);
 456
 457         // Retrieve data from buffer to host memory
 458         invalidateMappedMemoryRange(deviceInterface, getDevice(), outputBufferAlloc->getMemory(), outputBufferAlloc->getOffset(), imageSizeInBytes);
 459
 460         const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
 461
 462         // Wait for sparse queue to become idle
 463         deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
 464
 465         for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
 466         {
 467                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx);
 468                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageCopy[mipmapNdx].bufferOffset);
 469
 470                 if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
 471                         return tcu::TestStatus::fail("Failed");
 472         }
 473
 474         return tcu::TestStatus::pass("Passed");
 475 }
 476
 477 TestInstance* MipmapSparseResidencyCase::createInstance (Context& context) const
 478 {
 479         return new MipmapSparseResidencyInstance(context, m_imageType, m_imageSize, m_format);
 480 }
 481
 482 } // anonymous ns
 483
 484 tcu::TestCaseGroup* createMipmapSparseResidencyTests (tcu::TestContext& testCtx)
 485 {
 486         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mipmap_sparse_residency", "Mipmap Sparse Residency"));
 487
 488         static const deUint32 sizeCountPerImageType = 3u;
 489
 490         struct ImageParameters
 491         {
 492                 ImageType       imageType;
 493                 tcu::UVec3      imageSizes[sizeCountPerImageType];
 494         };
 495
 496         static const ImageParameters imageParametersArray[] =
 497         {
 498                 { IMAGE_TYPE_2D,                 { tcu::UVec3(512u, 256u, 1u),  tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u,  137u, 1u) } },
 499                 { IMAGE_TYPE_2D_ARRAY,   { tcu::UVec3(512u, 256u, 6u),  tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u,  137u, 3u) } },
 500                 { IMAGE_TYPE_CUBE,               { tcu::UVec3(256u, 256u, 1u),  tcu::UVec3(128u,  128u, 1u), tcu::UVec3(137u, 137u, 1u) } },
 501                 { IMAGE_TYPE_CUBE_ARRAY, { tcu::UVec3(256u, 256u, 6u),  tcu::UVec3(128u,  128u, 8u), tcu::UVec3(137u, 137u, 3u) } },
 502                 { IMAGE_TYPE_3D,                 { tcu::UVec3(256u, 256u, 16u), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u,  137u, 3u) } }
 503         };
 504
 505         static const tcu::TextureFormat formats[] =
 506         {
 507                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT32),
 508                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT16),
 509                 tcu::TextureFormat(tcu::TextureFormat::R,        tcu::TextureFormat::SIGNED_INT8),
 510                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32),
 511                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16),
 512                 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8)
 513         };
 514
 515         for (deInt32 imageTypeNdx = 0; imageTypeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray); ++imageTypeNdx)
 516         {
 517                 const ImageType                                 imageType = imageParametersArray[imageTypeNdx].imageType;
 518                 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str(), ""));
 519
 520                 for (deInt32 formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
 521                 {
 522                         const tcu::TextureFormat&               format = formats[formatNdx];
 523                         de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, getShaderImageFormatQualifier(format).c_str(), ""));
 524
 525                         for (deInt32 imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray[imageTypeNdx].imageSizes); ++imageSizeNdx)
 526                         {
 527                                 const tcu::UVec3 imageSize = imageParametersArray[imageTypeNdx].imageSizes[imageSizeNdx];
 528
 529                                 std::ostringstream stream;
 530                                 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
 531
 532                                 formatGroup->addChild(new MipmapSparseResidencyCase(testCtx, stream.str(), "", imageType, imageSize, format));
 533                         }
 534                         imageTypeGroup->addChild(formatGroup.release());
 535                 }
 536                 testGroup->addChild(imageTypeGroup.release());
 537         }
 538
 539         return testGroup.release();
 540 }
 541
 542 } // sparse
 543 } // vkt