external/vulkancts/modules/vulkan/image/vktImageMismatchedFormatsTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2020 The Khronos Group Inc.
   6  * Copyright (c) 2016 The Android Open Source Project
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Testing writing and reading for mismatched formats
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktImageLoadStoreTests.hpp"
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktImageTestsUtil.hpp"
  28 #include "vktImageLoadStoreUtil.hpp"
  29 #include "vktImageTexture.hpp"
  30
  31 #include "vkDefs.hpp"
  32 #include "vkRef.hpp"
  33 #include "vkRefUtil.hpp"
  34 #include "vkPlatform.hpp"
  35 #include "vkPrograms.hpp"
  36 #include "vkMemUtil.hpp"
  37 #include "vkBarrierUtil.hpp"
  38 #include "vkBuilderUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkImageUtil.hpp"
  41 #include "vkCmdUtil.hpp"
  42 #include "vkObjUtil.hpp"
  43 #include "vkImageWithMemory.hpp"
  44
  45 #include "deMath.h"
  46 #include "deUniquePtr.hpp"
  47 #include "deSharedPtr.hpp"
  48 #include "deStringUtil.hpp"
  49
  50 #include "tcuImageCompare.hpp"
  51 #include "tcuTexture.hpp"
  52 #include "tcuTextureUtil.hpp"
  53 #include "tcuFloat.hpp"
  54 #include "tcuStringTemplate.hpp"
  55
  56 #include <string>
  57 #include <vector>
  58 #include <map>
  59
  60 using namespace vk;
  61
  62 namespace vkt
  63 {
  64 namespace image
  65 {
  66 namespace
  67 {
  68
  69 struct FormatInfo
  70 {
  71         const char* GLSLFormat;
  72         int VectorWidth;
  73         int BytesPerPixel;
  74         tcu::TextureChannelClass ChannelClass;
  75 };
  76
  77 FormatInfo getFormatInfo (VkFormat format)
  78 {
  79         FormatInfo result;
  80
  81         const tcu::TextureFormat texFormat = mapVkFormat(format);
  82
  83         result.VectorWidth = getNumUsedChannels(texFormat.order);
  84         result.BytesPerPixel = getPixelSize(texFormat);
  85         result.ChannelClass = tcu::getTextureChannelClass(texFormat.type);
  86
  87         return result;
  88 }
  89
  90 std::string ChannelClassToImageType (tcu::TextureChannelClass channelClass)
  91 {
  92         switch (channelClass)
  93         {
  94                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uimage2D";
  95                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "iimage2D";
  96                 default: return "image2D";
  97         }
  98 }
  99
 100 std::string ChannelClassToVecType (tcu::TextureChannelClass channelClass)
 101 {
 102         switch (channelClass)
 103         {
 104                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4";
 105                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4";
 106                 default: return "vec4";
 107         }
 108 }
 109
 110 std::string ChannelClassToDefaultVecValue (tcu::TextureChannelClass channelClass)
 111 {
 112         switch (channelClass)
 113         {
 114                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4(1, 10, 100, 1000)";
 115                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4(-1, 2, -1000, 2000)";
 116                 default: return "vec4(0.25, 0.5, 0.0, 1.0)";
 117         }
 118 }
 119
 120 const std::map<std::string, FormatInfo> SpirvFormats {
 121         { "Rgba32f",            { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 122         { "Rg32f",                      { nullptr,                      2, 8,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 123         { "R32f",                       { nullptr,                      1, 4,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 124         { "Rgba16f",            { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 125         { "Rg16f",                      { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 126         { "R16f",                       { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 127         { "Rgba16",                     { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 128         { "Rg16",                       { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 129         { "R16",                        { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 130         { "Rgba16Snorm",        { "rgba16_snorm",       4, 8,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 131         { "Rg16Snorm",          { "rg16_snorm",         2, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 132         { "R16Snorm",           { "r16_snorm",          1, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 133         { "Rgb10A2",            { "rgb10_a2",           4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 134         { "R11fG11fB10f",       { "r11f_g11f_b10f", 3, 4,               tcu::TEXTURECHANNELCLASS_FLOATING_POINT } },
 135         { "Rgba8",                      { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 136         { "Rg8",                        { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 137         { "R8",                         { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT } },
 138         { "Rgba8Snorm",         { "rgba8_snorm",        4, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 139         { "Rg8Snorm",           { "rg8_snorm",          2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 140         { "R8Snorm",            { "r8_snorm",           1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT } },
 141         { "Rgba32i",            { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 142         { "Rg32i",                      { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 143         { "R32i",                       { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 144         { "Rgba16i",            { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 145         { "Rg16i",                      { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 146         { "R16i",                       { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 147         { "Rgba8i",                     { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 148         { "Rg8i",                       { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 149         { "R8i",                        { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER } },
 150         { "Rgba32ui",           { nullptr,                      4, 16,          tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 151         { "Rg32ui",                     { nullptr,                      2, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 152         { "R32ui",                      { nullptr,                      1, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 153         { "Rgba16ui",           { nullptr,                      4, 8,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 154         { "Rg16ui",                     { nullptr,                      2, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 155         { "R16ui",                      { nullptr,                      1, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 156         { "Rgb10a2ui",          { "rgb10_a2ui",         4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 157         { "Rgba8ui",            { nullptr,                      4, 4,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 158         { "Rg8ui",                      { nullptr,                      2, 2,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } },
 159         { "R8ui",                       { nullptr,                      1, 1,           tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER } }
 160 };
 161
 162 FormatInfo getFormatInfo (const std::string& spirvFormat)
 163 {
 164         auto it = SpirvFormats.find(spirvFormat);
 165         if (it != SpirvFormats.end()) return it->second;
 166         else return {"", 0, 0, tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT};
 167 }
 168
 169 bool matching (VkFormat format, const std::string& spirvFormat)
 170 {
 171         try
 172         {
 173                 FormatInfo      baseFormat              =       getFormatInfo(format);
 174                 FormatInfo      shaderFormat    =       getFormatInfo(spirvFormat);
 175
 176                 return (baseFormat.VectorWidth == shaderFormat.VectorWidth &&
 177                                 baseFormat.BytesPerPixel == shaderFormat.BytesPerPixel &&
 178                                 baseFormat.ChannelClass == shaderFormat.ChannelClass);
 179         }
 180         catch (const tcu::InternalError&)
 181         {
 182                 return false;
 183         }
 184 }
 185
 186 enum class TestType
 187 {
 188         READ = 0,
 189         SPARSE_READ,
 190         WRITE
 191 };
 192
 193 void fillImageCreateInfo (VkImageCreateInfo& imageCreateInfo, TestType testType, VkFormat format)
 194 {
 195         const VkImageCreateFlags        imageFlags              = ((testType == TestType::SPARSE_READ) ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0u);
 196         const VkImageCreateInfo         createInfo              =
 197         {
 198                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                                                                            // VkStructureType                      sType;
 199                 nullptr,                                                                                                                                                                                        // const void*                          pNext;
 200                 imageFlags,                                                                                                                                                                                     // VkImageCreateFlags           flags;
 201                 VK_IMAGE_TYPE_2D,                                                                                                                                                                       // VkImageType                          imageType;
 202                 format,                                                                                                                                                                                         // VkFormat                                     format;
 203                 makeExtent3D(8, 8, 1),                                                                                                                                                          // VkExtent3D                           extent;
 204                 1u,                                                                                                                                                                                                     // deUint32                                     mipLevels;
 205                 1u,                                                                                                                                                                                                     // deUint32                                     arrayLayers;
 206                 VK_SAMPLE_COUNT_1_BIT,                                                                                                                                                          // VkSampleCountFlagBits        samples;
 207                 VK_IMAGE_TILING_OPTIMAL,                                                                                                                                                        // VkImageTiling                        tiling;
 208                 VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,         // VkImageUsageFlags            usage;
 209                 VK_SHARING_MODE_EXCLUSIVE,                                                                                                                                                      // VkSharingMode                        sharingMode;
 210                 0u,                                                                                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 211                 nullptr,                                                                                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 212                 VK_IMAGE_LAYOUT_UNDEFINED                                                                                                                                                       // VkImageLayout                        initialLayout;
 213         };
 214
 215         imageCreateInfo = createInfo;
 216 }
 217
 218 class MismatchedFormatTest : public TestCase
 219 {
 220 public:
 221                                                 MismatchedFormatTest (tcu::TestContext&         testCtx,
 222                                                                                           const std::string&    name,
 223                                                                                           const std::string&    description,
 224                                                                                           const TestType                type,
 225                                                                                           const VkFormat                format,
 226                                                                                           const std::string&    spirvFormat);
 227
 228         virtual void            checkSupport            (Context&                       context) const;
 229         void                            initPrograms            (SourceCollections&     programCollection) const;
 230         TestInstance*           createInstance          (Context&                       context) const;
 231
 232 private:
 233         const TestType          m_type;
 234         const VkFormat          m_format;
 235         const std::string       m_spirvFormat;
 236 };
 237
 238 MismatchedFormatTest::MismatchedFormatTest (tcu::TestContext&   testCtx,
 239                                                                                         const std::string&      name,
 240                                                                                         const std::string&      description,
 241                                                                                         const TestType          type,
 242                                                                                         const VkFormat          format,
 243                                                                                         const std::string&      spirvFormat)
 244         : TestCase                                              (testCtx, name, description)
 245         , m_type                                                (type)
 246         , m_format                                              (format)
 247         , m_spirvFormat                                 (spirvFormat)
 248 {
 249 }
 250
 251 void MismatchedFormatTest::checkSupport (Context& context) const
 252 {
 253         const auto&     vki                             = context.getInstanceInterface();
 254         const auto      physicalDevice  = context.getPhysicalDevice();
 255
 256 #ifndef CTS_USES_VULKANSC
 257         if (m_type == TestType::SPARSE_READ)
 258         {
 259                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
 260
 261                 if (!getPhysicalDeviceFeatures(vki, physicalDevice).sparseResidencyBuffer)
 262                         TCU_THROW(NotSupportedError, "Sparse partially resident buffers not supported");
 263
 264                 // Check sparse operations support before creating the image.
 265                 VkImageCreateInfo imageCreateInfo;
 266                 fillImageCreateInfo(imageCreateInfo, m_type, m_format);
 267
 268                 if (!checkSparseImageFormatSupport(physicalDevice, vki, imageCreateInfo))
 269                 {
 270                         TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
 271                 }
 272
 273                 if (!getPhysicalDeviceFeatures(context.getInstanceInterface(), context.getPhysicalDevice()).shaderResourceResidency)
 274                 {
 275                         TCU_THROW(NotSupportedError, "Shader resource residency not supported");
 276                 }
 277         }
 278 #endif // CTS_USES_VULKANSC
 279
 280         VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(vki, physicalDevice, m_format);
 281
 282         if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) == 0)
 283         {
 284                 TCU_THROW(NotSupportedError, "Creating storage image with this format is not supported");
 285         }
 286 }
 287
 288 void MismatchedFormatTest::initPrograms (SourceCollections& programCollection) const
 289 {
 290         std::string     source;
 291
 292         if (m_type == TestType::READ)
 293         {
 294                 source = R"(
 295                         #version 460 core
 296
 297                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 298
 299                         void main()
 300                         {
 301                                 ${VECT} value = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy));
 302                         }
 303                 )";
 304         }
 305         else if (m_type == TestType::WRITE)
 306         {
 307                 source = R"(
 308                         #version 460 core
 309
 310                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 311
 312                         void main()
 313                         {
 314                                 imageStore(inputImage, ivec2(gl_GlobalInvocationID.xy), ${VALUE});
 315                         }
 316                 )";
 317         }
 318         else if (m_type == TestType::SPARSE_READ)
 319         {
 320                 source = R"(
 321                         #version 460 core
 322                         #extension GL_ARB_sparse_texture2 : require
 323
 324                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 325
 326                         void main()
 327                         {
 328                                 ${VECT} result;
 329                                 int r = sparseImageLoadARB(inputImage, ivec2(gl_GlobalInvocationID.xy), result);
 330                         }
 331                 )";
 332         }
 333
 334         const FormatInfo        spirvFormatInfo         =       getFormatInfo(m_spirvFormat);
 335
 336         const std::string       glslFormat                      =       spirvFormatInfo.GLSLFormat ?
 337                                                                                                 spirvFormatInfo.GLSLFormat : de::toLower(m_spirvFormat);
 338
 339         std::map<std::string, std::string>                      specializations;
 340
 341         specializations["FORMAT"]                               =       glslFormat;
 342         specializations["VECT"]                                 =       ChannelClassToVecType(spirvFormatInfo.ChannelClass);
 343         specializations["IMAGE"]                                =       ChannelClassToImageType(spirvFormatInfo.ChannelClass);
 344         specializations["VALUE"]                                =       ChannelClassToDefaultVecValue(spirvFormatInfo.ChannelClass);
 345
 346         programCollection.glslSources.add("comp") << glu::ComputeSource( tcu::StringTemplate{source}.specialize(specializations) );
 347 }
 348
 349 class MismatchedFormatTestInstance : public TestInstance
 350 {
 351 public:
 352                                                 MismatchedFormatTestInstance (Context&                          context,
 353                                                                                                           const TestType                type,
 354                                                                                                           const VkFormat                format,
 355                                                                                                           const std::string&    spirvFormat);
 356
 357         tcu::TestStatus         iterate                                 (void);
 358
 359 protected:
 360         const TestType          m_type;
 361         const VkFormat          m_format;
 362         const std::string       m_spirvFormat;
 363
 364 };
 365
 366 MismatchedFormatTestInstance::MismatchedFormatTestInstance (Context& context, const TestType type, const VkFormat format, const std::string& spirvFormat)
 367         : TestInstance          (context)
 368         , m_type                        (type)
 369         , m_format                      (format)
 370         , m_spirvFormat         (spirvFormat)
 371 {
 372 }
 373
 374 tcu::TestStatus MismatchedFormatTestInstance::iterate (void)
 375 {
 376         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
 377         const VkDevice                                  device                          = m_context.getDevice();
 378         const VkQueue                                   queue                           = m_context.getUniversalQueue();
 379         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 380         auto&                                                   allocator                       = m_context.getDefaultAllocator();
 381 #ifndef CTS_USES_VULKANSC
 382         const auto                                              physicalDevice          = m_context.getPhysicalDevice();
 383         const auto&                                             instance                        = m_context.getInstanceInterface();
 384 #endif // CTS_USES_VULKANSC
 385
 386         Move<VkShaderModule>                    shaderModule            = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0);
 387
 388         Move<VkDescriptorSetLayout>             descriptorSetLayout     = DescriptorSetLayoutBuilder()
 389                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 390                                                                                                                         .build(vk, device);
 391         Move<VkDescriptorPool>                  descriptorPool          = DescriptorPoolBuilder()
 392                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
 393                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
 394
 395         Move<VkDescriptorSet>                   descriptorSet           = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 396         Move<VkPipelineLayout>                  pipelineLayout          = makePipelineLayout(vk, device, descriptorSetLayout.get());
 397
 398         Move<VkPipeline>                                pipeline                        = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule);
 399
 400         VkImageCreateInfo                               imageCreateInfo;
 401         fillImageCreateInfo(imageCreateInfo, m_type, m_format);
 402
 403         vk::Move<vk::VkImage>                   storageImage            = createImage(vk, device, &imageCreateInfo);
 404         const auto                                              tcuFormat                       = mapVkFormat(m_format);
 405
 406         de::MovePtr<vk::Allocation>                                     storageAllocation;
 407         vk::Move<vk::VkSemaphore>                                       bindSemaphore;
 408         std::vector<de::SharedPtr<Allocation> >         allocations;
 409
 410         if (m_type == TestType::SPARSE_READ)
 411         {
 412                 bindSemaphore = createSemaphore(vk, device);
 413 #ifndef CTS_USES_VULKANSC
 414                 allocateAndBindSparseImage(     vk, device, physicalDevice, instance,
 415                                                                         imageCreateInfo, *bindSemaphore, m_context.getSparseQueue(),
 416                                                                         allocator, allocations, tcuFormat, *storageImage        );
 417 #endif // CTS_USES_VULKANSC
 418         }
 419         else
 420         {
 421                 storageAllocation = allocator.allocate(getImageMemoryRequirements(vk, device, *storageImage), MemoryRequirement::Any);
 422                 VK_CHECK(vk.bindImageMemory(device, *storageImage, storageAllocation->getMemory(), storageAllocation->getOffset()));
 423         }
 424
 425         const auto                                              subresourceRange        = makeImageSubresourceRange(getImageAspectFlags(tcuFormat), 0u, 1u, 0u, 1u);
 426         Move<VkImageView>                               storageImageView        = makeImageView(vk, device, *storageImage, VK_IMAGE_VIEW_TYPE_2D, m_format, subresourceRange);
 427         VkDescriptorImageInfo                   storageImageInfo        = makeDescriptorImageInfo(DE_NULL, *storageImageView, VK_IMAGE_LAYOUT_GENERAL);
 428
 429         DescriptorSetUpdateBuilder              builder;
 430         builder
 431                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storageImageInfo)
 432                 .update(vk, device);
 433
 434         Move<VkCommandPool>                             cmdPool                         = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
 435         Move<VkCommandBuffer>                   cmdBuffer                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 436
 437         const auto                                              layoutBarrier           = makeImageMemoryBarrier(0u, (VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, *storageImage, subresourceRange);
 438
 439         beginCommandBuffer(vk, *cmdBuffer);
 440                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u, &layoutBarrier);
 441                 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 442                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 443                 vk.cmdDispatch(*cmdBuffer, 8, 8, 1);
 444         endCommandBuffer(vk, *cmdBuffer);
 445
 446         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 447
 448         return tcu::TestStatus::pass("Passed");
 449 }
 450
 451 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
 452 {
 453         return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
 454 }
 455
 456 } // anonymous ns
 457
 458 tcu::TestCaseGroup* createImageMismatchedFormatsTests (tcu::TestContext& testCtx)
 459 {
 460         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mismatched_formats", "Test image load/store operations on mismatched formats"));
 461         de::MovePtr<tcu::TestCaseGroup> testGroupOpRead(new tcu::TestCaseGroup(testCtx, "image_read", "perform OpImageRead"));
 462         de::MovePtr<tcu::TestCaseGroup> testGroupOpWrite(new tcu::TestCaseGroup(testCtx, "image_write", "perform OpImageWrite"));
 463 #ifndef CTS_USES_VULKANSC
 464         de::MovePtr<tcu::TestCaseGroup> testGroupOpSparseRead(new tcu::TestCaseGroup(testCtx, "sparse_image_read", "perform OpSparseImageRead"));
 465 #endif // CTS_USES_VULKANSC
 466
 467         for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8; format < VK_CORE_FORMAT_LAST; format = static_cast<VkFormat>(format+1))
 468         {
 469                 for (auto& pair : SpirvFormats)
 470                 {
 471                         const std::string&      spirvFormat = pair.first;
 472
 473                         if (matching(format, spirvFormat))
 474                         {
 475                                 const std::string       enumName        = getFormatName(format);
 476                                 const std::string       testName        = de::toLower( enumName.substr(10) + "_with_" + spirvFormat );
 477
 478                                 testGroupOpRead->addChild(new MismatchedFormatTest(     testCtx, testName, "",
 479                                                                                                                                         TestType::READ,
 480                                                                                                                                         format, spirvFormat) );
 481
 482                                 testGroupOpWrite->addChild(new MismatchedFormatTest(testCtx, testName, "",
 483                                                                                                                                         TestType::WRITE,
 484                                                                                                                                         format, spirvFormat) );
 485 #ifndef CTS_USES_VULKANSC
 486                                 testGroupOpSparseRead->addChild(new MismatchedFormatTest(       testCtx, testName, "",
 487                                                                                                                                                         TestType::SPARSE_READ,
 488                                                                                                                                                         format, spirvFormat) );
 489 #endif // CTS_USES_VULKANSC
 490                         }
 491                 }
 492         }
 493
 494         testGroup->addChild(testGroupOpRead.release());
 495         testGroup->addChild(testGroupOpWrite.release());
 496 #ifndef CTS_USES_VULKANSC
 497         testGroup->addChild(testGroupOpSparseRead.release());
 498 #endif // CTS_USES_VULKANSC
 499
 500         return testGroup.release();
 501 }
 502
 503 } // image
 504 } // vkt