1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2020 The Khronos Group Inc.
6 * Copyright (c) 2016 The Android Open Source Project
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 * \brief Testing writing and reading for mismatched formats
23 *//*--------------------------------------------------------------------*/
25 #include "vktImageLoadStoreTests.hpp"
26 #include "vktTestCaseUtil.hpp"
27 #include "vktImageTestsUtil.hpp"
28 #include "vktImageLoadStoreUtil.hpp"
29 #include "vktImageTexture.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"
46 #include "deUniquePtr.hpp"
47 #include "deSharedPtr.hpp"
48 #include "deStringUtil.hpp"
50 #include "tcuImageCompare.hpp"
51 #include "tcuTexture.hpp"
52 #include "tcuTextureUtil.hpp"
53 #include "tcuFloat.hpp"
54 #include "tcuStringTemplate.hpp"
71 const char* GLSLFormat;
74 tcu::TextureChannelClass ChannelClass;
77 FormatInfo getFormatInfo (VkFormat format)
81 const tcu::TextureFormat texFormat = mapVkFormat(format);
83 result.VectorWidth = getNumUsedChannels(texFormat.order);
84 result.BytesPerPixel = getPixelSize(texFormat);
85 result.ChannelClass = tcu::getTextureChannelClass(texFormat.type);
90 std::string ChannelClassToImageType (tcu::TextureChannelClass channelClass)
94 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uimage2D";
95 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "iimage2D";
96 default: return "image2D";
100 std::string ChannelClassToVecType (tcu::TextureChannelClass channelClass)
102 switch (channelClass)
104 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4";
105 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4";
106 default: return "vec4";
110 std::string ChannelClassToDefaultVecValue (tcu::TextureChannelClass channelClass)
112 switch (channelClass)
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)";
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 } }
162 FormatInfo getFormatInfo (const std::string& spirvFormat)
164 auto it = SpirvFormats.find(spirvFormat);
165 if (it != SpirvFormats.end()) return it->second;
166 else return {"", 0, 0, tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT};
169 bool matching (VkFormat format, const std::string& spirvFormat)
173 FormatInfo baseFormat = getFormatInfo(format);
174 FormatInfo shaderFormat = getFormatInfo(spirvFormat);
176 return (baseFormat.VectorWidth == shaderFormat.VectorWidth &&
177 baseFormat.BytesPerPixel == shaderFormat.BytesPerPixel &&
178 baseFormat.ChannelClass == shaderFormat.ChannelClass);
180 catch (const tcu::InternalError&)
193 void fillImageCreateInfo (VkImageCreateInfo& imageCreateInfo, TestType testType, VkFormat format)
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 =
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;
215 imageCreateInfo = createInfo;
218 class MismatchedFormatTest : public TestCase
221 MismatchedFormatTest (tcu::TestContext& testCtx,
222 const std::string& name,
223 const std::string& description,
225 const VkFormat format,
226 const std::string& spirvFormat);
228 virtual void checkSupport (Context& context) const;
229 void initPrograms (SourceCollections& programCollection) const;
230 TestInstance* createInstance (Context& context) const;
233 const TestType m_type;
234 const VkFormat m_format;
235 const std::string m_spirvFormat;
238 MismatchedFormatTest::MismatchedFormatTest (tcu::TestContext& testCtx,
239 const std::string& name,
240 const std::string& description,
242 const VkFormat format,
243 const std::string& spirvFormat)
244 : TestCase (testCtx, name, description)
247 , m_spirvFormat (spirvFormat)
251 void MismatchedFormatTest::checkSupport (Context& context) const
253 const auto& vki = context.getInstanceInterface();
254 const auto physicalDevice = context.getPhysicalDevice();
256 #ifndef CTS_USES_VULKANSC
257 if (m_type == TestType::SPARSE_READ)
259 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SPARSE_BINDING);
261 if (!getPhysicalDeviceFeatures(vki, physicalDevice).sparseResidencyBuffer)
262 TCU_THROW(NotSupportedError, "Sparse partially resident buffers not supported");
264 // Check sparse operations support before creating the image.
265 VkImageCreateInfo imageCreateInfo;
266 fillImageCreateInfo(imageCreateInfo, m_type, m_format);
268 if (!checkSparseImageFormatSupport(physicalDevice, vki, imageCreateInfo))
270 TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
273 if (!getPhysicalDeviceFeatures(context.getInstanceInterface(), context.getPhysicalDevice()).shaderResourceResidency)
275 TCU_THROW(NotSupportedError, "Shader resource residency not supported");
278 #endif // CTS_USES_VULKANSC
280 VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(vki, physicalDevice, m_format);
282 if ((formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) == 0)
284 TCU_THROW(NotSupportedError, "Creating storage image with this format is not supported");
288 void MismatchedFormatTest::initPrograms (SourceCollections& programCollection) const
292 if (m_type == TestType::READ)
297 layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
301 ${VECT} value = imageLoad(inputImage, ivec2(gl_GlobalInvocationID.xy));
305 else if (m_type == TestType::WRITE)
310 layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
314 imageStore(inputImage, ivec2(gl_GlobalInvocationID.xy), ${VALUE});
318 else if (m_type == TestType::SPARSE_READ)
322 #extension GL_ARB_sparse_texture2 : require
324 layout (${FORMAT}, binding=0) uniform ${IMAGE} inputImage;
329 int r = sparseImageLoadARB(inputImage, ivec2(gl_GlobalInvocationID.xy), result);
334 const FormatInfo spirvFormatInfo = getFormatInfo(m_spirvFormat);
336 const std::string glslFormat = spirvFormatInfo.GLSLFormat ?
337 spirvFormatInfo.GLSLFormat : de::toLower(m_spirvFormat);
339 std::map<std::string, std::string> specializations;
341 specializations["FORMAT"] = glslFormat;
342 specializations["VECT"] = ChannelClassToVecType(spirvFormatInfo.ChannelClass);
343 specializations["IMAGE"] = ChannelClassToImageType(spirvFormatInfo.ChannelClass);
344 specializations["VALUE"] = ChannelClassToDefaultVecValue(spirvFormatInfo.ChannelClass);
346 programCollection.glslSources.add("comp") << glu::ComputeSource( tcu::StringTemplate{source}.specialize(specializations) );
349 class MismatchedFormatTestInstance : public TestInstance
352 MismatchedFormatTestInstance (Context& context,
354 const VkFormat format,
355 const std::string& spirvFormat);
357 tcu::TestStatus iterate (void);
360 const TestType m_type;
361 const VkFormat m_format;
362 const std::string m_spirvFormat;
366 MismatchedFormatTestInstance::MismatchedFormatTestInstance (Context& context, const TestType type, const VkFormat format, const std::string& spirvFormat)
367 : TestInstance (context)
370 , m_spirvFormat (spirvFormat)
374 tcu::TestStatus MismatchedFormatTestInstance::iterate (void)
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
386 Move<VkShaderModule> shaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0);
388 Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
389 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
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);
395 Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
396 Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vk, device, descriptorSetLayout.get());
398 Move<VkPipeline> pipeline = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule);
400 VkImageCreateInfo imageCreateInfo;
401 fillImageCreateInfo(imageCreateInfo, m_type, m_format);
403 vk::Move<vk::VkImage> storageImage = createImage(vk, device, &imageCreateInfo);
404 const auto tcuFormat = mapVkFormat(m_format);
406 de::MovePtr<vk::Allocation> storageAllocation;
407 vk::Move<vk::VkSemaphore> bindSemaphore;
408 std::vector<de::SharedPtr<Allocation> > allocations;
410 if (m_type == TestType::SPARSE_READ)
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
421 storageAllocation = allocator.allocate(getImageMemoryRequirements(vk, device, *storageImage), MemoryRequirement::Any);
422 VK_CHECK(vk.bindImageMemory(device, *storageImage, storageAllocation->getMemory(), storageAllocation->getOffset()));
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);
429 DescriptorSetUpdateBuilder builder;
431 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storageImageInfo)
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);
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);
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);
446 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
448 return tcu::TestStatus::pass("Passed");
451 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
453 return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
458 tcu::TestCaseGroup* createImageMismatchedFormatsTests (tcu::TestContext& testCtx)
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
467 for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8; format < VK_CORE_FORMAT_LAST; format = static_cast<VkFormat>(format+1))
469 for (auto& pair : SpirvFormats)
471 const std::string& spirvFormat = pair.first;
473 if (matching(format, spirvFormat))
475 const std::string enumName = getFormatName(format);
476 const std::string testName = de::toLower( enumName.substr(10) + "_with_" + spirvFormat );
478 testGroupOpRead->addChild(new MismatchedFormatTest( testCtx, testName, "",
480 format, spirvFormat) );
482 testGroupOpWrite->addChild(new MismatchedFormatTest(testCtx, testName, "",
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
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
500 return testGroup.release();