external/vulkancts/modules/vulkan/sparse_resources/vktSparseResourcesImageSparseBinding.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  vktSparseResourcesImageSparseBinding.cpp
  21  * \brief Sparse fully resident images with mipmaps tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktSparseResourcesBufferSparseBinding.hpp"
  25 #include "vktSparseResourcesTestsUtil.hpp"
  26 #include "vktSparseResourcesBase.hpp"
  27 #include "vktTestCaseUtil.hpp"
  28
  29 #include "vkDefs.hpp"
  30 #include "vkRef.hpp"
  31 #include "vkRefUtil.hpp"
  32 #include "vkPlatform.hpp"
  33 #include "vkPrograms.hpp"
  34 #include "vkMemUtil.hpp"
  35 #include "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 class ImageSparseBindingCase : public TestCase
  56 {
  57 public:
  58                                         ImageSparseBindingCase  (tcu::TestContext&                      testCtx,
  59                                                                                          const std::string&                     name,
  60                                                                                          const std::string&                     description,
  61                                                                                          const ImageType                        imageType,
  62                                                                                          const tcu::UVec3&                      imageSize,
  63                                                                                          const tcu::TextureFormat&      format);
  64
  65         TestInstance*   createInstance                  (Context&                                       context) const;
  66
  67 private:
  68         const ImageType                         m_imageType;
  69         const tcu::UVec3                        m_imageSize;
  70         const tcu::TextureFormat        m_format;
  71 };
  72
  73 ImageSparseBindingCase::ImageSparseBindingCase (tcu::TestContext&                       testCtx,
  74                                                                                                 const std::string&                      name,
  75                                                                                                 const std::string&                      description,
  76                                                                                                 const ImageType                         imageType,
  77                                                                                                 const tcu::UVec3&                       imageSize,
  78                                                                                                 const tcu::TextureFormat&       format)
  79         : TestCase                              (testCtx, name, description)
  80         , m_imageType                   (imageType)
  81         , m_imageSize                   (imageSize)
  82         , m_format                              (format)
  83 {
  84 }
  85
  86 class ImageSparseBindingInstance : public SparseResourcesBaseInstance
  87 {
  88 public:
  89                                         ImageSparseBindingInstance      (Context&                                       context,
  90                                                                                                  const ImageType                        imageType,
  91                                                                                                  const tcu::UVec3&                      imageSize,
  92                                                                                                  const tcu::TextureFormat&      format);
  93
  94         tcu::TestStatus iterate                                         (void);
  95
  96 private:
  97         const ImageType                         m_imageType;
  98         const tcu::UVec3                        m_imageSize;
  99         const tcu::TextureFormat        m_format;
 100 };
 101
 102 ImageSparseBindingInstance::ImageSparseBindingInstance (Context&                                        context,
 103                                                                                                                 const ImageType                         imageType,
 104                                                                                                                 const tcu::UVec3&                       imageSize,
 105                                                                                                                 const tcu::TextureFormat&       format)
 106         : SparseResourcesBaseInstance   (context)
 107         , m_imageType                                   (imageType)
 108         , m_imageSize                                   (imageSize)
 109         , m_format                                              (format)
 110 {
 111 }
 112
 113 tcu::TestStatus ImageSparseBindingInstance::iterate (void)
 114 {
 115         const InstanceInterface&                        instance                = m_context.getInstanceInterface();
 116         const DeviceInterface&                          deviceInterface = m_context.getDeviceInterface();
 117         const VkPhysicalDevice                          physicalDevice  = m_context.getPhysicalDevice();
 118         VkImageCreateInfo                                       imageSparseInfo;
 119         std::vector<DeviceMemoryUniquePtr>      deviceMemUniquePtrVec;
 120
 121         // Check if image size does not exceed device limits
 122         if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
 123                 TCU_THROW(NotSupportedError, "Image size not supported for device");
 124
 125         // Check if device supports sparse binding
 126         if (!getPhysicalDeviceFeatures(instance, physicalDevice).sparseBinding)
 127                 TCU_THROW(NotSupportedError, "Device does not support sparse binding");
 128
 129         {
 130                 // Create logical device supporting both sparse and compute queues
 131                 QueueRequirementsVec queueRequirements;
 132                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
 133                 queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
 134
 135                 createDeviceSupportingQueues(queueRequirements);
 136         }
 137
 138         const de::UniquePtr<Allocator> allocator(new SimpleAllocator(deviceInterface, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instance, physicalDevice)));
 139
 140         const Queue& sparseQueue        = getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
 141         const Queue& computeQueue       = getQueue(VK_QUEUE_COMPUTE_BIT, 0);
 142
 143         imageSparseInfo.sType                                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;                                  //VkStructureType               sType;
 144         imageSparseInfo.pNext                                   = DE_NULL;                                                                                              //const void*                   pNext;
 145         imageSparseInfo.flags                                   = VK_IMAGE_CREATE_SPARSE_BINDING_BIT;                                   //VkImageCreateFlags    flags;
 146         imageSparseInfo.imageType                               = mapImageType(m_imageType);                                                    //VkImageType                   imageType;
 147         imageSparseInfo.format                                  = mapTextureFormat(m_format);                                                   //VkFormat                              format;
 148         imageSparseInfo.extent                                  = makeExtent3D(getLayerSize(m_imageType, m_imageSize)); //VkExtent3D                    extent;
 149         imageSparseInfo.arrayLayers                             = getNumLayers(m_imageType, m_imageSize);                               //deUint32                              arrayLayers;
 150         imageSparseInfo.samples                                 = VK_SAMPLE_COUNT_1_BIT;                                                                //VkSampleCountFlagBits samples;
 151         imageSparseInfo.tiling                                  = VK_IMAGE_TILING_OPTIMAL;                                                              //VkImageTiling                 tiling;
 152         imageSparseInfo.initialLayout                   = VK_IMAGE_LAYOUT_UNDEFINED;                                                    //VkImageLayout                 initialLayout;
 153         imageSparseInfo.usage                                   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 154                                                                                           VK_IMAGE_USAGE_TRANSFER_DST_BIT;                                              //VkImageUsageFlags             usage;
 155         imageSparseInfo.sharingMode                             = VK_SHARING_MODE_EXCLUSIVE;                                                    //VkSharingMode                 sharingMode;
 156         imageSparseInfo.queueFamilyIndexCount   = 0u;                                                                                                   //deUint32                              queueFamilyIndexCount;
 157         imageSparseInfo.pQueueFamilyIndices             = DE_NULL;                                                                                              //const deUint32*               pQueueFamilyIndices;
 158
 159         if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
 160         {
 161                 imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 162         }
 163
 164         {
 165                 VkImageFormatProperties imageFormatProperties;
 166                 instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
 167                         imageSparseInfo.format,
 168                         imageSparseInfo.imageType,
 169                         imageSparseInfo.tiling,
 170                         imageSparseInfo.usage,
 171                         imageSparseInfo.flags,
 172                         &imageFormatProperties);
 173
 174                 imageSparseInfo.mipLevels = getImageMaxMipLevels(imageFormatProperties, imageSparseInfo.extent);
 175         }
 176
 177         // Create sparse image
 178         const Unique<VkImage> imageSparse(createImage(deviceInterface, *m_logicalDevice, &imageSparseInfo));
 179
 180         // Create sparse image memory bind semaphore
 181         const Unique<VkSemaphore> imageMemoryBindSemaphore(makeSemaphore(deviceInterface, *m_logicalDevice));
 182
 183         // Get sparse image general memory requirements
 184         const VkMemoryRequirements imageSparseMemRequirements = getImageMemoryRequirements(deviceInterface, *m_logicalDevice, *imageSparse);
 185
 186         // Check if required image memory size does not exceed device limits
 187         if (imageSparseMemRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
 188                 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
 189
 190         DE_ASSERT((imageSparseMemRequirements.size % imageSparseMemRequirements.alignment) == 0);
 191
 192         {
 193                 std::vector<VkSparseMemoryBind> sparseMemoryBinds;
 194                 const deUint32                                  numSparseBinds  = static_cast<deUint32>(imageSparseMemRequirements.size / imageSparseMemRequirements.alignment);
 195                 const deUint32                                  memoryType              = findMatchingMemoryType(instance, physicalDevice, imageSparseMemRequirements, MemoryRequirement::Any);
 196
 197                 if (memoryType == NO_MATCH_FOUND)
 198                         return tcu::TestStatus::fail("No matching memory type found");
 199
 200                 for (deUint32 sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
 201                 {
 202                         const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, *m_logicalDevice,
 203                                 imageSparseMemRequirements.alignment, memoryType, imageSparseMemRequirements.alignment * sparseBindNdx);
 204
 205                         deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, *m_logicalDevice, DE_NULL))));
 206
 207                         sparseMemoryBinds.push_back(sparseMemoryBind);
 208                 }
 209
 210                 const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo = makeSparseImageOpaqueMemoryBindInfo(*imageSparse, numSparseBinds, &sparseMemoryBinds[0]);
 211
 212                 const VkBindSparseInfo bindSparseInfo =
 213                 {
 214                         VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,                     //VkStructureType                                                       sType;
 215                         DE_NULL,                                                                        //const void*                                                           pNext;
 216                         0u,                                                                                     //deUint32                                                                      waitSemaphoreCount;
 217                         DE_NULL,                                                                        //const VkSemaphore*                                            pWaitSemaphores;
 218                         0u,                                                                                     //deUint32                                                                      bufferBindCount;
 219                         DE_NULL,                                                                        //const VkSparseBufferMemoryBindInfo*           pBufferBinds;
 220                         1u,                                                                                     //deUint32                                                                      imageOpaqueBindCount;
 221                         &opaqueBindInfo,                                                        //const VkSparseImageOpaqueMemoryBindInfo*      pImageOpaqueBinds;
 222                         0u,                                                                                     //deUint32                                                                      imageBindCount;
 223                         DE_NULL,                                                                        //const VkSparseImageMemoryBindInfo*            pImageBinds;
 224                         1u,                                                                                     //deUint32                                                                      signalSemaphoreCount;
 225                         &imageMemoryBindSemaphore.get()                         //const VkSemaphore*                                            pSignalSemaphores;
 226                 };
 227
 228                 // Submit sparse bind commands for execution
 229                 VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
 230         }
 231
 232         // Create command buffer for compute and transfer oparations
 233         const Unique<VkCommandPool>       commandPool(makeCommandPool(deviceInterface, *m_logicalDevice, computeQueue.queueFamilyIndex));
 234         const Unique<VkCommandBuffer> commandBuffer(makeCommandBuffer(deviceInterface, *m_logicalDevice, *commandPool));
 235
 236         std::vector<VkBufferImageCopy> bufferImageCopy(imageSparseInfo.mipLevels);
 237
 238         {
 239                 deUint32 bufferOffset = 0;
 240                 for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; mipmapNdx++)
 241                 {
 242                         bufferImageCopy[mipmapNdx] = makeBufferImageCopy(mipLevelExtents(imageSparseInfo.extent, mipmapNdx), imageSparseInfo.arrayLayers, mipmapNdx, static_cast<VkDeviceSize>(bufferOffset));
 243                         bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 244                 }
 245         }
 246
 247         // Start recording commands
 248         beginCommandBuffer(deviceInterface, *commandBuffer);
 249
 250         const deUint32                          imageSizeInBytes                = getImageSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, imageSparseInfo.mipLevels, MEM_ALIGN_BUFFERIMAGECOPY_OFFSET);
 251         const VkBufferCreateInfo        inputBufferCreateInfo   = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
 252
 253         const de::UniquePtr<Buffer>     inputBuffer(new Buffer(deviceInterface, *m_logicalDevice, *allocator, inputBufferCreateInfo, MemoryRequirement::HostVisible));
 254
 255         std::vector<deUint8> referenceData(imageSizeInBytes);
 256
 257         for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
 258         {
 259                 referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageSparseMemRequirements.alignment) + 1u);
 260         }
 261
 262         deMemcpy(inputBuffer->getAllocation().getHostPtr(), &referenceData[0], imageSizeInBytes);
 263
 264         flushMappedMemoryRange(deviceInterface, *m_logicalDevice, inputBuffer->getAllocation().getMemory(), inputBuffer->getAllocation().getOffset(), imageSizeInBytes);
 265
 266         {
 267                 const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
 268                 (
 269                         VK_ACCESS_HOST_WRITE_BIT,
 270                         VK_ACCESS_TRANSFER_READ_BIT,
 271                         inputBuffer->get(),
 272                         0u,
 273                         imageSizeInBytes
 274                 );
 275
 276                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
 277         }
 278
 279         {
 280                 const VkImageMemoryBarrier imageSparseTransferDstBarrier = makeImageMemoryBarrier
 281                 (
 282                         0u,
 283                         VK_ACCESS_TRANSFER_WRITE_BIT,
 284                         VK_IMAGE_LAYOUT_UNDEFINED,
 285                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 286                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
 287                         sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
 288                         *imageSparse,
 289                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
 290                 );
 291
 292                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferDstBarrier);
 293         }
 294
 295         deviceInterface.cmdCopyBufferToImage(*commandBuffer, inputBuffer->get(), *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 296
 297         {
 298                 const VkImageMemoryBarrier imageSparseTransferSrcBarrier = makeImageMemoryBarrier
 299                 (
 300                         VK_ACCESS_TRANSFER_WRITE_BIT,
 301                         VK_ACCESS_TRANSFER_READ_BIT,
 302                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 303                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 304                         *imageSparse,
 305                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
 306                 );
 307
 308                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &imageSparseTransferSrcBarrier);
 309         }
 310
 311         const VkBufferCreateInfo        outputBufferCreateInfo = makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 312         const de::UniquePtr<Buffer>     outputBuffer(new Buffer(deviceInterface, *m_logicalDevice, *allocator, outputBufferCreateInfo, MemoryRequirement::HostVisible));
 313
 314         deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, outputBuffer->get(), static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
 315
 316         {
 317                 const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
 318                 (
 319                         VK_ACCESS_TRANSFER_WRITE_BIT,
 320                         VK_ACCESS_HOST_READ_BIT,
 321                         outputBuffer->get(),
 322                         0u,
 323                         imageSizeInBytes
 324                 );
 325
 326                 deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
 327         }
 328
 329         // End recording commands
 330         endCommandBuffer(deviceInterface, *commandBuffer);
 331
 332         const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
 333
 334         // Submit commands for execution and wait for completion
 335         submitCommandsAndWait(deviceInterface, *m_logicalDevice, computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits);
 336
 337         // Retrieve data from buffer to host memory
 338         const Allocation& allocation = outputBuffer->getAllocation();
 339         invalidateMappedMemoryRange(deviceInterface, *m_logicalDevice, allocation.getMemory(), allocation.getOffset(), imageSizeInBytes);
 340
 341         const deUint8* outputData = static_cast<const deUint8*>(allocation.getHostPtr());
 342
 343         // Wait for sparse queue to become idle
 344         deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
 345
 346         for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
 347         {
 348                 const deUint32 mipLevelSizeInBytes      = getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, m_format, mipmapNdx);
 349                 const deUint32 bufferOffset                     = static_cast<deUint32>(bufferImageCopy[mipmapNdx].bufferOffset);
 350
 351                 if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
 352                         return tcu::TestStatus::fail("Failed");
 353         }
 354
 355         return tcu::TestStatus::pass("Passed");
 356 }
 357
 358 TestInstance* ImageSparseBindingCase::createInstance (Context& context) const
 359 {
 360         return new ImageSparseBindingInstance(context, m_imageType, m_imageSize, m_format);
 361 }
 362
 363 } // anonymous ns
 364
 365 tcu::TestCaseGroup* createImageSparseBindingTests(tcu::TestContext& testCtx)
 366 {
 367         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "image_sparse_binding", "Buffer Sparse Binding"));
 368
 369         static const deUint32 sizeCountPerImageType = 3u;
 370
 371         struct ImageParameters
 372         {
 373                 ImageType       imageType;
 374                 tcu::UVec3      imageSizes[sizeCountPerImageType];
 375         };
 376
 377         static const ImageParameters imageParametersArray[] =
 378         {
 379                 { IMAGE_TYPE_1D,                { tcu::UVec3(512u, 1u,   1u ), tcu::UVec3(1024u, 1u,   1u), tcu::UVec3(11u,  1u,   1u) } },
 380                 { IMAGE_TYPE_1D_ARRAY,  { tcu::UVec3(512u, 1u,   64u), tcu::UVec3(1024u, 1u,   8u), tcu::UVec3(11u,  1u,   3u) } },
 381                 { IMAGE_TYPE_2D,                { tcu::UVec3(512u, 256u, 1u ), tcu::UVec3(1024u, 128u, 1u), tcu::UVec3(11u,  137u, 1u) } },
 382                 { IMAGE_TYPE_2D_ARRAY,  { tcu::UVec3(512u, 256u, 6u ), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u,  137u, 3u) } },
 383                 { IMAGE_TYPE_3D,                { tcu::UVec3(512u, 256u, 6u ), tcu::UVec3(1024u, 128u, 8u), tcu::UVec3(11u,  137u, 3u) } },
 384                 { IMAGE_TYPE_CUBE,              { tcu::UVec3(256u, 256u, 1u ), tcu::UVec3(128u,  128u, 1u), tcu::UVec3(137u, 137u, 1u) } },
 385                 { IMAGE_TYPE_CUBE_ARRAY,{ tcu::UVec3(256u, 256u, 6u ), tcu::UVec3(128u,  128u, 8u), tcu::UVec3(137u, 137u, 3u) } }
 386         };
 387
 388         static const tcu::TextureFormat formats[] =
 389         {
 390                 tcu::TextureFormat(tcu::TextureFormat::R,               tcu::TextureFormat::SIGNED_INT32),
 391                 tcu::TextureFormat(tcu::TextureFormat::R,               tcu::TextureFormat::SIGNED_INT16),
 392                 tcu::TextureFormat(tcu::TextureFormat::R,               tcu::TextureFormat::SIGNED_INT8),
 393                 tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNSIGNED_INT32),
 394                 tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNSIGNED_INT16),
 395                 tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNSIGNED_INT8)
 396         };
 397
 398         for (deInt32 imageTypeNdx = 0; imageTypeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray); ++imageTypeNdx)
 399         {
 400                 const ImageType                                 imageType = imageParametersArray[imageTypeNdx].imageType;
 401                 de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str(), ""));
 402
 403                 for (deInt32 formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
 404                 {
 405                         const tcu::TextureFormat&               format = formats[formatNdx];
 406                         de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, getShaderImageFormatQualifier(format).c_str(), ""));
 407
 408                         for (deInt32 imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(imageParametersArray[imageTypeNdx].imageSizes); ++imageSizeNdx)
 409                         {
 410                                 const tcu::UVec3 imageSize = imageParametersArray[imageTypeNdx].imageSizes[imageSizeNdx];
 411
 412                                 std::ostringstream stream;
 413                                 stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
 414
 415                                 formatGroup->addChild(new ImageSparseBindingCase(testCtx, stream.str(), "", imageType, imageSize, format));
 416                         }
 417                         imageTypeGroup->addChild(formatGroup.release());
 418                 }
 419                 testGroup->addChild(imageTypeGroup.release());
 420         }
 421
 422         return testGroup.release();
 423 }
 424
 425 } // sparse
 426 } // vkt