From 7ac9a1f266eb171fa0eb411c300d2122f578a3a6 Mon Sep 17 00:00:00 2001 From: Maciej Jesionowski Date: Thu, 28 Jul 2016 10:57:30 +0200 Subject: [PATCH] Add multisampled storage image load/store test New tests: - dEQP-VK.image.load_store_multisample.2d.* - dEQP-VK.image.load_store_multisample.2d_array.* Fixes #439 Change-Id: I584f3795dc8f50af753d8dea8b8c47906840770a --- android/cts/master/vk-master.txt | 234 +++++++++ .../vulkancts/modules/vulkan/image/CMakeLists.txt | 4 + .../vulkan/image/vktImageLoadStoreTests.cpp | 136 +----- .../modules/vulkan/image/vktImageLoadStoreUtil.cpp | 114 +++++ .../modules/vulkan/image/vktImageLoadStoreUtil.hpp | 73 +++ .../image/vktImageMultisampleLoadStoreTests.cpp | 541 +++++++++++++++++++++ .../image/vktImageMultisampleLoadStoreTests.hpp | 39 ++ .../modules/vulkan/image/vktImageTests.cpp | 2 + .../modules/vulkan/image/vktImageTestsUtil.cpp | 49 +- .../modules/vulkan/image/vktImageTestsUtil.hpp | 4 +- .../modules/vulkan/image/vktImageTexture.cpp | 32 +- .../modules/vulkan/image/vktImageTexture.hpp | 7 +- external/vulkancts/mustpass/1.0.1/vk-default.txt | 234 +++++++++ 13 files changed, 1323 insertions(+), 146 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.cpp create mode 100644 external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.hpp create mode 100644 external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.cpp create mode 100644 external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.hpp diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index ba97c94..fb400e6 100644 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -102700,6 +102700,240 @@ dEQP-VK.image.load_store.buffer.r8g8b8a8_sint dEQP-VK.image.load_store.buffer.r32_sint dEQP-VK.image.load_store.buffer.r8g8b8a8_unorm dEQP-VK.image.load_store.buffer.r8g8b8a8_snorm +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_64 dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_uint dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_sint dEQP-VK.image.format_reinterpret.1d.r16g16b16a16_sfloat_r16g16b16a16_uint diff --git a/external/vulkancts/modules/vulkan/image/CMakeLists.txt b/external/vulkancts/modules/vulkan/image/CMakeLists.txt index e47e1fd..cafca7c 100644 --- a/external/vulkancts/modules/vulkan/image/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/image/CMakeLists.txt @@ -15,6 +15,10 @@ set(DEQP_VK_IMAGE_SRCS vktImageSizeTests.hpp vktImageTexture.cpp vktImageTexture.hpp + vktImageMultisampleLoadStoreTests.cpp + vktImageMultisampleLoadStoreTests.hpp + vktImageLoadStoreUtil.cpp + vktImageLoadStoreUtil.hpp ) set(DEQP_VK_IMAGE_LIBS diff --git a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp index b5c57af..ba27a7c 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp @@ -25,6 +25,7 @@ #include "vktImageLoadStoreTests.hpp" #include "vktTestCaseUtil.hpp" #include "vktImageTestsUtil.hpp" +#include "vktImageLoadStoreUtil.hpp" #include "vktImageTexture.hpp" #include "vkDefs.hpp" @@ -58,93 +59,11 @@ namespace image namespace { -typedef de::SharedPtr > SharedVkDescriptorSet; -typedef de::SharedPtr > SharedVkImageView; - -template -inline de::SharedPtr > makeVkSharedPtr (Move vkMove) -{ - return de::SharedPtr >(new Unique(vkMove)); -} - -inline VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags) -{ - const VkImageCreateInfo imageParams = - { - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags; - mapImageType(texture.type()), // VkImageType imageType; - format, // VkFormat format; - makeExtent3D(texture.layerSize()), // VkExtent3D extent; - 1u, // deUint32 mipLevels; - (deUint32)texture.numLayers(), // deUint32 arrayLayers; - VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; - VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; - usage, // VkImageUsageFlags usage; - VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; - 0u, // deUint32 queueFamilyIndexCount; - DE_NULL, // const deUint32* pQueueFamilyIndices; - VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; - }; - return imageParams; -} - inline VkBufferImageCopy makeBufferImageCopy (const Texture& texture) { return image::makeBufferImageCopy(makeExtent3D(texture.layerSize()), texture.numLayers()); } -ImageType getImageTypeForSingleLayer (const ImageType imageType) -{ - switch (imageType) - { - case IMAGE_TYPE_1D: - case IMAGE_TYPE_1D_ARRAY: - return IMAGE_TYPE_1D; - - case IMAGE_TYPE_2D: - case IMAGE_TYPE_2D_ARRAY: - case IMAGE_TYPE_CUBE: - case IMAGE_TYPE_CUBE_ARRAY: - // A single layer for cube is a 2d face - return IMAGE_TYPE_2D; - - case IMAGE_TYPE_3D: - return IMAGE_TYPE_3D; - - case IMAGE_TYPE_BUFFER: - return IMAGE_TYPE_BUFFER; - - default: - DE_FATAL("Internal test error"); - return IMAGE_TYPE_LAST; - } -} - -float computeStoreColorScale (const VkFormat format, const tcu::IVec3 imageSize) -{ - const int maxImageDimension = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z())); - const float div = static_cast(maxImageDimension - 1); - - if (isUnormFormat(format)) - return 1.0f / div; - else if (isSnormFormat(format)) - return 2.0f / div; - else - return 1.0f; -} - -inline float computeStoreColorBias (const VkFormat format) -{ - return isSnormFormat(format) ? -1.0f : 0.0f; -} - -inline bool isIntegerFormat (const VkFormat format) -{ - return isIntFormat(format) || isUintFormat(format); -} - tcu::ConstPixelBufferAccess getLayerOrSlice (const Texture& texture, const tcu::ConstPixelBufferAccess access, const int layer) { switch (texture.type()) @@ -171,15 +90,6 @@ tcu::ConstPixelBufferAccess getLayerOrSlice (const Texture& texture, const tcu:: } } -std::string getFormatCaseName (const VkFormat format) -{ - const std::string fullName = getFormatName(format); - - DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_")); - - return de::toLower(fullName.substr(10)); -} - //! \return true if all layers match in both pixel buffers bool comparePixelBuffers (tcu::TestLog& log, const Texture& texture, @@ -340,15 +250,6 @@ void flipHorizontally (const tcu::PixelBufferAccess access) } } -#if defined(DE_DEBUG) -inline bool colorScaleAndBiasAreValid (const VkFormat format, const float colorScale, const float colorBias) -{ - // Only normalized (fixed-point) formats may have scale/bias - const bool integerOrFloatFormat = isIntFormat(format) || isUintFormat(format) || isFloatFormat(format); - return !integerOrFloatFormat || (colorScale == 1.0f && colorBias == 0.0f); -} -#endif - inline bool formatsAreCompatible (const VkFormat format0, const VkFormat format1) { return format0 == format1 || mapVkFormat(format0).getPixelSize() == mapVkFormat(format1).getPixelSize(); @@ -405,18 +306,6 @@ void commandCopyImageToBuffer (Context& context, vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL); } -//! Minimum chunk size is determined by the offset alignment requirements. -VkDeviceSize getOptimalUniformBufferChunkSize (Context& context, VkDeviceSize minimumRequiredChunkSizeBytes) -{ - const VkPhysicalDeviceProperties properties = getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice()); - const VkDeviceSize alignment = properties.limits.minUniformBufferOffsetAlignment; - - if (minimumRequiredChunkSizeBytes > alignment) - return alignment + (minimumRequiredChunkSizeBytes / alignment) * alignment; - else - return alignment; -} - class StoreTest : public TestCase { public: @@ -486,7 +375,7 @@ void StoreTest::initPrograms (SourceCollections& programCollection) const src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" << "\n" << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" - << "layout (binding = 0, " << formatQualifierStr << ") writeonly uniform highp " << imageTypeStr << " u_image;\n"; + << "layout (binding = 0, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_image;\n"; if (m_singleLayerBind) src << "layout (binding = 1) readonly uniform Constants {\n" @@ -673,7 +562,7 @@ ImageStoreTestInstance::ImageStoreTestInstance (Context& context, const VkFormat format, const bool singleLayerBind) : StoreTestInstance (context, texture, format, singleLayerBind) - , m_constantsBufferChunkSizeBytes (getOptimalUniformBufferChunkSize(context, sizeof(deUint32))) + , m_constantsBufferChunkSizeBytes (getOptimalUniformBufferChunkSize(context.getInstanceInterface(), context.getPhysicalDevice(), sizeof(deUint32))) , m_allDescriptorSets (texture.numLayers()) , m_allImageViews (texture.numLayers()) { @@ -925,8 +814,8 @@ void LoadStoreTest::initPrograms (SourceCollections& programCollection) const src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" << "\n" << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" - << "layout (binding = 0, " << formatQualifierStr << ") " << maybeRestrictStr << "readonly uniform highp " << imageTypeStr << " u_image0;\n" - << "layout (binding = 1, " << formatQualifierStr << ") " << maybeRestrictStr << "writeonly uniform highp " << imageTypeStr << " u_image1;\n" + << "layout (binding = 0, " << formatQualifierStr << ") " << maybeRestrictStr << "readonly uniform " << imageTypeStr << " u_image0;\n" + << "layout (binding = 1, " << formatQualifierStr << ") " << maybeRestrictStr << "writeonly uniform " << imageTypeStr << " u_image1;\n" << "\n" << "void main (void)\n" << "{\n" @@ -1286,9 +1175,6 @@ TestInstance* LoadStoreTest::createInstance (Context& context) const return new ImageLoadStoreTestInstance(context, m_texture, m_format, m_imageFormat, m_singleLayerBind); } -// TODO Which image/format combinations should be supported? Spec says it should be queried with vkGetPhysicalDeviceImageFormatProperties. -// What about buffer/format? (texel storage buffer) (use vkGetPhysicalDeviceFormatProperties ?) - static const Texture s_textures[] = { Texture(IMAGE_TYPE_1D, tcu::IVec3(64, 1, 1), 1), @@ -1346,10 +1232,10 @@ tcu::TestCaseGroup* createImageStoreTests (tcu::TestContext& testCtx) for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx) { - groupByImageViewType->addChild(new StoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]), "", texture, s_formats[formatNdx])); + groupByImageViewType->addChild(new StoreTest(testCtx, getFormatShortString(s_formats[formatNdx]), "", texture, s_formats[formatNdx])); if (isLayered) - groupByImageViewType->addChild(new StoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]) + "_single_layer", "", + groupByImageViewType->addChild(new StoreTest(testCtx, getFormatShortString(s_formats[formatNdx]) + "_single_layer", "", texture, s_formats[formatNdx], StoreTest::FLAG_SINGLE_LAYER_BIND)); } testGroup->addChild(groupByImageViewType.release()); @@ -1370,11 +1256,11 @@ tcu::TestCaseGroup* createImageLoadStoreTests (tcu::TestContext& testCtx) for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx) { - groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]), "", + groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatShortString(s_formats[formatNdx]), "", texture, s_formats[formatNdx], s_formats[formatNdx])); if (isLayered) - groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]) + "_single_layer", "", + groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatShortString(s_formats[formatNdx]) + "_single_layer", "", texture, s_formats[formatNdx], s_formats[formatNdx], LoadStoreTest::FLAG_SINGLE_LAYER_BIND)); } testGroup->addChild(groupByImageViewType.release()); @@ -1395,9 +1281,7 @@ tcu::TestCaseGroup* createImageFormatReinterpretTests (tcu::TestContext& testCtx for (int imageFormatNdx = 0; imageFormatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++imageFormatNdx) for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx) { - //TODO Are all conversions valid or do we have to limit (or expand) somehow? Is it stated anywhere in the spec? - - const std::string caseName = getFormatCaseName(s_formats[imageFormatNdx]) + "_" + getFormatCaseName(s_formats[formatNdx]); + const std::string caseName = getFormatShortString(s_formats[imageFormatNdx]) + "_" + getFormatShortString(s_formats[formatNdx]); if (imageFormatNdx != formatNdx && formatsAreCompatible(s_formats[imageFormatNdx], s_formats[formatNdx])) groupByImageViewType->addChild(new LoadStoreTest(testCtx, caseName, "", texture, s_formats[formatNdx], s_formats[imageFormatNdx])); } diff --git a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.cpp b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.cpp new file mode 100644 index 0000000..4d5a027 --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.cpp @@ -0,0 +1,114 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2016 The Khronos Group Inc. + * Copyright (c) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Image load/store utilities + *//*--------------------------------------------------------------------*/ + +#include "vktImageLoadStoreUtil.hpp" +#include "vkQueryUtil.hpp" + +using namespace vk; + +namespace vkt +{ +namespace image +{ + +float computeStoreColorScale (const vk::VkFormat format, const tcu::IVec3 imageSize) +{ + const int maxImageDimension = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z())); + const float div = static_cast(maxImageDimension - 1); + + if (isUnormFormat(format)) + return 1.0f / div; + else if (isSnormFormat(format)) + return 2.0f / div; + else + return 1.0f; +} + +ImageType getImageTypeForSingleLayer (const ImageType imageType) +{ + switch (imageType) + { + case IMAGE_TYPE_1D: + case IMAGE_TYPE_1D_ARRAY: + return IMAGE_TYPE_1D; + + case IMAGE_TYPE_2D: + case IMAGE_TYPE_2D_ARRAY: + case IMAGE_TYPE_CUBE: + case IMAGE_TYPE_CUBE_ARRAY: + // A single layer for cube is a 2d face + return IMAGE_TYPE_2D; + + case IMAGE_TYPE_3D: + return IMAGE_TYPE_3D; + + case IMAGE_TYPE_BUFFER: + return IMAGE_TYPE_BUFFER; + + default: + DE_FATAL("Internal test error"); + return IMAGE_TYPE_LAST; + } +} + +VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags) +{ + const VkSampleCountFlagBits samples = static_cast(texture.numSamples()); // integer and bit mask are aligned, so we can cast like this + + const VkImageCreateInfo imageParams = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags; + mapImageType(texture.type()), // VkImageType imageType; + format, // VkFormat format; + makeExtent3D(texture.layerSize()), // VkExtent3D extent; + 1u, // deUint32 mipLevels; + (deUint32)texture.numLayers(), // deUint32 arrayLayers; + samples, // VkSampleCountFlagBits samples; + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; + usage, // VkImageUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 0u, // deUint32 queueFamilyIndexCount; + DE_NULL, // const deUint32* pQueueFamilyIndices; + VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; + }; + return imageParams; +} + + +//! Minimum chunk size is determined by the offset alignment requirements. +VkDeviceSize getOptimalUniformBufferChunkSize (const InstanceInterface& vki, const VkPhysicalDevice physDevice, VkDeviceSize minimumRequiredChunkSizeBytes) +{ + const VkPhysicalDeviceProperties properties = getPhysicalDeviceProperties(vki, physDevice); + const VkDeviceSize alignment = properties.limits.minUniformBufferOffsetAlignment; + + if (minimumRequiredChunkSizeBytes > alignment) + return alignment + (minimumRequiredChunkSizeBytes / alignment) * alignment; + else + return alignment; +} + +} // image +} // vkt diff --git a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.hpp b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.hpp new file mode 100644 index 0000000..a25a00d --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.hpp @@ -0,0 +1,73 @@ +#ifndef _VKTIMAGELOADSTOREUTIL_HPP +#define _VKTIMAGELOADSTOREUTIL_HPP +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2016 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Image load/store utilities + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "vkDefs.hpp" +#include "vkImageUtil.hpp" +#include "vktImageTestsUtil.hpp" +#include "vktImageTexture.hpp" +#include "tcuVector.hpp" +#include "deSharedPtr.hpp" + +namespace vkt +{ +namespace image +{ + +typedef de::SharedPtr > SharedVkDescriptorSet; +typedef de::SharedPtr > SharedVkImageView; + +template +inline de::SharedPtr > makeVkSharedPtr (vk::Move vkMove) +{ + return de::SharedPtr >(new vk::Unique(vkMove)); +} + +inline float computeStoreColorBias (const vk::VkFormat format) +{ + return isSnormFormat(format) ? -1.0f : 0.0f; +} + +inline bool isIntegerFormat (const vk::VkFormat format) +{ + return isIntFormat(format) || isUintFormat(format); +} + +inline bool colorScaleAndBiasAreValid (const vk::VkFormat format, const float colorScale, const float colorBias) +{ + // Only normalized (fixed-point) formats may have scale/bias + const bool integerOrFloatFormat = isIntFormat(format) || isUintFormat(format) || isFloatFormat(format); + return !integerOrFloatFormat || (colorScale == 1.0f && colorBias == 0.0f); +} + +float computeStoreColorScale (const vk::VkFormat format, const tcu::IVec3 imageSize); +ImageType getImageTypeForSingleLayer (const ImageType imageType); +vk::VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const vk::VkFormat format, const vk::VkImageUsageFlags usage, const vk::VkImageCreateFlags flags); +vk::VkDeviceSize getOptimalUniformBufferChunkSize (const vk::InstanceInterface& vki, const vk::VkPhysicalDevice physDevice, vk::VkDeviceSize minimumRequiredChunkSizeBytes); + +} // image +} // vkt + +#endif // _VKTIMAGELOADSTOREUTIL_HPP diff --git a/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.cpp new file mode 100644 index 0000000..6f8bdac --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.cpp @@ -0,0 +1,541 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2016 The Khronos Group Inc. + * Copyright (c) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Multisampled image load/store Tests + *//*--------------------------------------------------------------------*/ + +#include "vktImageMultisampleLoadStoreTests.hpp" +#include "vktTestCaseUtil.hpp" +#include "vktImageTestsUtil.hpp" +#include "vktImageLoadStoreUtil.hpp" +#include "vktImageTexture.hpp" + +#include "vkDefs.hpp" +#include "vkRef.hpp" +#include "vkRefUtil.hpp" +#include "vkPlatform.hpp" +#include "vkPrograms.hpp" +#include "vkMemUtil.hpp" +#include "vkBuilderUtil.hpp" +#include "vkQueryUtil.hpp" +#include "vkImageUtil.hpp" + +#include "deUniquePtr.hpp" + +#include "tcuTextureUtil.hpp" + +#include +#include + +namespace vkt +{ +namespace image +{ +namespace +{ +using namespace vk; +using de::MovePtr; +using de::UniquePtr; +using tcu::IVec3; + +static const VkFormat CHECKSUM_IMAGE_FORMAT = VK_FORMAT_R32_SINT; + +struct CaseDef +{ + Texture texture; + VkFormat format; + VkSampleCountFlagBits numSamples; + bool singleLayerBind; +}; + +// Multisampled storage image test. +// +// Pass 1: Write a slightly different color pattern per-sample to the whole image. +// Pass 2: Read samples of the same image and check if color values are in the expected range. +// Write back results as a checksum image and verify them on the host. +// Each checksum image pixel should contain an integer equal to the number of samples. + +void initPrograms (SourceCollections& programCollection, const CaseDef caseDef) +{ + const int dimension = (caseDef.singleLayerBind ? caseDef.texture.layerDimension() : caseDef.texture.dimension()); + const std::string texelCoordStr = (dimension == 1 ? "gx" : dimension == 2 ? "ivec2(gx, gy)" : dimension == 3 ? "ivec3(gx, gy, gz)" : ""); + + const ImageType usedImageType = (caseDef.singleLayerBind ? getImageTypeForSingleLayer(caseDef.texture.type()) : caseDef.texture.type()); + const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(caseDef.format)); + const std::string msImageTypeStr = getShaderImageType(mapVkFormat(caseDef.format), usedImageType, (caseDef.texture.numSamples() > 1)); + + const std::string xMax = de::toString(caseDef.texture.size().x() - 1); + const std::string yMax = de::toString(caseDef.texture.size().y() - 1); + const std::string signednessPrefix = isUintFormat(caseDef.format) ? "u" : isIntFormat(caseDef.format) ? "i" : ""; + const std::string gvec4Expr = signednessPrefix + "vec4"; + const int numColorComponents = tcu::getNumUsedChannels(mapVkFormat(caseDef.format).order); + + const float storeColorScale = computeStoreColorScale(caseDef.format, caseDef.texture.size()); + const float storeColorBias = computeStoreColorBias(caseDef.format); + DE_ASSERT(colorScaleAndBiasAreValid(caseDef.format, storeColorScale, storeColorBias)); + + const std::string colorScaleExpr = (storeColorScale == 1.0f ? "" : "*" + de::toString(storeColorScale)) + + (storeColorBias == 0.0f ? "" : " + float(" + de::toString(storeColorBias) + ")"); + const std::string colorExpr = + gvec4Expr + "(" + + "gx^gy^gz^(sampleNdx >> 5)^(sampleNdx & 31), " // we "split" sampleNdx to keep this value in [0, 31] range for numSamples = 64 case + + (numColorComponents > 1 ? "(" + xMax + "-gx)^gy^gz, " : "0, ") + + (numColorComponents > 2 ? "gx^(" + yMax + "-gy)^gz, " : "0, ") + + (numColorComponents > 3 ? "(" + xMax + "-gx)^(" + yMax + "-gy)^gz" : "1") + + ")" + colorScaleExpr; + + // Store shader + { + std::ostringstream src; + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "\n" + << "layout(local_size_x = 1) in;\n" + << "layout(set = 0, binding = 1, " << formatQualifierStr << ") writeonly uniform " << msImageTypeStr << " u_msImage;\n"; + + if (caseDef.singleLayerBind) + src << "layout(set = 0, binding = 0) readonly uniform Constants {\n" + << " int u_layerNdx;\n" + << "};\n"; + + src << "\n" + << "void main (void)\n" + << "{\n" + << " int gx = int(gl_GlobalInvocationID.x);\n" + << " int gy = int(gl_GlobalInvocationID.y);\n" + << " int gz = " << (caseDef.singleLayerBind ? "u_layerNdx" : "int(gl_GlobalInvocationID.z)") << ";\n" + << "\n" + << " for (int sampleNdx = 0; sampleNdx < " << caseDef.texture.numSamples() <<"; ++sampleNdx) {\n" + << " imageStore(u_msImage, " << texelCoordStr << ", sampleNdx, " << colorExpr << ");\n" + << " }\n" + << "}\n"; + + programCollection.glslSources.add("comp_store") << glu::ComputeSource(src.str()); + } + + // Load shader + { + const tcu::TextureFormat checksumFormat = mapVkFormat(CHECKSUM_IMAGE_FORMAT); + const std::string checksumImageTypeStr = getShaderImageType(checksumFormat, usedImageType); + const bool useExactCompare = isIntegerFormat(caseDef.format); + + std::ostringstream src; + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "\n" + << "layout(local_size_x = 1) in;\n" + << "layout(set = 0, binding = 1, " << formatQualifierStr << ") readonly uniform " << msImageTypeStr << " u_msImage;\n" + << "layout(set = 0, binding = 2, " << getShaderImageFormatQualifier(checksumFormat) << ") writeonly uniform " << checksumImageTypeStr << " u_checksumImage;\n"; + + if (caseDef.singleLayerBind) + src << "layout(set = 0, binding = 0) readonly uniform Constants {\n" + << " int u_layerNdx;\n" + << "};\n"; + + src << "\n" + << "void main (void)\n" + << "{\n" + << " int gx = int(gl_GlobalInvocationID.x);\n" + << " int gy = int(gl_GlobalInvocationID.y);\n" + << " int gz = " << (caseDef.singleLayerBind ? "u_layerNdx" : "int(gl_GlobalInvocationID.z)") << ";\n" + << "\n" + << " int checksum = 0;\n" + << " for (int sampleNdx = 0; sampleNdx < " << caseDef.texture.numSamples() <<"; ++sampleNdx) {\n" + << " " << gvec4Expr << " color = imageLoad(u_msImage, " << texelCoordStr << ", sampleNdx);\n"; + + if (useExactCompare) + src << " if (color == " << colorExpr << ")\n" + << " ++checksum;\n"; + else + src << " " << gvec4Expr << " diff = abs(abs(color) - abs(" << colorExpr << "));\n" + << " if (all(lessThan(diff, " << gvec4Expr << "(0.02))))\n" + << " ++checksum;\n"; + + src << " }\n" + << "\n" + << " imageStore(u_checksumImage, " << texelCoordStr << ", ivec4(checksum));\n" + << "}\n"; + + programCollection.glslSources.add("comp_load") << glu::ComputeSource(src.str()); + } +} + +void checkRequirements (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const CaseDef& caseDef) +{ + VkPhysicalDeviceFeatures features; + vki.getPhysicalDeviceFeatures(physDevice, &features); + + if (!features.shaderStorageImageMultisample) + TCU_THROW(NotSupportedError, "Multisampled storage images are not supported"); + + VkImageFormatProperties imageFormatProperties; + const VkResult imageFormatResult = vki.getPhysicalDeviceImageFormatProperties( + physDevice, caseDef.format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT, (VkImageCreateFlags)0, &imageFormatProperties); + + if (imageFormatResult == VK_ERROR_FORMAT_NOT_SUPPORTED) + TCU_THROW(NotSupportedError, "Format is not supported"); + + if ((imageFormatProperties.sampleCounts & caseDef.numSamples) != caseDef.numSamples) + TCU_THROW(NotSupportedError, "Requested sample count is not supported"); +} + +//! Helper function to deal with per-layer resources. +void insertImageViews (const DeviceInterface& vk, const VkDevice device, const CaseDef& caseDef, const VkFormat format, const VkImage image, std::vector* const pOutImageViews) +{ + if (caseDef.singleLayerBind) + { + pOutImageViews->clear(); + pOutImageViews->resize(caseDef.texture.numLayers()); + for (int layerNdx = 0; layerNdx < caseDef.texture.numLayers(); ++layerNdx) + { + (*pOutImageViews)[layerNdx] = makeVkSharedPtr(makeImageView( + vk, device, image, mapImageViewType(getImageTypeForSingleLayer(caseDef.texture.type())), format, + makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, layerNdx, 1u))); + } + } + else // bind all layers at once + { + pOutImageViews->clear(); + pOutImageViews->resize(1); + (*pOutImageViews)[0] = makeVkSharedPtr(makeImageView( + vk, device, image, mapImageViewType(caseDef.texture.type()), format, + makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, caseDef.texture.numLayers()))); + } +} + +//! Helper function to deal with per-layer resources. +void insertDescriptorSets (const DeviceInterface& vk, const VkDevice device, const CaseDef& caseDef, const VkDescriptorPool descriptorPool, const VkDescriptorSetLayout descriptorSetLayout, std::vector* const pOutDescriptorSets) +{ + if (caseDef.singleLayerBind) + { + pOutDescriptorSets->clear(); + pOutDescriptorSets->resize(caseDef.texture.numLayers()); + for (int layerNdx = 0; layerNdx < caseDef.texture.numLayers(); ++layerNdx) + (*pOutDescriptorSets)[layerNdx] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout)); + } + else // bind all layers at once + { + pOutDescriptorSets->clear(); + pOutDescriptorSets->resize(1); + (*pOutDescriptorSets)[0] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout)); + } +} + +tcu::TestStatus test (Context& context, const CaseDef caseDef) +{ + const InstanceInterface& vki = context.getInstanceInterface(); + const VkPhysicalDevice physDevice = context.getPhysicalDevice(); + const DeviceInterface& vk = context.getDeviceInterface(); + const VkDevice device = context.getDevice(); + const VkQueue queue = context.getUniversalQueue(); + const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); + Allocator& allocator = context.getDefaultAllocator(); + + checkRequirements(vki, physDevice, caseDef); + + // Images + + const UniquePtr msImage(new Image( + vk, device, allocator, makeImageCreateInfo(caseDef.texture, caseDef.format, VK_IMAGE_USAGE_STORAGE_BIT, 0u), MemoryRequirement::Any)); + + const UniquePtr checksumImage(new Image( + vk, device, allocator, + makeImageCreateInfo(Texture(caseDef.texture, 1), CHECKSUM_IMAGE_FORMAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0u), + MemoryRequirement::Any)); + + // Buffer used to pass constants to the shader. + + const int numLayers = caseDef.texture.numLayers(); + const VkDeviceSize bufferChunkSize = getOptimalUniformBufferChunkSize(vki, physDevice, sizeof(deInt32)); + const VkDeviceSize constantsBufferSizeBytes = numLayers * bufferChunkSize; + UniquePtr constantsBuffer (new Buffer(vk, device, allocator, makeBufferCreateInfo(constantsBufferSizeBytes, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), + MemoryRequirement::HostVisible)); + + { + const Allocation& alloc = constantsBuffer->getAllocation(); + deUint8* const basePtr = static_cast(alloc.getHostPtr()); + + deMemset(alloc.getHostPtr(), 0, static_cast(constantsBufferSizeBytes)); + + for (int layerNdx = 0; layerNdx < numLayers; ++layerNdx) + { + deInt32* const valuePtr = reinterpret_cast(basePtr + layerNdx * bufferChunkSize); + *valuePtr = layerNdx; + } + + flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), constantsBufferSizeBytes); + } + + const VkDeviceSize resultBufferSizeBytes = getImageSizeBytes(caseDef.texture.size(), CHECKSUM_IMAGE_FORMAT); + UniquePtr resultBuffer (new Buffer(vk, device, allocator, makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), + MemoryRequirement::HostVisible)); + + { + const Allocation& alloc = resultBuffer->getAllocation(); + deMemset(alloc.getHostPtr(), 0, static_cast(resultBufferSizeBytes)); + flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes); + } + + // Descriptors + + Unique descriptorSetLayout(DescriptorSetLayoutBuilder() + .addSingleBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT) + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) + .build(vk, device)); + + Unique descriptorPool(DescriptorPoolBuilder() + .addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, numLayers) + .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, numLayers) + .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, numLayers) + .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, numLayers)); + + std::vector allDescriptorSets; + std::vector allMultisampledImageViews; + std::vector allChecksumImageViews; + + insertDescriptorSets(vk, device, caseDef, *descriptorPool, *descriptorSetLayout, &allDescriptorSets); + insertImageViews (vk, device, caseDef, caseDef.format, **msImage, &allMultisampledImageViews); + insertImageViews (vk, device, caseDef, CHECKSUM_IMAGE_FORMAT, **checksumImage, &allChecksumImageViews); + + // Prepare commands + + const Unique pipelineLayout (makePipelineLayout (vk, device, *descriptorSetLayout)); + const Unique cmdPool (makeCommandPool (vk, device, queueFamilyIndex)); + const Unique cmdBuffer (makeCommandBuffer (vk, device, *cmdPool)); + + const tcu::IVec3 workSize = (caseDef.singleLayerBind ? caseDef.texture.layerSize() : caseDef.texture.size()); + const int loopNumLayers = (caseDef.singleLayerBind ? numLayers : 1); + const VkImageSubresourceRange subresourceAllLayers = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, caseDef.texture.numLayers()); + + // Pass 1: Write MS image + { + const Unique shaderModule (createShaderModule (vk, device, context.getBinaryCollection().get("comp_store"), 0)); + const Unique pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule)); + + beginCommandBuffer(vk, *cmdBuffer); + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline); + + { + const VkImageMemoryBarrier barriers[] = + { + makeImageMemoryBarrier((VkAccessFlags)0, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, **msImage, subresourceAllLayers), + makeImageMemoryBarrier((VkAccessFlags)0, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, **checksumImage, subresourceAllLayers), + }; + + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, + 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers); + } + + for (int layerNdx = 0; layerNdx < loopNumLayers; ++layerNdx) + { + const VkDescriptorSet descriptorSet = **allDescriptorSets[layerNdx]; + const VkDescriptorImageInfo descriptorMultiImageInfo = makeDescriptorImageInfo(DE_NULL, **allMultisampledImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL); + const VkDescriptorBufferInfo descriptorConstantsBufferInfo = makeDescriptorBufferInfo(constantsBuffer->get(), layerNdx*bufferChunkSize, bufferChunkSize); + + DescriptorSetUpdateBuilder() + .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descriptorConstantsBufferInfo) + .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorMultiImageInfo) + .update(vk, device); + + vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL); + vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), workSize.z()); + } + + endCommandBuffer(vk, *cmdBuffer); + submitCommandsAndWait(vk, device, queue, *cmdBuffer); + } + + // Pass 2: "Resolve" MS image in compute shader + { + const Unique shaderModule (createShaderModule (vk, device, context.getBinaryCollection().get("comp_load"), 0)); + const Unique pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule)); + + beginCommandBuffer(vk, *cmdBuffer); + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline); + + { + const VkImageMemoryBarrier barriers[] = + { + makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, **msImage, subresourceAllLayers), + }; + + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, + 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers); + } + + for (int layerNdx = 0; layerNdx < loopNumLayers; ++layerNdx) + { + const VkDescriptorSet descriptorSet = **allDescriptorSets[layerNdx]; + const VkDescriptorImageInfo descriptorMultiImageInfo = makeDescriptorImageInfo(DE_NULL, **allMultisampledImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL); + const VkDescriptorImageInfo descriptorChecksumImageInfo = makeDescriptorImageInfo(DE_NULL, **allChecksumImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL); + const VkDescriptorBufferInfo descriptorConstantsBufferInfo = makeDescriptorBufferInfo(constantsBuffer->get(), layerNdx*bufferChunkSize, bufferChunkSize); + + DescriptorSetUpdateBuilder() + .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descriptorConstantsBufferInfo) + .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorMultiImageInfo) + .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorChecksumImageInfo) + .update(vk, device); + + vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL); + vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), workSize.z()); + } + + endCommandBuffer(vk, *cmdBuffer); + submitCommandsAndWait(vk, device, queue, *cmdBuffer); + } + + // Retrieve result + { + beginCommandBuffer(vk, *cmdBuffer); + + { + const VkImageMemoryBarrier barriers[] = + { + makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **checksumImage, subresourceAllLayers), + }; + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, + 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers); + } + { + const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(caseDef.texture.layerSize()), caseDef.texture.numLayers()); + vk.cmdCopyImageToBuffer(*cmdBuffer, **checksumImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **resultBuffer, 1u, ©Region); + } + { + const VkBufferMemoryBarrier barriers[] = + { + makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, **resultBuffer, 0ull, resultBufferSizeBytes), + }; + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, + 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers, 0u, DE_NULL); + } + + endCommandBuffer(vk, *cmdBuffer); + submitCommandsAndWait(vk, device, queue, *cmdBuffer); + } + + // Verify + { + const Allocation& alloc = resultBuffer->getAllocation(); + invalidateMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes); + + const IVec3 imageSize = caseDef.texture.size(); + const deInt32* pDataPtr = static_cast(alloc.getHostPtr()); + const deInt32 expectedChecksum = caseDef.texture.numSamples(); + + for (int layer = 0; layer < imageSize.z(); ++layer) + for (int y = 0; y < imageSize.y(); ++y) + for (int x = 0; x < imageSize.x(); ++x) + { + if (*pDataPtr != expectedChecksum) + { + context.getTestContext().getLog() + << tcu::TestLog::Message << "Some sample colors were incorrect at (x, y, layer) = (" << x << ", " << y << ", " << layer << ")" << tcu::TestLog::EndMessage + << tcu::TestLog::Message << "Checksum value is " << *pDataPtr << " but expected " << expectedChecksum << tcu::TestLog::EndMessage; + + return tcu::TestStatus::fail("Some sample colors were incorrect"); + } + ++pDataPtr; + } + + return tcu::TestStatus::pass("OK"); + } +} + +} // anonymous ns + +tcu::TestCaseGroup* createImageMultisampleLoadStoreTests (tcu::TestContext& testCtx) +{ + const Texture textures[] = + { + // \note Shader code is tweaked to work with image size of 32, take a look if this needs to be modified. + Texture(IMAGE_TYPE_2D, tcu::IVec3(32, 32, 1), 1), + Texture(IMAGE_TYPE_2D_ARRAY, tcu::IVec3(32, 32, 1), 4), + }; + + static const VkFormat formats[] = + { + VK_FORMAT_R32G32B32A32_SFLOAT, + VK_FORMAT_R16G16B16A16_SFLOAT, + VK_FORMAT_R32_SFLOAT, + + VK_FORMAT_R32G32B32A32_UINT, + VK_FORMAT_R16G16B16A16_UINT, + VK_FORMAT_R8G8B8A8_UINT, + VK_FORMAT_R32_UINT, + + VK_FORMAT_R32G32B32A32_SINT, + VK_FORMAT_R16G16B16A16_SINT, + VK_FORMAT_R8G8B8A8_SINT, + VK_FORMAT_R32_SINT, + + VK_FORMAT_R8G8B8A8_UNORM, + + VK_FORMAT_R8G8B8A8_SNORM, + }; + + static const VkSampleCountFlagBits samples[] = + { + VK_SAMPLE_COUNT_2_BIT, + VK_SAMPLE_COUNT_4_BIT, + VK_SAMPLE_COUNT_8_BIT, + VK_SAMPLE_COUNT_16_BIT, + VK_SAMPLE_COUNT_32_BIT, + VK_SAMPLE_COUNT_64_BIT, + }; + + MovePtr testGroup(new tcu::TestCaseGroup(testCtx, "load_store_multisample", "Multisampled image store and load")); + + for (int baseTextureNdx = 0; baseTextureNdx < DE_LENGTH_OF_ARRAY(textures); ++baseTextureNdx) + { + const Texture& baseTexture = textures[baseTextureNdx]; + MovePtr imageViewGroup (new tcu::TestCaseGroup(testCtx, getImageTypeName(baseTexture.type()).c_str(), "")); + const int numLayerBindModes = (baseTexture.numLayers() == 1 ? 1 : 2); + + for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx) + for (int layerBindMode = 0; layerBindMode < numLayerBindModes; ++layerBindMode) + { + const bool singleLayerBind = (layerBindMode != 0); + const std::string formatGroupName = getFormatShortString(formats[formatNdx]) + (singleLayerBind ? "_single_layer" : ""); + MovePtr formatGroup (new tcu::TestCaseGroup(testCtx, formatGroupName.c_str(), "")); + + for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); ++samplesNdx) + { + const std::string samplesCaseName = "samples_" + de::toString(samples[samplesNdx]); + + const CaseDef caseDef = + { + Texture(baseTexture, samples[samplesNdx]), + formats[formatNdx], + samples[samplesNdx], + singleLayerBind, + }; + + addFunctionCaseWithPrograms(formatGroup.get(), samplesCaseName, "", initPrograms, test, caseDef); + } + imageViewGroup->addChild(formatGroup.release()); + } + testGroup->addChild(imageViewGroup.release()); + } + + return testGroup.release(); +} + +} // image +} // vkt diff --git a/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.hpp b/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.hpp new file mode 100644 index 0000000..daddd05 --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.hpp @@ -0,0 +1,39 @@ +#ifndef _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP +#define _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2016 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Multisampled image load/store Tests + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "vktTestCase.hpp" + +namespace vkt +{ +namespace image +{ + +tcu::TestCaseGroup* createImageMultisampleLoadStoreTests (tcu::TestContext& testCtx); + +} // image +} // vkt + +#endif // _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP diff --git a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp index ef6d83f..d83f6d1 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp @@ -23,6 +23,7 @@ #include "vktImageTests.hpp" #include "vktImageLoadStoreTests.hpp" +#include "vktImageMultisampleLoadStoreTests.hpp" #include "vktImageQualifiersTests.hpp" #include "vktImageSizeTests.hpp" #include "vktTestGroupUtil.hpp" @@ -42,6 +43,7 @@ void createChildren (tcu::TestCaseGroup* imageTests) imageTests->addChild(createImageStoreTests(testCtx)); imageTests->addChild(createImageLoadStoreTests(testCtx)); + imageTests->addChild(createImageMultisampleLoadStoreTests(testCtx)); imageTests->addChild(createImageFormatReinterpretTests(testCtx)); imageTests->addChild(createImageQualifiersTests(testCtx)); imageTests->addChild(createImageSizeTests(testCtx)); diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp index b847e19..437b830 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp @@ -500,25 +500,39 @@ std::string getImageTypeName (const ImageType imageType) } } -std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType) +std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample) { std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" : tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : ""; std::string imageTypePart; - switch (imageType) + if (multisample) { - case IMAGE_TYPE_1D: imageTypePart = "1D"; break; - case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break; - case IMAGE_TYPE_2D: imageTypePart = "2D"; break; - case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break; - case IMAGE_TYPE_3D: imageTypePart = "3D"; break; - case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break; - case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break; - case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break; - - default: - DE_ASSERT(false); + switch (imageType) + { + case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break; + case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break; + + default: + DE_ASSERT(false); + } + } + else + { + switch (imageType) + { + case IMAGE_TYPE_1D: imageTypePart = "1D"; break; + case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break; + case IMAGE_TYPE_2D: imageTypePart = "2D"; break; + case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break; + case IMAGE_TYPE_3D: imageTypePart = "3D"; break; + case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break; + case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break; + case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break; + + default: + DE_ASSERT(false); + } } return formatPart + "image" + imageTypePart; @@ -568,5 +582,14 @@ std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format) return std::string() + orderPart + typePart; } +std::string getFormatShortString (const VkFormat format) +{ + const std::string fullName = getFormatName(format); + + DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_")); + + return de::toLower(fullName.substr(10)); +} + } // image } // vkt diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp index afe8a31..039dca0 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp @@ -53,7 +53,7 @@ enum ImageType vk::VkImageType mapImageType (const ImageType imageType); vk::VkImageViewType mapImageViewType (const ImageType imageType); std::string getImageTypeName (const ImageType imageType); -std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType); +std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample = false); std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format); class Buffer @@ -176,6 +176,8 @@ inline vk::VkDeviceSize getImageSizeBytes (const tcu::IVec3& imageSize, const vk return tcu::getPixelSize(vk::mapVkFormat(format)) * imageSize.x() * imageSize.y() * imageSize.z(); } +std::string getFormatShortString (const vk::VkFormat format); + } // image } // vkt diff --git a/external/vulkancts/modules/vulkan/image/vktImageTexture.cpp b/external/vulkancts/modules/vulkan/image/vktImageTexture.cpp index ce58f00..68d11a0 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTexture.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTexture.cpp @@ -28,23 +28,24 @@ namespace vkt namespace image { -Texture::Texture (const ImageType type_, const tcu::IVec3& layerSize_, const int layers) - : m_layerSize (layerSize_) - , m_type (type_) - , m_numLayers (layers) +void Texture::checkInvariants (void) const { + DE_ASSERT((m_numSamples == 1) || (m_numSamples == 2) || (m_numSamples == 4) || (m_numSamples == 8) || + (m_numSamples == 16) || (m_numSamples == 32) || (m_numSamples == 64)); DE_ASSERT(m_numLayers >= 1); DE_ASSERT(m_layerSize.x() >= 1 && m_layerSize.y() >= 1 && m_layerSize.z() >= 1); - switch (type_) + switch (m_type) { case IMAGE_TYPE_1D: case IMAGE_TYPE_BUFFER: DE_ASSERT(m_numLayers == 1); + DE_ASSERT(m_numSamples == 1); DE_ASSERT(m_layerSize.y() == 1 && m_layerSize.z() == 1); break; case IMAGE_TYPE_1D_ARRAY: + DE_ASSERT(m_numSamples == 1); DE_ASSERT(m_layerSize.y() == 1 && m_layerSize.z() == 1); break; @@ -58,16 +59,19 @@ Texture::Texture (const ImageType type_, const tcu::IVec3& layerSize_, const int break; case IMAGE_TYPE_CUBE: + DE_ASSERT(m_numSamples == 1); DE_ASSERT(m_numLayers == 6); DE_ASSERT(m_layerSize.z() == 1); break; case IMAGE_TYPE_CUBE_ARRAY: + DE_ASSERT(m_numSamples == 1); DE_ASSERT(m_numLayers >= 6 && m_numLayers % 6 == 0); DE_ASSERT(m_layerSize.z() == 1); break; case IMAGE_TYPE_3D: + DE_ASSERT(m_numSamples == 1); DE_ASSERT(m_numLayers == 1); break; @@ -77,6 +81,24 @@ Texture::Texture (const ImageType type_, const tcu::IVec3& layerSize_, const int } } +Texture::Texture (const ImageType imageType, const tcu::IVec3& imageLayerSize, const int layers, const int samples) + : m_layerSize (imageLayerSize) + , m_type (imageType) + , m_numLayers (layers) + , m_numSamples (samples) +{ + checkInvariants(); +} + +Texture::Texture (const Texture& other, const int samples) + : m_layerSize (other.m_layerSize) + , m_type (other.m_type) + , m_numLayers (other.m_numLayers) + , m_numSamples (samples) +{ + checkInvariants(); +} + tcu::IVec3 Texture::size (void) const { switch (m_type) diff --git a/external/vulkancts/modules/vulkan/image/vktImageTexture.hpp b/external/vulkancts/modules/vulkan/image/vktImageTexture.hpp index 18c32ab..8edae9f 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTexture.hpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTexture.hpp @@ -35,20 +35,25 @@ namespace image class Texture { public: - Texture (const ImageType type, const tcu::IVec3& layerSize, const int layers); + Texture (const ImageType imageType, const tcu::IVec3& imageLayerSize, const int layers, const int samples = 1); + Texture (const Texture& other, const int samples); ImageType type (void) const { return m_type; } //!< Texture type tcu::IVec3 layerSize (void) const { return m_layerSize; } //!< Size of a single layer int numLayers (void) const { return m_numLayers; } //!< Number of array layers (for array and cube types) + int numSamples (void) const { return m_numSamples; } //!< Number of samples per texel (multisampled texture) tcu::IVec3 size (void) const; //!< Size including number of layers in additional dimension (e.g. z in 2d texture) int dimension (void) const; //!< Coordinate dimension used for addressing (e.g. 3 (x,y,z) for 2d array) int layerDimension (void) const; //!< Coordinate dimension used for addressing a single layer (e.g. 2 (x,y) for 2d array) private: + void checkInvariants (void) const; + const tcu::IVec3 m_layerSize; const ImageType m_type; const int m_numLayers; + const int m_numSamples; }; inline bool isCube (const Texture& texture) diff --git a/external/vulkancts/mustpass/1.0.1/vk-default.txt b/external/vulkancts/mustpass/1.0.1/vk-default.txt index 4597ff2..3602832 100644 --- a/external/vulkancts/mustpass/1.0.1/vk-default.txt +++ b/external/vulkancts/mustpass/1.0.1/vk-default.txt @@ -96269,6 +96269,240 @@ dEQP-VK.image.load_store.buffer.r8g8b8a8_sint dEQP-VK.image.load_store.buffer.r32_sint dEQP-VK.image.load_store.buffer.r8g8b8a8_unorm dEQP-VK.image.load_store.buffer.r8g8b8a8_snorm +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_64 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_2 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_4 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_8 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_16 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_32 +dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_64 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_2 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_4 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_8 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_16 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_32 +dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_64 dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_uint dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_sint dEQP-VK.image.format_reinterpret.1d.r16g16b16a16_sfloat_r16g16b16a16_uint -- 2.7.4