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
getFormatInfo(VkFormat format)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
ChannelClassToImageType(tcu::TextureChannelClass channelClass)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
ChannelClassToVecType(tcu::TextureChannelClass channelClass)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
ChannelClassToDefaultVecValue(tcu::TextureChannelClass channelClass)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
getFormatInfo(const std::string & spirvFormat)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
matching(VkFormat format,const std::string & spirvFormat)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
fillImageCreateInfo(VkImageCreateInfo & imageCreateInfo,TestType testType,VkFormat format)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
MismatchedFormatTest(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const TestType type,const VkFormat format,const std::string & spirvFormat)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
checkSupport(Context & context) const251 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
initPrograms(SourceCollections & programCollection) const286 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
MismatchedFormatTestInstance(Context & context,const TestType type,const VkFormat format,const std::string & spirvFormat)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
iterate(void)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
createInstance(Context & context) const446 TestInstance* MismatchedFormatTest::createInstance (Context& context) const
447 {
448 return new MismatchedFormatTestInstance(context, m_type, m_format, m_spirvFormat);
449 }
450
451 } // anonymous ns
452
createImageMismatchedFormatsTests(tcu::TestContext & testCtx)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
495