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         if (m_type == TestType::SPARSE_READ)
 257         {
 258                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
 259
 260                 if (!getPhysicalDeviceFeatures(vki, physicalDevice).sparseResidencyBuffer)
 261                         TCU_THROW(NotSupportedError, "Sparse partially resident buffers not supported");
 262
 263                 // Check sparse operations support before creating the image.
 264                 VkImageCreateInfo imageCreateInfo;
 265                 fillImageCreateInfo(imageCreateInfo, m_type, m_format);
 266
 267                 if (!checkSparseImageFormatSupport(physicalDevice, vki, imageCreateInfo))
 268                 {
 269                         TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
 270                 }
 271
 272                 if (!getPhysicalDeviceFeatures(context.getInstanceInterface(), context.getPhysicalDevice()).shaderResourceResidency)
 273                 {
 274                         TCU_THROW(NotSupportedError, "Shader resource residency not supported");
 275                 }
 276         }
 277
 278         VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(vki, physicalDevice, m_format);
 279
 280         if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) == 0)
 281         {
 282                 TCU_THROW(NotSupportedError, "Creating storage image with this format is not supported");
 283         }
 284 }
 285
 286 void MismatchedFormatTest::initPrograms (SourceCollections& programCollection) const
 287 {
 288         std::string     source;
 289
 290         if (m_type == TestType::READ)
 291         {
 292                 source = R"(
 293                         #version 460 core
 294
 295                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 296
 297                         void main()
 298                         {
 299                                 ${VECT} value = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy));
 300                         }
 301                 )";
 302         }
 303         else if (m_type == TestType::WRITE)
 304         {
 305                 source = R"(
 306                         #version 460 core
 307
 308                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 309
 310                         void main()
 311                         {
 312                                 imageStore(inputImage, ivec2(gl_GlobalInvocationID.xy), ${VALUE});
 313                         }
 314                 )";
 315         }
 316         else if (m_type == TestType::SPARSE_READ)
 317         {
 318                 source = R"(
 319                         #version 460 core
 320                         #extension GL_ARB_sparse_texture2 : require
 321
 322                         layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
 323
 324                         void main()
 325                         {
 326                                 ${VECT} result;
 327                                 int r = sparseImageLoadARB(inputImage, ivec2(gl_GlobalInvocationID.xy), result);
 328                         }
 329                 )";
 330         }
 331
 332         const FormatInfo        spirvFormatInfo         =       getFormatInfo(m_spirvFormat);
 333
 334         const std::string       glslFormat                      =       spirvFormatInfo.GLSLFormat ?
 335                                                                                                 spirvFormatInfo.GLSLFormat : de::toLower(m_spirvFormat);
 336
 337         std::map<std::string, std::string>                      specializations;
 338
 339         specializations["FORMAT"]                               =       glslFormat;
 340         specializations["VECT"]                                 =       ChannelClassToVecType(spirvFormatInfo.ChannelClass);
 341         specializations["IMAGE"]                                =       ChannelClassToImageType(spirvFormatInfo.ChannelClass);
 342         specializations["VALUE"]                                =       ChannelClassToDefaultVecValue(spirvFormatInfo.ChannelClass);
 343
 344         programCollection.glslSources.add("comp") << glu::ComputeSource( tcu::StringTemplate{source}.specialize(specializations) );
 345 }
 346
 347 class MismatchedFormatTestInstance : public TestInstance
 348 {
 349 public:
 350                                                 MismatchedFormatTestInstance (Context&                          context,
 351                                                                                                           const TestType                type,
 352                                                                                                           const VkFormat                format,
 353                                                                                                           const std::string&    spirvFormat);
 354
 355         tcu::TestStatus         iterate                                 (void);
 356
 357 protected:
 358         const TestType          m_type;
 359         const VkFormat          m_format;
 360         const std::string       m_spirvFormat;
 361
 362 };
 363
 364 MismatchedFormatTestInstance::MismatchedFormatTestInstance (Context& context, const TestType type, const VkFormat format, const std::string& spirvFormat)
 365         : TestInstance          (context)
 366         , m_type                        (type)
 367         , m_format                      (format)
 368         , m_spirvFormat         (spirvFormat)
 369 {
 370 }
 371
 372 tcu::TestStatus MismatchedFormatTestInstance::iterate (void)
 373 {
 374         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
 375         const VkDevice                                  device                          = m_context.getDevice();
 376         const VkQueue                                   queue                           = m_context.getUniversalQueue();
 377         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 378         auto&                                                   allocator                       = m_context.getDefaultAllocator();
 379         const auto                                              physicalDevice          = m_context.getPhysicalDevice();
 380         const auto&                                             instance                        = m_context.getInstanceInterface();
 381
 382         Move<VkShaderModule>                    shaderModule            = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0);
 383
 384         Move<VkDescriptorSetLayout>             descriptorSetLayout     = DescriptorSetLayoutBuilder()
 385                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 386                                                                                                                         .build(vk, device);
 387         Move<VkDescriptorPool>                  descriptorPool          = DescriptorPoolBuilder()
 388                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
 389                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
 390
 391         Move<VkDescriptorSet>                   descriptorSet           = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 392         Move<VkPipelineLayout>                  pipelineLayout          = makePipelineLayout(vk, device, descriptorSetLayout.get());
 393
 394         Move<VkPipeline>                                pipeline                        = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule);
 395
 396         VkImageCreateInfo                               imageCreateInfo;
 397         fillImageCreateInfo(imageCreateInfo, m_type, m_format);
 398
 399         vk::Move<vk::VkImage>                   storageImage            = createImage(vk, device, &imageCreateInfo);
 400         const auto                                              tcuFormat                       = mapVkFormat(m_format);
 401
 402         de::MovePtr<vk::Allocation>                                     storageAllocation;
 403         vk::Move<vk::VkSemaphore>                                       bindSemaphore;
 404         std::vector<de::SharedPtr<Allocation> >         allocations;
 405
 406         if (m_type == TestType::SPARSE_READ)
 407         {
 408                 bindSemaphore = createSemaphore(vk, device);
 409
 410                 allocateAndBindSparseImage(     vk, device, physicalDevice, instance,
 411                                                                         imageCreateInfo, *bindSemaphore, m_context.getSparseQueue(),
 412                                                                         allocator, allocations, tcuFormat, *storageImage        );
 413         }
 414         else
 415         {
 416                 storageAllocation = allocator.allocate(getImageMemoryRequirements(vk, device, *storageImage), MemoryRequirement::Any);
 417                 VK_CHECK(vk.bindImageMemory(device, *storageImage, storageAllocation->getMemory(), storageAllocation->getOffset()));
 418         }
 419
 420         const auto                                              subresourceRange        = makeImageSubresourceRange(getImageAspectFlags(tcuFormat), 0u, 1u, 0u, 1u);
 421         Move<VkImageView>                               storageImageView        = makeImageView(vk, device, *storageImage, VK_IMAGE_VIEW_TYPE_2D, m_format, subresourceRange);
 422         VkDescriptorImageInfo                   storageImageInfo        = makeDescriptorImageInfo(DE_NULL, *storageImageView, VK_IMAGE_LAYOUT_GENERAL);
 423
 424         DescriptorSetUpdateBuilder              builder;
 425         builder
 426                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storageImageInfo)
 427                 .update(vk, device);
 428
 429         Move<VkCommandPool>                             cmdPool                         = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
 430         Move<VkCommandBuffer>                   cmdBuffer                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 431
 432         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);
 433
 434         beginCommandBuffer(vk, *cmdBuffer);
 435                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u, &layoutBarrier);
 436                 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 437                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 438                 vk.cmdDispatch(*cmdBuffer, 8, 8, 1);
 439         endCommandBuffer(vk, *cmdBuffer);
 440
 441         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 442
 443         return tcu::TestStatus::pass("Passed");
 444 }
 445
 446 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
 447 {
 448         return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
 449 }
 450
 451 } // anonymous ns
 452
 453 tcu::TestCaseGroup* createImageMismatchedFormatsTests (tcu::TestContext& testCtx)
 454 {
 455         de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mismatched_formats", "Test image load/store operations on mismatched formats"));
 456         de::MovePtr<tcu::TestCaseGroup> testGroupOpRead(new tcu::TestCaseGroup(testCtx, "image_read", "perform OpImageRead"));
 457         de::MovePtr<tcu::TestCaseGroup> testGroupOpWrite(new tcu::TestCaseGroup(testCtx, "image_write", "perform OpImageWrite"));
 458         de::MovePtr<tcu::TestCaseGroup> testGroupOpSparseRead(new tcu::TestCaseGroup(testCtx, "sparse_image_read", "perform OpSparseImageRead"));
 459
 460         for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8; format < VK_CORE_FORMAT_LAST; format = static_cast<VkFormat>(format+1))
 461         {
 462                 for (auto& pair : SpirvFormats)
 463                 {
 464                         const std::string&      spirvFormat = pair.first;
 465
 466                         if (matching(format, spirvFormat))
 467                         {
 468                                 const std::string       enumName        = getFormatName(format);
 469                                 const std::string       testName        = de::toLower( enumName.substr(10) + "_with_" + spirvFormat );
 470
 471                                 testGroupOpRead->addChild(new MismatchedFormatTest(     testCtx, testName, "",
 472                                                                                                                                         TestType::READ,
 473                                                                                                                                         format, spirvFormat) );
 474
 475                                 testGroupOpWrite->addChild(new MismatchedFormatTest(testCtx, testName, "",
 476                                                                                                                                         TestType::WRITE,
 477                                                                                                                                         format, spirvFormat) );
 478
 479                                 testGroupOpSparseRead->addChild(new MismatchedFormatTest(       testCtx, testName, "",
 480                                                                                                                                                         TestType::SPARSE_READ,
 481                                                                                                                                                         format, spirvFormat) );
 482                         }
 483                 }
 484         }
 485
 486         testGroup->addChild(testGroupOpRead.release());
 487         testGroup->addChild(testGroupOpWrite.release());
 488         testGroup->addChild(testGroupOpSparseRead.release());
 489
 490         return testGroup.release();
 491 }
 492
 493 } // image
 494 } // vkt