external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemCopyImageToBufferTests.cpp \
external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemFillUpdateCopyBufferTests.cpp \
external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemImageValidator.cpp \
+ external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemStorageBufferTests.cpp \
external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemTests.cpp \
external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemUtils.cpp \
external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp \
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_8
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_9
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_10
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_7
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_8
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_9
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_10
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_7
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_8
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_9
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_10
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_7
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_8
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_9
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_10
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_7
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_8
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_9
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_10
vktProtectedMemCopyImageToBufferTests.cpp
vktProtectedMemCopyBufferToImageTests.hpp
vktProtectedMemCopyBufferToImageTests.cpp
+ vktProtectedMemStorageBufferTests.cpp
+ vktProtectedMemStorageBufferTests.hpp
)
set(DEQP_VK_PROTECTED_MEMORY_LIBS
template<typename T>
struct ValidationDataStorage {
- const T values;
+ T values;
};
typedef ValidationData<tcu::UVec4> ValidationDataUVec4;
{
ctx.getTestContext().getLog()
<< tcu::TestLog::Message << "Reference values: \n"
- << "1: " << m_refData.values << "\n"
+ << "1: " << m_refDataStorage.values << "\n"
<< tcu::TestLog::EndMessage;
}
}
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 The Khronos Group Inc.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * 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 Protected memory storage buffer tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktProtectedMemStorageBufferTests.hpp"
+
+#include "deRandom.hpp"
+#include "deStringUtil.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuVector.hpp"
+#include "tcuStringTemplate.hpp"
+
+#include "vkPrograms.hpp"
+#include "vktTestCase.hpp"
+#include "vktTestGroupUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkBuilderUtil.hpp"
+
+#include "vktProtectedMemBufferValidator.hpp"
+#include "vktProtectedMemUtils.hpp"
+#include "vktProtectedMemContext.hpp"
+
+namespace vkt
+{
+namespace ProtectedMem
+{
+
+namespace
+{
+
+enum {
+ RENDER_HEIGHT = 128,
+ RENDER_WIDTH = 128,
+};
+
+enum {
+ RANDOM_TEST_COUNT = 10,
+};
+
+enum SSBOTestType {
+ SSBO_READ,
+ SSBO_WRITE,
+ SSBO_ATOMIC
+};
+
+enum SSBOAtomicType {
+ ATOMIC_ADD,
+ ATOMIC_MIN,
+ ATOMIC_MAX,
+ ATOMIC_AND,
+ ATOMIC_OR,
+ ATOMIC_XOR,
+ ATOMIC_EXCHANGE,
+ ATOMIC_COMPSWAP
+};
+
+
+const char* getSSBOTestDescription (SSBOTestType type)
+{
+ switch (type) {
+ case SSBO_READ: return "Test for read storage buffer on protected memory.";
+ case SSBO_WRITE: return "Test for write storage buffer on protected memory.";
+ case SSBO_ATOMIC: return "Test for atomic storage buffer on protected memory.";
+ default: DE_FATAL("Invalid SSBO test type"); return "";
+ }
+}
+
+const char* getSSBOTypeString (SSBOTestType type)
+{
+ switch (type) {
+ case SSBO_READ: return "read";
+ case SSBO_WRITE: return "write";
+ case SSBO_ATOMIC: return "atomic";
+ default: DE_FATAL("Invalid SSBO test type"); return "";
+ }
+}
+
+const char* getShaderTypeString (const glu::ShaderType shaderType)
+{
+ switch (shaderType) {
+ case glu::SHADERTYPE_FRAGMENT: return "fragment";
+ case glu::SHADERTYPE_COMPUTE: return "compute";
+ default: DE_FATAL("Invalid shader type"); return "";
+ }
+}
+
+const char* getSSBOAtomicTypeString (SSBOAtomicType type)
+{
+ switch (type)
+ {
+ case ATOMIC_ADD: return "add";
+ case ATOMIC_MIN: return "min";
+ case ATOMIC_MAX: return "max";
+ case ATOMIC_AND: return "and";
+ case ATOMIC_OR: return "or";
+ case ATOMIC_XOR: return "xor";
+ case ATOMIC_EXCHANGE: return "exchange";
+ case ATOMIC_COMPSWAP: return "compswap";
+ default: DE_FATAL("Invalid SSBO atomic operation type"); return "";
+ }
+}
+
+void static addBufferCopyCmd (const vk::DeviceInterface& vk,
+ vk::VkCommandBuffer cmdBuffer,
+ deUint32 queueFamilyIndex,
+ vk::VkBuffer srcBuffer,
+ vk::VkBuffer dstBuffer,
+ deUint32 copySize)
+{
+ const vk::VkBufferMemoryBarrier dstWriteStartBarrier =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0, // VkAccessFlags srcAccessMask
+ vk::VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask
+ queueFamilyIndex, // uint32_t srcQueueFamilyIndex
+ queueFamilyIndex, // uint32_t dstQueueFamilyIndex
+ dstBuffer, // VkBuffer buffer
+ 0u, // VkDeviceSize offset
+ VK_WHOLE_SIZE, // VkDeviceSize size
+ };
+ vk.cmdPipelineBarrier(cmdBuffer,
+ vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
+ (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &dstWriteStartBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
+
+ const vk::VkBufferCopy copyRegion =
+ {
+ 0, // VkDeviceSize srcOffset
+ 0, // VkDeviceSize dstOffset
+ copySize // VkDeviceSize size
+ };
+ vk.cmdCopyBuffer(cmdBuffer, srcBuffer, dstBuffer, 1, ©Region);
+
+ const vk::VkBufferMemoryBarrier dstWriteEndBarrier =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
+ vk::VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask
+ queueFamilyIndex, // uint32_t srcQueueFamilyIndex
+ queueFamilyIndex, // uint32_t dstQueueFamilyIndex
+ dstBuffer, // VkBuffer buffer
+ 0u, // VkDeviceSize offset
+ VK_WHOLE_SIZE, // VkDeviceSize size
+ };
+ vk.cmdPipelineBarrier(cmdBuffer,
+ vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+ vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &dstWriteEndBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
+
+}
+
+template<typename T>
+class StorageBufferTestInstance : public ProtectedTestInstance
+{
+public:
+ StorageBufferTestInstance (Context& ctx,
+ const SSBOTestType testType,
+ const glu::ShaderType shaderType,
+ const tcu::UVec4 testInput,
+ const BufferValidator<T>& validator);
+ virtual tcu::TestStatus iterate (void);
+
+private:
+ tcu::TestStatus executeFragmentTest (void);
+ tcu::TestStatus executeComputeTest (void);
+
+ const SSBOTestType m_testType;
+ const glu::ShaderType m_shaderType;
+ const tcu::UVec4 m_testInput;
+ const BufferValidator<T>& m_validator;
+ const vk::VkFormat m_imageFormat;
+};
+
+template<typename T>
+class StorageBufferTestCase : public TestCase
+{
+public:
+ StorageBufferTestCase (tcu::TestContext& testctx,
+ const SSBOTestType testType,
+ const glu::ShaderType shaderType,
+ const char* name,
+ const tcu::UVec4 testInput,
+ ValidationDataStorage<T> validationData,
+ const std::string& extraShader = "")
+ : TestCase (testctx, name, getSSBOTestDescription(testType))
+ , m_testType (testType)
+ , m_shaderType (shaderType)
+ , m_testInput (testInput)
+ , m_validator (validationData)
+ , m_extraShader (extraShader)
+ {
+ }
+ virtual TestInstance* createInstance (Context& ctx) const
+ {
+ return new StorageBufferTestInstance<T>(ctx, m_testType, m_shaderType, m_testInput, m_validator);
+ }
+ virtual void initPrograms (vk::SourceCollections& programCollection) const;
+
+ virtual ~StorageBufferTestCase (void) {}
+
+private:
+ const SSBOTestType m_testType;
+ const glu::ShaderType m_shaderType;
+ const tcu::UVec4 m_testInput;
+ const BufferValidator<T> m_validator;
+ const std::string m_extraShader;
+};
+
+template<typename T>
+StorageBufferTestInstance<T>::StorageBufferTestInstance (Context& ctx,
+ const SSBOTestType testType,
+ const glu::ShaderType shaderType,
+ const tcu::UVec4 testInput,
+ const BufferValidator<T>& validator)
+ : ProtectedTestInstance (ctx)
+ , m_testType (testType)
+ , m_shaderType (shaderType)
+ , m_testInput (testInput)
+ , m_validator (validator)
+ , m_imageFormat (vk::VK_FORMAT_R8G8B8A8_UNORM)
+{
+}
+
+template<typename T>
+void StorageBufferTestCase<T>::initPrograms (vk::SourceCollections& programCollection) const
+{
+ const char* vertexShader =
+ "#version 450\n"
+ "layout(location=0) out vec4 vIndex;\n"
+ "void main() {\n"
+ " vec2 pos[4] = vec2[4]( vec2(-0.7, 0.7), vec2(0.7, 0.7), vec2(0.0, -0.7), vec2(-0.7, -0.7) );\n"
+ " vIndex = vec4(gl_VertexIndex);\n"
+ " gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);\n"
+ "}";
+
+ // set = 0, location = 0 -> buffer ProtectedTestBuffer (uvec4)
+ // set = 0, location = 2 -> buffer ProtectedTestBufferSource (uvec4)
+ const char* readShaderTemplateStr =
+ "#version 450\n"
+ "${INPUT_DECLARATION}\n"
+ "\n"
+ "layout(set=0, binding=0, std140) buffer ProtectedTestBuffer\n"
+ "{\n"
+ " highp uvec4 protectedTestResultBuffer;\n"
+ "};\n"
+ "\n"
+ "layout(set=0, binding=2, std140) buffer ProtectedTestBufferSource\n"
+ "{\n"
+ " highp uvec4 protectedTestBufferSource;\n"
+ "};\n"
+ "\n"
+ "void main (void)\n"
+ "{\n"
+ " protectedTestResultBuffer = protectedTestBufferSource;\n"
+ " ${FRAGMENT_OUTPUT}\n"
+ "}\n";
+
+ // set = 0, location = 0 -> buffer ProtectedTestBuffer (uvec4)
+ // set = 0, location = 1 -> uniform Data (uvec4)
+ const char* writeShaderTemplateStr =
+ "#version 450\n"
+ "${INPUT_DECLARATION}\n"
+ "\n"
+ "layout(set=0, binding=0, std140) buffer ProtectedTestBuffer\n"
+ "{\n"
+ " highp uvec4 protectedTestResultBuffer;\n"
+ "};\n"
+ "\n"
+ "layout(set=0, binding=1, std140) uniform Data\n"
+ "{\n"
+ " highp uvec4 testInput;\n"
+ "};\n"
+ "\n"
+ "void main (void)\n"
+ "{\n"
+ " protectedTestResultBuffer = testInput;\n"
+ " ${FRAGMENT_OUTPUT}\n"
+ "}\n";
+
+ // set = 0, location = 0 -> buffer ProtectedTestBuffer (uint [4])
+ const char* atomicTestShaderTemplateStr =
+ "#version 450\n"
+ "${INPUT_DECLARATION}\n"
+ "\n"
+ "layout(set=0, binding=0, std430) buffer ProtectedTestBuffer\n"
+ "{\n"
+ " highp uint protectedTestResultBuffer[4];\n"
+ "};\n"
+ "\n"
+ "void main (void)\n"
+ "{\n"
+ " uint i = uint(${INVOCATION_ID});\n"
+ " ${ATOMIC_FUNCTION_CALL}\n"
+ " ${FRAGMENT_OUTPUT}\n"
+ "}\n";
+
+ const char* shaderTemplateStr;
+ std::map<std::string, std::string> shaderParam;
+ switch (m_testType) {
+ case SSBO_READ: shaderTemplateStr = readShaderTemplateStr; break;
+ case SSBO_WRITE: shaderTemplateStr = writeShaderTemplateStr; break;
+ case SSBO_ATOMIC: {
+ shaderTemplateStr = atomicTestShaderTemplateStr;
+ shaderParam["ATOMIC_FUNCTION_CALL"] = m_extraShader;
+ break;
+ }
+ default: DE_FATAL("Incorrect SSBO test type"); return;
+ }
+
+ if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
+ {
+ shaderParam["INPUT_DECLARATION"] = "layout(location=0) out mediump vec4 o_color;\n"
+ "layout(location=0) in vec4 vIndex;\n";
+ shaderParam["FRAGMENT_OUTPUT"] = "o_color = vec4( 0.0, 0.4, 1.0, 1.0 );\n";
+ shaderParam["INVOCATION_ID"] = "vIndex.x";
+
+ programCollection.glslSources.add("vert") << glu::VertexSource(vertexShader);
+ programCollection.glslSources.add("TestShader") << glu::FragmentSource(tcu::StringTemplate(shaderTemplateStr).specialize(shaderParam));
+ }
+ else if (m_shaderType == glu::SHADERTYPE_COMPUTE)
+ {
+ shaderParam["INPUT_DECLARATION"] = "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n";
+ shaderParam["FRAGMENT_OUTPUT"] = "";
+ shaderParam["INVOCATION_ID"] = "gl_GlobalInvocationID.x";
+ programCollection.glslSources.add("TestShader") << glu::ComputeSource(tcu::StringTemplate(shaderTemplateStr).specialize(shaderParam));
+ }
+ else
+ DE_FATAL("Incorrect shader type");
+
+ m_validator.initPrograms(programCollection);
+}
+
+template<typename T>
+tcu::TestStatus StorageBufferTestInstance<T>::executeFragmentTest(void)
+{
+ ProtectedContext& ctx (m_protectedContext);
+ const vk::DeviceInterface& vk = ctx.getDeviceInterface();
+ const vk::VkDevice device = ctx.getDevice();
+ const vk::VkQueue queue = ctx.getQueue();
+ const deUint32 queueFamilyIndex = ctx.getQueueFamilyIndex();
+
+ const deUint32 testUniformSize = sizeof(m_testInput);
+ de::UniquePtr<vk::BufferWithMemory> testUniform (makeBuffer(ctx,
+ PROTECTION_DISABLED,
+ queueFamilyIndex,
+ testUniformSize,
+ vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+ vk::MemoryRequirement::HostVisible));
+
+ // Set the test input uniform data
+ {
+ deMemcpy(testUniform->getAllocation().getHostPtr(), &m_testInput, testUniformSize);
+ vk::flushMappedMemoryRange(vk, device, testUniform->getAllocation().getMemory(), testUniform->getAllocation().getOffset(), testUniformSize);
+ }
+ const deUint32 testBufferSize = sizeof(ValidationDataStorage<T>);
+ de::MovePtr<vk::BufferWithMemory> testBuffer (makeBuffer(ctx,
+ PROTECTION_ENABLED,
+ queueFamilyIndex,
+ testBufferSize,
+ vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ vk::MemoryRequirement::Protected));
+ de::MovePtr<vk::BufferWithMemory> testBufferSource (makeBuffer(ctx,
+ PROTECTION_ENABLED,
+ queueFamilyIndex,
+ testBufferSize,
+ vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ vk::MemoryRequirement::Protected));
+
+ vk::Move<vk::VkShaderModule> vertexShader (vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("vert"), 0));
+ vk::Unique<vk::VkShaderModule> testShader (vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("TestShader"), 0));
+
+ // Create descriptors
+ vk::Unique<vk::VkDescriptorSetLayout> descriptorSetLayout(vk::DescriptorSetLayoutBuilder()
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_ALL)
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_ALL)
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_ALL)
+ .build(vk, device));
+ vk::Unique<vk::VkDescriptorPool> descriptorPool(vk::DescriptorPoolBuilder()
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
+ .addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
+ .build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
+ vk::Unique<vk::VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
+
+ // Update descriptor set information
+ {
+ vk::VkDescriptorBufferInfo descTestBuffer = makeDescriptorBufferInfo(**testBuffer, 0, testBufferSize);
+ vk::VkDescriptorBufferInfo descTestUniform = makeDescriptorBufferInfo(**testUniform, 0, testUniformSize);
+ vk::VkDescriptorBufferInfo descTestBufferSource = makeDescriptorBufferInfo(**testBufferSource, 0, testBufferSize);
+
+ vk::DescriptorSetUpdateBuilder()
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBuffer)
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descTestUniform)
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBufferSource)
+ .update(vk, device);
+ }
+
+ // Create output image
+ de::MovePtr<vk::ImageWithMemory> colorImage (createImage2D(ctx, PROTECTION_ENABLED, queueFamilyIndex,
+ RENDER_WIDTH, RENDER_HEIGHT,
+ m_imageFormat,
+ vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|vk::VK_IMAGE_USAGE_SAMPLED_BIT));
+ vk::Unique<vk::VkImageView> colorImageView (createImageView(ctx, **colorImage, m_imageFormat));
+ vk::Unique<vk::VkRenderPass> renderPass (createRenderPass(ctx, m_imageFormat));
+ vk::Unique<vk::VkFramebuffer> framebuffer (createFramebuffer(ctx, RENDER_WIDTH, RENDER_HEIGHT, *renderPass, *colorImageView));
+
+ // Build pipeline
+ vk::Unique<vk::VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
+ vk::Unique<vk::VkCommandPool> cmdPool (makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
+ vk::Unique<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ // Create pipeline
+ vk::Unique<vk::VkPipeline> graphicsPipeline (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass,
+ *vertexShader, *testShader,
+ std::vector<vk::VkVertexInputBindingDescription>(),
+ std::vector<vk::VkVertexInputAttributeDescription>(),
+ tcu::UVec2(RENDER_WIDTH, RENDER_HEIGHT),
+ vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST));
+
+ beginCommandBuffer(vk, *cmdBuffer);
+
+ if (m_testType == SSBO_READ || m_testType == SSBO_ATOMIC)
+ {
+ vk::VkBuffer targetBuffer = (m_testType == SSBO_ATOMIC) ? **testBuffer : **testBufferSource;
+ addBufferCopyCmd(vk, *cmdBuffer, queueFamilyIndex, **testUniform, targetBuffer, testUniformSize);
+ }
+
+ // Start image barrier
+ {
+ const vk::VkImageMemoryBarrier startImgBarrier =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
+ DE_NULL, // pNext
+ 0, // srcAccessMask
+ vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // dstAccessMask
+ vk::VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
+ vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
+ queueFamilyIndex, // srcQueueFamilyIndex
+ queueFamilyIndex, // dstQueueFamilyIndex
+ **colorImage, // image
+ {
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
+ 0u, // baseMipLevel
+ 1u, // mipLevels
+ 0u, // baseArraySlice
+ 1u, // subresourceRange
+ }
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer,
+ vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &startImgBarrier);
+ }
+
+ const vk::VkClearValue clearValue = vk::makeClearValueColorF32(0.125f, 0.25f, 0.5f, 1.0f);
+ const vk::VkRenderPassBeginInfo renderPassBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *renderPass, // VkRenderPass renderPass;
+ *framebuffer, // VkFramebuffer framebuffer;
+ { { 0, 0 }, { RENDER_WIDTH, RENDER_HEIGHT } }, // VkRect2D renderArea;
+ 1u, // deUint32 attachmentCount;
+ &clearValue // const VkClearValue* pAttachmentClearValues;
+ };
+
+ vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, vk::VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
+ vk.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL);
+
+ vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
+ vk.cmdEndRenderPass(*cmdBuffer);
+
+ {
+ const vk::VkImageMemoryBarrier endImgBarrier =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
+ DE_NULL, // pNext
+ vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // srcAccessMask
+ vk::VK_ACCESS_SHADER_READ_BIT, // dstAccessMask
+ vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout
+ vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // newLayout
+ queueFamilyIndex, // srcQueueFamilyIndex
+ queueFamilyIndex, // dstQueueFamilyIndex
+ **colorImage, // image
+ {
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
+ 0u, // baseMipLevel
+ 1u, // mipLevels
+ 0u, // baseArraySlice
+ 1u, // subresourceRange
+ }
+ };
+ vk.cmdPipelineBarrier(*cmdBuffer,
+ vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &endImgBarrier);
+ }
+
+ VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
+
+ // Execute Draw
+ {
+ const vk::Unique<vk::VkFence> fence (vk::createFence(vk, device));
+ VK_CHECK(vk.resetFences(device, 1, &fence.get()));
+ VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
+ }
+
+ // Log inputs
+ ctx.getTestContext().getLog()
+ << tcu::TestLog::Message << "Input values: \n"
+ << "1: " << m_testInput << "\n"
+ << tcu::TestLog::EndMessage;
+
+ // Validate buffer
+ if (m_validator.validateBuffer(ctx, **testBuffer))
+ return tcu::TestStatus::pass("Everything went OK");
+ else
+ return tcu::TestStatus::fail("Something went really wrong");
+}
+
+template<typename T>
+tcu::TestStatus StorageBufferTestInstance<T>::executeComputeTest(void)
+{
+ ProtectedContext& ctx (m_protectedContext);
+ const vk::DeviceInterface& vk = ctx.getDeviceInterface();
+ const vk::VkDevice device = ctx.getDevice();
+ const vk::VkQueue queue = ctx.getQueue();
+ const deUint32 queueFamilyIndex = ctx.getQueueFamilyIndex();
+
+ const deUint32 testUniformSize = sizeof(m_testInput);
+ de::UniquePtr<vk::BufferWithMemory> testUniform (makeBuffer(ctx,
+ PROTECTION_DISABLED,
+ queueFamilyIndex,
+ testUniformSize,
+ vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+ vk::MemoryRequirement::HostVisible));
+
+ // Set the test input uniform data
+ {
+ deMemcpy(testUniform->getAllocation().getHostPtr(), &m_testInput, testUniformSize);
+ vk::flushMappedMemoryRange(vk, device, testUniform->getAllocation().getMemory(), testUniform->getAllocation().getOffset(), testUniformSize);
+ }
+
+ const deUint32 testBufferSize = sizeof(ValidationDataStorage<T>);
+ de::MovePtr<vk::BufferWithMemory> testBuffer (makeBuffer(ctx,
+ PROTECTION_ENABLED,
+ queueFamilyIndex,
+ testBufferSize,
+ vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ vk::MemoryRequirement::Protected));
+ de::MovePtr<vk::BufferWithMemory> testBufferSource (makeBuffer(ctx,
+ PROTECTION_ENABLED,
+ queueFamilyIndex,
+ testBufferSize,
+ vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
+ | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+ vk::MemoryRequirement::Protected));
+
+ vk::Unique<vk::VkShaderModule> testShader (vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("TestShader"), 0));
+
+ // Create descriptors
+ vk::Unique<vk::VkDescriptorSetLayout> descriptorSetLayout(vk::DescriptorSetLayoutBuilder()
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
+ .build(vk, device));
+ vk::Unique<vk::VkDescriptorPool> descriptorPool(vk::DescriptorPoolBuilder()
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
+ .addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
+ .build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
+ vk::Unique<vk::VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
+
+ // Update descriptor set information
+ {
+ vk::VkDescriptorBufferInfo descTestBuffer = makeDescriptorBufferInfo(**testBuffer, 0, testBufferSize);
+ vk::VkDescriptorBufferInfo descTestUniform = makeDescriptorBufferInfo(**testUniform, 0, testUniformSize);
+ vk::VkDescriptorBufferInfo descTestBufferSource = makeDescriptorBufferInfo(**testBufferSource, 0, testBufferSize);
+
+ vk::DescriptorSetUpdateBuilder()
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBuffer)
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descTestUniform)
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBufferSource)
+ .update(vk, device);
+ }
+
+
+ // Build and execute test
+ {
+ const vk::Unique<vk::VkFence> fence (vk::createFence(vk, device));
+ vk::Unique<vk::VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
+ vk::Unique<vk::VkPipeline> SSBOPipeline (makeComputePipeline(vk, device, *pipelineLayout, *testShader, DE_NULL));
+ vk::Unique<vk::VkCommandPool> cmdPool (makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
+ vk::Unique<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+ deUint32 dispatchCount = (m_testType == SSBO_ATOMIC) ? 4u : 1u;
+
+ beginCommandBuffer(vk, *cmdBuffer);
+
+ if (m_testType == SSBO_READ || m_testType == SSBO_ATOMIC)
+ {
+ vk::VkBuffer targetBuffer = (m_testType == SSBO_ATOMIC) ? **testBuffer : **testBufferSource;
+ addBufferCopyCmd(vk, *cmdBuffer, queueFamilyIndex, **testUniform, targetBuffer, testUniformSize);
+ }
+
+ vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *SSBOPipeline);
+ vk.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL);
+
+ vk.cmdDispatch(*cmdBuffer, dispatchCount, 1u, 1u);
+
+ VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
+ VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
+ }
+
+ ctx.getTestContext().getLog()
+ << tcu::TestLog::Message << "Input values: \n"
+ << "1: " << m_testInput << "\n"
+ << tcu::TestLog::EndMessage;
+
+ // Validate buffer
+ if (m_validator.validateBuffer(ctx, **testBuffer))
+ return tcu::TestStatus::pass("Everything went OK");
+ else
+ return tcu::TestStatus::fail("Something went really wrong");
+}
+
+template<typename T>
+tcu::TestStatus StorageBufferTestInstance<T>::iterate(void)
+{
+ switch (m_shaderType)
+ {
+ case glu::SHADERTYPE_FRAGMENT: return executeFragmentTest();
+ case glu::SHADERTYPE_COMPUTE: return executeComputeTest();
+ default:
+ DE_FATAL("Incorrect shader type"); return tcu::TestStatus::fail("");
+ }
+}
+
+tcu::TestCaseGroup* createSpecifiedStorageBufferTests (tcu::TestContext& testCtx,
+ const std::string groupName,
+ SSBOTestType testType,
+ const glu::ShaderType shaderType,
+ const ValidationDataStorage<tcu::UVec4> testData[],
+ size_t testCount)
+{
+ const std::string testTypeStr = getSSBOTypeString(testType);
+ const std::string description = "Storage buffer " + testTypeStr + " tests";
+ de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, groupName.c_str(), description.c_str()));
+
+ for (size_t ndx = 0; ndx < testCount; ++ndx)
+ {
+ const std::string name = testTypeStr + "_" + de::toString(ndx + 1);
+ testGroup->addChild(new StorageBufferTestCase<tcu::UVec4>(testCtx, testType, shaderType, name.c_str(), testData[ndx].values, testData[ndx]));
+ }
+
+ return testGroup.release();
+}
+
+tcu::TestCaseGroup* createRandomizedBufferTests (tcu::TestContext& testCtx, SSBOTestType testType, const glu::ShaderType shaderType, size_t testCount)
+{
+ de::Random rnd (testCtx.getCommandLine().getBaseSeed());
+ std::vector<ValidationDataStorage<tcu::UVec4> > testData;
+ testData.resize(testCount);
+
+ for (size_t ndx = 0; ndx < testCount; ++ndx)
+ testData[ndx].values = tcu::UVec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32());
+
+ return createSpecifiedStorageBufferTests(testCtx, "random", testType, shaderType, testData.data(), testData.size());
+}
+
+tcu::TestCaseGroup* createRWStorageBufferTests (tcu::TestContext& testCtx,
+ const std::string groupName,
+ const std::string groupDescription,
+ SSBOTestType testType,
+ const ValidationDataStorage<tcu::UVec4> testData[],
+ size_t testCount)
+{
+ de::MovePtr<tcu::TestCaseGroup> ssboRWTestGroup (new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupDescription.c_str()));
+
+ glu::ShaderType shaderTypes[] = {
+ glu::SHADERTYPE_FRAGMENT,
+ glu::SHADERTYPE_COMPUTE
+ };
+
+ for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderTypes); ++shaderNdx)
+ {
+ const glu::ShaderType shaderType = shaderTypes[shaderNdx];
+ const std::string shaderName = getShaderTypeString(shaderType);
+ const std::string shaderGroupDesc = "Storage buffer tests for shader type: " + shaderName;
+ de::MovePtr<tcu::TestCaseGroup> testShaderGroup (new tcu::TestCaseGroup(testCtx, shaderName.c_str(), shaderGroupDesc.c_str()));
+
+ testShaderGroup->addChild(createSpecifiedStorageBufferTests(testCtx, "static", testType, shaderType, testData, testCount));
+ testShaderGroup->addChild(createRandomizedBufferTests(testCtx, testType, shaderType, RANDOM_TEST_COUNT));
+ ssboRWTestGroup->addChild(testShaderGroup.release());
+ }
+
+ return ssboRWTestGroup.release();
+}
+
+void calculateAtomicOpData (SSBOAtomicType type,
+ const tcu::UVec4& inputValue,
+ const deUint32 atomicArg,
+ std::string& atomicCall,
+ tcu::UVec4& refValue,
+ const deUint32 swapNdx = 0)
+{
+ switch (type)
+ {
+ case ATOMIC_ADD:
+ {
+ refValue = inputValue + tcu::UVec4(atomicArg);
+ atomicCall = "atomicAdd(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_MIN:
+ {
+ refValue = tcu::UVec4(std::min(inputValue.x(), atomicArg), std::min(inputValue.y(), atomicArg), std::min(inputValue.z(), atomicArg), std::min(inputValue.w(), atomicArg));
+ atomicCall = "atomicMin(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_MAX:
+ {
+ refValue = tcu::UVec4(std::max(inputValue.x(), atomicArg), std::max(inputValue.y(), atomicArg), std::max(inputValue.z(), atomicArg), std::max(inputValue.w(), atomicArg));
+ atomicCall = "atomicMax(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_AND:
+ {
+ refValue = tcu::UVec4(inputValue.x() & atomicArg, inputValue.y() & atomicArg, inputValue.z() & atomicArg, inputValue.w() & atomicArg);
+ atomicCall = "atomicAnd(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_OR:
+ {
+ refValue = tcu::UVec4(inputValue.x() | atomicArg, inputValue.y() | atomicArg, inputValue.z() | atomicArg, inputValue.w() | atomicArg);
+ atomicCall = "atomicOr(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_XOR:
+ {
+ refValue = tcu::UVec4(inputValue.x() ^ atomicArg, inputValue.y() ^ atomicArg, inputValue.z() ^ atomicArg, inputValue.w() ^ atomicArg);
+ atomicCall = "atomicXor(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_EXCHANGE:
+ {
+ refValue = tcu::UVec4(atomicArg);
+ atomicCall = "atomicExchange(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ case ATOMIC_COMPSWAP:
+ {
+ int selectedNdx = swapNdx % 4;
+ deUint32 selectedChange = inputValue[selectedNdx];
+
+ refValue = inputValue;
+ refValue[selectedNdx] = atomicArg;
+ atomicCall = "atomicCompSwap(protectedTestResultBuffer[i], " + de::toString(selectedChange) + "u, " + de::toString(atomicArg) + "u);";
+ break;
+ }
+ default: DE_FATAL("Incorrect atomic function type"); break;
+ }
+
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createReadStorageBufferTests (tcu::TestContext& testCtx)
+{
+ const ValidationDataStorage<tcu::UVec4> testData[] = {
+ { tcu::UVec4(0u, 0u, 0u, 0u) }, { tcu::UVec4(1u, 0u, 0u, 0u) },
+ { tcu::UVec4(0u, 1u, 0u, 0u) }, { tcu::UVec4(0u, 0u, 1u, 0u) },
+ { tcu::UVec4(0u, 0u, 0u, 1u) }, { tcu::UVec4(1u, 1u, 1u, 1u) }
+ };
+
+ return createRWStorageBufferTests(testCtx, "ssbo_read", "Storage Buffer Read Tests", SSBO_READ, testData, DE_LENGTH_OF_ARRAY(testData));
+}
+
+tcu::TestCaseGroup* createWriteStorageBufferTests (tcu::TestContext& testCtx)
+{
+ const ValidationDataStorage<tcu::UVec4> testData[] = {
+ { tcu::UVec4(0u, 0u, 0u, 0u) }, { tcu::UVec4(1u, 0u, 0u, 0u) },
+ { tcu::UVec4(0u, 1u, 0u, 0u) }, { tcu::UVec4(0u, 0u, 1u, 0u) },
+ { tcu::UVec4(0u, 0u, 0u, 1u) }, { tcu::UVec4(1u, 1u, 1u, 1u) }
+ };
+
+ return createRWStorageBufferTests(testCtx, "ssbo_write", "Storage Buffer Write Tests", SSBO_WRITE, testData, DE_LENGTH_OF_ARRAY(testData));
+}
+
+tcu::TestCaseGroup* createAtomicStorageBufferTests (tcu::TestContext& testctx)
+{
+ struct {
+ const tcu::UVec4 input;
+ const deUint32 atomicArg;
+ const deUint32 swapNdx;
+ } testData[] = {
+ { tcu::UVec4(0u, 1u, 2u, 3u), 10u, 0u },
+ { tcu::UVec4(10u, 20u, 30u, 40u), 3u, 2u },
+ { tcu::UVec4(800u, 400u, 230u, 999u), 50u, 3u },
+ { tcu::UVec4(100800u, 233400u, 22230u, 77999u), 800u, 1u },
+ };
+
+ SSBOAtomicType testTypes[] = {
+ ATOMIC_ADD,
+ ATOMIC_MIN,
+ ATOMIC_MAX,
+ ATOMIC_AND,
+ ATOMIC_OR,
+ ATOMIC_XOR,
+ ATOMIC_EXCHANGE,
+ ATOMIC_COMPSWAP
+ };
+
+ glu::ShaderType shaderTypes[] = {
+ glu::SHADERTYPE_FRAGMENT,
+ glu::SHADERTYPE_COMPUTE
+ };
+
+ de::Random rnd (testctx.getCommandLine().getBaseSeed());
+ de::MovePtr<tcu::TestCaseGroup> ssboAtomicTests (new tcu::TestCaseGroup(testctx, "ssbo_atomic", "Storage Buffer Atomic Tests"));
+
+ for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderTypes); ++shaderNdx)
+ {
+ const glu::ShaderType shaderType = shaderTypes[shaderNdx];
+ const std::string shaderName = getShaderTypeString(shaderType);
+ const std::string shaderDesc = "Storage Buffer Atomic Tests for shader type: " + shaderName;
+ de::MovePtr<tcu::TestCaseGroup> atomicShaderGroup (new tcu::TestCaseGroup(testctx, shaderName.c_str(), shaderDesc.c_str()));
+
+ for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++typeNdx)
+ {
+ SSBOAtomicType atomicType = testTypes[typeNdx];
+ const std::string atomicTypeStr = getSSBOAtomicTypeString(atomicType);
+ const std::string atomicDesc = "Storage Buffer Atomic Tests: " + atomicTypeStr;
+
+ de::MovePtr<tcu::TestCaseGroup> staticTests (new tcu::TestCaseGroup(testctx, "static", (atomicDesc + " with static input").c_str()));
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testData); ++ndx)
+ {
+ const std::string name = "atomic_" + atomicTypeStr + "_" + de::toString(ndx + 1);
+ const tcu::UVec4& inputValue = testData[ndx].input;
+ const deUint32& atomicArg = testData[ndx].atomicArg;
+ std::string atomicCall;
+ tcu::UVec4 refValue;
+
+ calculateAtomicOpData(atomicType, inputValue, atomicArg, atomicCall, refValue, testData[ndx].swapNdx);
+
+ ValidationDataStorage<tcu::UVec4> validationData = { refValue };
+ staticTests->addChild(new StorageBufferTestCase<tcu::UVec4>(testctx, SSBO_ATOMIC, shaderType, name.c_str(), inputValue, validationData, atomicCall));
+ }
+
+ de::MovePtr<tcu::TestCaseGroup> randomTests (new tcu::TestCaseGroup(testctx, "random", (atomicDesc + " with random input").c_str()));
+ for (int ndx = 0; ndx < RANDOM_TEST_COUNT; ndx++)
+ {
+ const std::string name = "atomic_" + atomicTypeStr + "_" + de::toString(ndx + 1);
+ deUint32 atomicArg = rnd.getUint16();
+ tcu::UVec4 inputValue (rnd.getUint16(), rnd.getUint16(), rnd.getUint16(), rnd.getUint16());
+ tcu::UVec4 refValue;
+ std::string atomicCall;
+
+ calculateAtomicOpData(atomicType, inputValue, atomicArg, atomicCall, refValue, ndx);
+
+ ValidationDataStorage<tcu::UVec4> validationData = { refValue };
+ randomTests->addChild(new StorageBufferTestCase<tcu::UVec4>(testctx, SSBO_ATOMIC, shaderType, name.c_str(), inputValue, validationData, atomicCall));
+
+ }
+
+ de::MovePtr<tcu::TestCaseGroup> atomicTests (new tcu::TestCaseGroup(testctx, atomicTypeStr.c_str(), atomicDesc.c_str()));
+ atomicTests->addChild(staticTests.release());
+ atomicTests->addChild(randomTests.release());
+ atomicShaderGroup->addChild(atomicTests.release());
+ }
+ ssboAtomicTests->addChild(atomicShaderGroup.release());
+ }
+
+ return ssboAtomicTests.release();
+}
+
+} // ProtectedMem
+} // vkt
--- /dev/null
+#ifndef _VKTPROTECTEDMEMSTORAGEBUFFERTESTS_HPP
+#define _VKTPROTECTEDMEMSTORAGEBUFFERTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 The Khronos Group Inc.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * 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 Protected memory storage buffer tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace ProtectedMem
+{
+
+tcu::TestCaseGroup* createReadStorageBufferTests (tcu::TestContext& testCtx);
+tcu::TestCaseGroup* createWriteStorageBufferTests (tcu::TestContext& testCtx);
+tcu::TestCaseGroup* createAtomicStorageBufferTests (tcu::TestContext& testCtx);
+
+} // ProtectedMem
+} // vkt
+
+#endif // _VKTPROTECTEDMEMSTORAGEBUFFERTESTS_HPP
#include "vktProtectedMemFillUpdateCopyBufferTests.hpp"
#include "vktProtectedMemCopyImageToBufferTests.hpp"
#include "vktProtectedMemCopyBufferToImageTests.hpp"
+#include "vktProtectedMemStorageBufferTests.hpp"
namespace vkt
{
protectedTests->addChild(bufferTestGroup.release());
}
+ // Storage buffer test case group
+ {
+ de::MovePtr<tcu::TestCaseGroup> ssboTestGroup (new tcu::TestCaseGroup(testCtx, "ssbo", "Storage Buffer Tests"));
+ ssboTestGroup->addChild(createReadStorageBufferTests(testCtx));
+ ssboTestGroup->addChild(createWriteStorageBufferTests(testCtx));
+ ssboTestGroup->addChild(createAtomicStorageBufferTests(testCtx));
+ protectedTests->addChild(ssboTestGroup.release());
+ }
return protectedTests.release();
}
return vk::createCommandPool(vk, device, poolFlags, queueFamilyIdx);
}
+vk::Move<vk::VkPipeline> makeGraphicsPipeline (const vk::DeviceInterface& vk,
+ const vk::VkDevice device,
+ const vk::VkPipelineLayout pipelineLayout,
+ const vk::VkRenderPass renderPass,
+ const vk::VkShaderModule vertexShaderModule,
+ const vk::VkShaderModule fragmentShaderModule,
+ const VertexBindings& vertexBindings,
+ const VertexAttribs& vertexAttribs,
+ const tcu::UVec2& renderSize,
+ const vk::VkPrimitiveTopology topology)
+{
+ const vk::VkPipelineShaderStageCreateInfo shaderStageParams[2] =
+ {
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
+ vertexShaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
+ },
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
+ fragmentShaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
+ }
+ };
+ const vk::VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
+ (deUint32)vertexBindings.size(), // deUint32 bindingCount;
+ vertexBindings.data(), // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ (deUint32)vertexAttribs.size(), // deUint32 attributeCount;
+ vertexAttribs.data() // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ };
+ const vk::VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
+ topology, // VkPrimitiveTopology topology;
+ VK_FALSE // VkBool32 primitiveRestartEnable;
+ };
+ const vk::VkViewport viewport =
+ {
+ 0.0f, // float originX;
+ 0.0f, // float originY;
+ (float)renderSize.x(), // float width;
+ (float)renderSize.y(), // float height;
+ 0.0f, // float minDepth;
+ 1.0f // float maxDepth;
+ };
+ const vk::VkRect2D scissor =
+ {
+ { 0, 0 }, // VkOffset2D offset;
+ { renderSize.x(), renderSize.y() } // VkExtent2D extent;
+ };
+ const vk::VkPipelineViewportStateCreateInfo viewportStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
+ 1u, // deUint32 viewportCount;
+ &viewport, // const VkViewport* pViewports;
+ 1u, // deUint32 scissorsCount;
+ &scissor, // const VkRect2D* pScissors;
+ };
+ const vk::VkPipelineRasterizationStateCreateInfo rasterStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
+ VK_FALSE, // VkBool32 depthClipEnable;
+ VK_FALSE, // VkBool32 rasterizerDiscardEnable;
+ vk::VK_POLYGON_MODE_FILL, // VkFillMode fillMode;
+ vk::VK_CULL_MODE_NONE, // VkCullMode cullMode;
+ vk::VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
+ VK_FALSE, // VkBool32 depthBiasEnable;
+ 0.0f, // float depthBias;
+ 0.0f, // float depthBiasClamp;
+ 0.0f, // float slopeScaledDepthBias;
+ 1.0f, // float lineWidth;
+ };
+ const vk::VkPipelineMultisampleStateCreateInfo multisampleStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
+ vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
+ VK_FALSE, // VkBool32 sampleShadingEnable;
+ 0.0f, // float minSampleShading;
+ DE_NULL, // const VkSampleMask* pSampleMask;
+ VK_FALSE, // VkBool32 alphaToCoverageEnable;
+ VK_FALSE // VkBool32 alphaToOneEnable;
+ };
+ const vk::VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
+ {
+ VK_FALSE, // VkBool32 blendEnable;
+ vk::VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor;
+ vk::VK_BLEND_FACTOR_ZERO, // VkBlend destBlendColor;
+ vk::VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
+ vk::VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha;
+ vk::VK_BLEND_FACTOR_ZERO, // VkBlend destBlendAlpha;
+ vk::VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
+ (vk::VK_COLOR_COMPONENT_R_BIT |
+ vk::VK_COLOR_COMPONENT_G_BIT |
+ vk::VK_COLOR_COMPONENT_B_BIT |
+ vk::VK_COLOR_COMPONENT_A_BIT), // VkChannelFlags channelWriteMask;
+ };
+ const vk::VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
+ VK_FALSE, // VkBool32 logicOpEnable;
+ vk::VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
+ 1u, // deUint32 attachmentCount;
+ &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
+ { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4];
+ };
+ const vk::VkGraphicsPipelineCreateInfo graphicsPipelineParams =
+ {
+ vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (vk::VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
+ 2u, // deUint32 stageCount;
+ shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
+ &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
+ &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
+ &rasterStateParams, // const VkPipelineRasterStateCreateInfo* pRasterState;
+ &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ (const vk::VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
+ pipelineLayout, // VkPipelineLayout layout;
+ renderPass, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
+ 0u, // VkPipeline basePipelineHandle;
+ 0u // deInt32 basePipelineIndex;
+ };
+ return vk::createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineParams);
+}
+
} // ProtectedMem
} // vkt
#include "vkPlatform.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkImageWithMemory.hpp"
+#include "tcuVector.hpp"
namespace vkt
{
PROTECTION_ENABLED = 1,
};
+typedef std::vector<vk::VkVertexInputBindingDescription> VertexBindings;
+typedef std::vector<vk::VkVertexInputAttributeDescription> VertexAttribs;
+
vk::Move<vk::VkInstance> makeProtectedMemInstance (const vk::PlatformInterface& vkp,
bool isValidationEnabled);
deUint32 chooseProtectedMemQueueFamilyIndex (const vk::InstanceDriver& vkd,
ProtectionMode protectionMode,
const deUint32 queueFamilyIdx);
+
+vk::Move<vk::VkPipeline> makeGraphicsPipeline (const vk::DeviceInterface& vk,
+ const vk::VkDevice device,
+ const vk::VkPipelineLayout pipelineLayout,
+ const vk::VkRenderPass renderPass,
+ const vk::VkShaderModule vertexShaderModule,
+ const vk::VkShaderModule fragmentShaderModule,
+ const VertexBindings& vertexBindings,
+ const VertexAttribs& vertexAttribs,
+ const tcu::UVec2& renderSize,
+ const vk::VkPrimitiveTopology topology);
+
} // ProtectedMem
} // vkt
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_8
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_9
dEQP-VK.protected_memory.buffer.copy_image_to_float_buffer.primary.random.copy_10
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.static.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_7
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_8
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_9
+dEQP-VK.protected_memory.ssbo.ssbo_read.fragment.random.read_10
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.static.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_1
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_2
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_3
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_4
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_5
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_6
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_7
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_8
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_9
+dEQP-VK.protected_memory.ssbo.ssbo_read.compute.random.read_10
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.static.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_7
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_8
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_9
+dEQP-VK.protected_memory.ssbo.ssbo_write.fragment.random.write_10
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.static.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_1
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_2
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_3
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_4
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_5
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_6
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_7
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_8
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_9
+dEQP-VK.protected_memory.ssbo.ssbo_write.compute.random.write_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.static.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.add.random.atomic_add_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.static.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.min.random.atomic_min_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.static.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.max.random.atomic_max_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.static.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.and.random.atomic_and_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.static.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.or.random.atomic_or_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.static.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.xor.random.atomic_xor_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.static.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.exchange.random.atomic_exchange_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.static.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.fragment.compswap.random.atomic_compswap_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.static.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.add.random.atomic_add_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.static.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.min.random.atomic_min_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.static.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.max.random.atomic_max_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.static.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.and.random.atomic_and_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.static.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.or.random.atomic_or_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.static.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.xor.random.atomic_xor_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.static.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.exchange.random.atomic_exchange_10
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.static.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_1
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_2
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_3
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_4
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_5
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_6
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_7
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_8
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_9
+dEQP-VK.protected_memory.ssbo.ssbo_atomic.compute.compswap.random.atomic_compswap_10
projects / platform / upstream / VK-GL-CTS.git / commitdiff