New tests for VK_KHR_synchronization2
authorPiotr Byszewski <piotr.byszewski@mobica.com>
Fri, 3 Jul 2020 10:26:21 +0000 (12:26 +0200)
committerAlexander Galazin <Alexander.Galazin@arm.com>
Tue, 16 Feb 2021 08:20:46 +0000 (08:20 +0000)
This change adds none_stage tests that exercise PIPELINE_STAGE_NONE
as well as MEMORY_ACCESS_READ|WRITE_BIT and new generic layouts.

Event tests were also extends to test GPU-only scenarios using new
VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR.

Components: Vulkan

VK-GL-CTS issue: 2365

New tests:
dEQP-VK.synchronization2.basic.event.*_device_only
dEQP-VK.synchronization2.none_stage.*

Affects:
dEQP-VK.synchronization*

Change-Id: I86e056054a6541526140fd15fb53bef9359b6b28

AndroidGen.mk
android/cts/master/vk-master-2020-03-01.txt
android/cts/master/vk-master.txt
external/vulkancts/modules/vulkan/synchronization/CMakeLists.txt
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.cpp [new file with mode: 0644]
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.hpp [new file with mode: 0644]
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationTests.cpp
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp
external/vulkancts/mustpass/master/vk-default.txt

index 42ba368..f00dc29 100644 (file)
@@ -424,6 +424,7 @@ LOCAL_SRC_FILES := \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicSemaphoreTests.cpp \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationInternallySynchronizedObjectsTests.cpp \
+       external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.cpp \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperation.cpp \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationMultiQueueTests.cpp \
        external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp \
index 5e813c1..2154d4a 100644 (file)
@@ -244968,10 +244968,229 @@ dEQP-VK.synchronization2.timeline_semaphore.wait.one_signal_from_host
 dEQP-VK.synchronization2.timeline_semaphore.wait.host_wait_before_signal
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_device
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_host
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.general_to_general
+dEQP-VK.synchronization2.none_stage.general_to_shader_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_general_to_general
+dEQP-VK.synchronization2.none_stage.old_access_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_general_to_general
+dEQP-VK.synchronization2.none_stage.legacy_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_depth_stencil_read
 dEQP-VK.synchronization2.basic.event.device_set_reset
 dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer
+dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer_device_only
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.multi_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue_typed
index ed5b16c..9fba3ab 100644 (file)
@@ -606836,10 +606836,229 @@ dEQP-VK.synchronization2.timeline_semaphore.wait.one_signal_from_host
 dEQP-VK.synchronization2.timeline_semaphore.wait.host_wait_before_signal
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_device
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_host
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.general_to_general
+dEQP-VK.synchronization2.none_stage.general_to_shader_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_general_to_general
+dEQP-VK.synchronization2.none_stage.old_access_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_general_to_general
+dEQP-VK.synchronization2.none_stage.legacy_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_depth_stencil_read
 dEQP-VK.synchronization2.basic.event.device_set_reset
 dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer
+dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer_device_only
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.multi_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue_typed
index d012279..440d413 100644 (file)
@@ -29,6 +29,8 @@ set(DEQP_VK_SYNCHRONIZATION_SRCS
        vktSynchronizationCrossInstanceSharingTests.hpp
        vktSynchronizationTimelineSemaphoreTests.cpp
        vktSynchronizationTimelineSemaphoreTests.hpp
+       vktSynchronizationNoneStageTests.cpp
+       vktSynchronizationNoneStageTests.hpp
        vktSynchronizationSignalOrderTests.cpp
        vktSynchronizationSignalOrderTests.hpp
        vktSynchronizationWin32KeyedMutexTests.cpp
index eb7a0d2..d4a92d3 100644 (file)
@@ -41,6 +41,12 @@ using namespace vk;
 #define SHORT_FENCE_WAIT       1000ull
 #define LONG_FENCE_WAIT                ~0ull
 
+struct TestConfig
+{
+       SynchronizationType             type;
+       VkEventCreateFlags              flags;
+};
+
 tcu::TestStatus hostResetSetEventCase (Context& context)
 {
        const DeviceInterface&          vk                      = context.getDeviceInterface();
@@ -77,7 +83,7 @@ tcu::TestStatus hostResetSetEventCase (Context& context)
        return tcu::TestStatus::pass("Tests set and reset event on host pass");
 }
 
-tcu::TestStatus deviceResetSetEventCase (Context& context, SynchronizationType type)
+tcu::TestStatus deviceResetSetEventCase (Context& context, TestConfig config)
 {
        const DeviceInterface&                          vk                                              = context.getDeviceInterface();
        const VkDevice                                          device                                  = context.getDevice();
@@ -99,7 +105,7 @@ tcu::TestStatus deviceResetSetEventCase (Context& context, SynchronizationType t
        VkDependencyInfoKHR                                     dependencyInfo                  = makeCommonDependencyInfo(&memoryBarrier2);
 
        {
-               SynchronizationWrapperPtr synchronizationWrapper = getSynchronizationWrapper(type, vk, DE_FALSE);
+               SynchronizationWrapperPtr synchronizationWrapper = getSynchronizationWrapper(config.type, vk, DE_FALSE);
 
                beginCommandBuffer(vk, *cmdBuffer);
                synchronizationWrapper->cmdSetEvent(*cmdBuffer, *event, &dependencyInfo);
@@ -123,7 +129,7 @@ tcu::TestStatus deviceResetSetEventCase (Context& context, SynchronizationType t
                return tcu::TestStatus::fail("Event should be in signaled state after set");
 
        {
-               SynchronizationWrapperPtr synchronizationWrapper = getSynchronizationWrapper(type, vk, DE_FALSE);
+               SynchronizationWrapperPtr synchronizationWrapper = getSynchronizationWrapper(config.type, vk, DE_FALSE);
 
                beginCommandBuffer(vk, *cmdBuffer);
                synchronizationWrapper->cmdResetEvent(*cmdBuffer, *event, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR);
@@ -149,7 +155,7 @@ tcu::TestStatus deviceResetSetEventCase (Context& context, SynchronizationType t
        return tcu::TestStatus::pass("Device set and reset event tests pass");
 }
 
-tcu::TestStatus singleSubmissionCase (Context& context, SynchronizationType type)
+tcu::TestStatus singleSubmissionCase (Context& context, TestConfig config)
 {
        enum {SET=0, WAIT, COUNT};
        const DeviceInterface&                  vk                                                      = context.getDeviceInterface();
@@ -160,13 +166,13 @@ tcu::TestStatus singleSubmissionCase (Context& context, SynchronizationType type
        const Unique<VkCommandPool>             cmdPool                                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
        const Move<VkCommandBuffer>             ptrCmdBuffer[COUNT]                     = { makeCommandBuffer(vk, device, *cmdPool), makeCommandBuffer(vk, device, *cmdPool) };
        VkCommandBuffer                                 cmdBuffers[COUNT]                       = {*ptrCmdBuffer[SET], *ptrCmdBuffer[WAIT]};
-       const Unique<VkEvent>                   event                                           (createEvent(vk, device));
+       const Unique<VkEvent>                   event                                           (createEvent(vk, device, config.flags));
        VkCommandBufferSubmitInfoKHR    commandBufferSubmitInfo[]       {
                                                                                                                                        makeCommonCommandBufferSubmitInfo(cmdBuffers[SET]),
                                                                                                                                        makeCommonCommandBufferSubmitInfo(cmdBuffers[WAIT])
                                                                                                                                };
        VkDependencyInfoKHR                             dependencyInfo                          = makeCommonDependencyInfo();
-       SynchronizationWrapperPtr               synchronizationWrapper          = getSynchronizationWrapper(type, vk, DE_FALSE);
+       SynchronizationWrapperPtr               synchronizationWrapper          = getSynchronizationWrapper(config.type, vk, DE_FALSE);
 
        synchronizationWrapper->addSubmitInfo(
                0u,                                                                             // deUint32                                                             waitSemaphoreInfoCount
@@ -193,7 +199,7 @@ tcu::TestStatus singleSubmissionCase (Context& context, SynchronizationType type
        return tcu::TestStatus::pass("Wait and set even on device single submission tests pass");
 }
 
-tcu::TestStatus multiSubmissionCase(Context& context, SynchronizationType type)
+tcu::TestStatus multiSubmissionCase(Context& context, TestConfig config)
 {
        enum { SET = 0, WAIT, COUNT };
        const DeviceInterface&                  vk                                      = context.getDeviceInterface();
@@ -205,7 +211,7 @@ tcu::TestStatus multiSubmissionCase(Context& context, SynchronizationType type)
        const Unique<VkCommandPool>             cmdPool                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
        const Move<VkCommandBuffer>             ptrCmdBuffer[COUNT] = { makeCommandBuffer(vk, device, *cmdPool), makeCommandBuffer(vk, device, *cmdPool) };
        VkCommandBuffer                                 cmdBuffers[COUNT]       = { *ptrCmdBuffer[SET], *ptrCmdBuffer[WAIT] };
-       const Unique<VkEvent>                   event                           (createEvent(vk, device));
+       const Unique<VkEvent>                   event                           (createEvent(vk, device, config.flags));
        VkCommandBufferSubmitInfoKHR    commandBufferSubmitInfo[] =
        {
                makeCommonCommandBufferSubmitInfo(cmdBuffers[SET]),
@@ -213,8 +219,8 @@ tcu::TestStatus multiSubmissionCase(Context& context, SynchronizationType type)
        };
        SynchronizationWrapperPtr               synchronizationWrapper[] =
        {
-               getSynchronizationWrapper(type, vk, DE_FALSE),
-               getSynchronizationWrapper(type, vk, DE_FALSE)
+               getSynchronizationWrapper(config.type, vk, DE_FALSE),
+               getSynchronizationWrapper(config.type, vk, DE_FALSE)
        };
        VkDependencyInfoKHR                             dependencyInfos[] =
        {
@@ -257,7 +263,7 @@ tcu::TestStatus multiSubmissionCase(Context& context, SynchronizationType type)
        return tcu::TestStatus::pass("Wait and set even on device multi submission tests pass");
 }
 
-tcu::TestStatus secondaryCommandBufferCase (Context& context, SynchronizationType type)
+tcu::TestStatus secondaryCommandBufferCase (Context& context, TestConfig config)
 {
        enum {SET=0, WAIT, COUNT};
        const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
@@ -277,7 +283,7 @@ tcu::TestStatus secondaryCommandBufferCase (Context& context, SynchronizationTyp
                                                                                                                                        };
        const Move<VkCommandBuffer>                             prtCmdBuffers[COUNT]    = {allocateCommandBuffer (vk, device, &cmdBufferInfo), allocateCommandBuffer (vk, device, &cmdBufferInfo)};
        VkCommandBuffer                                                 secondaryCmdBuffers[]   = {*prtCmdBuffers[SET], *prtCmdBuffers[WAIT]};
-       const Unique<VkEvent>                                   event                                   (createEvent(vk, device));
+       const Unique<VkEvent>                                   event                                   (createEvent(vk, device, config.flags));
 
        const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
                                                                                                                                        {
@@ -303,7 +309,7 @@ tcu::TestStatus secondaryCommandBufferCase (Context& context, SynchronizationTyp
                                                                                                                                                makeCommonDependencyInfo(),
                                                                                                                                                makeCommonDependencyInfo()
                                                                                                                                        };
-       SynchronizationWrapperPtr                               synchronizationWrapper  = getSynchronizationWrapper(type, vk, DE_FALSE);
+       SynchronizationWrapperPtr                               synchronizationWrapper  = getSynchronizationWrapper(config.type, vk, DE_FALSE);
 
        synchronizationWrapper->addSubmitInfo(
                0u,                                                                             // deUint32                                                             waitSemaphoreInfoCount
@@ -334,9 +340,9 @@ tcu::TestStatus secondaryCommandBufferCase (Context& context, SynchronizationTyp
        return tcu::TestStatus::pass("Wait and set even on device using secondary command buffers tests pass");
 }
 
-void checkSupport(Context& context, const SynchronizationType type)
+void checkSupport(Context& context, TestConfig config)
 {
-       if (type == SynchronizationType::SYNCHRONIZATION2)
+       if (config.type == SynchronizationType::SYNCHRONIZATION2)
                context.requireDeviceFunctionality("VK_KHR_synchronization2");
 }
 
@@ -344,27 +350,42 @@ void checkSupport(Context& context, const SynchronizationType type)
 
 tcu::TestCaseGroup* createBasicEventTests (tcu::TestContext& testCtx)
 {
-       const SynchronizationType                       type            (SynchronizationType::LEGACY);
-       de::MovePtr<tcu::TestCaseGroup>         basicTests      (new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
+       TestConfig config
+       {
+               SynchronizationType::LEGACY,
+               0U
+       };
+
+       de::MovePtr<tcu::TestCaseGroup> basicTests (new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
 
        addFunctionCase(basicTests.get(), "host_set_reset", "Basic event tests set and reset on host", hostResetSetEventCase);
-       addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", checkSupport, deviceResetSetEventCase, type);
-       addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", checkSupport, singleSubmissionCase, type);
-       addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", checkSupport, multiSubmissionCase, type);
-       addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", checkSupport, secondaryCommandBufferCase, type);
+       addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", checkSupport, deviceResetSetEventCase, config);
+       addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", checkSupport, singleSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", checkSupport, multiSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", checkSupport, secondaryCommandBufferCase, config);
 
        return basicTests.release();
 }
 
 tcu::TestCaseGroup* createSynchronization2BasicEventTests (tcu::TestContext& testCtx)
 {
-       const SynchronizationType                       type            (SynchronizationType::SYNCHRONIZATION2);
-       de::MovePtr<tcu::TestCaseGroup>         basicTests      (new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
+       TestConfig config
+       {
+               SynchronizationType::SYNCHRONIZATION2,
+               0U
+       };
+
+       de::MovePtr<tcu::TestCaseGroup> basicTests (new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
+
+       addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", checkSupport, deviceResetSetEventCase, config);
+       addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", checkSupport, singleSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", checkSupport, multiSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", checkSupport, secondaryCommandBufferCase, config);
 
-       addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", checkSupport, deviceResetSetEventCase, type);
-       addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", checkSupport, singleSubmissionCase, type);
-       addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", checkSupport, multiSubmissionCase, type);
-       addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", checkSupport, secondaryCommandBufferCase, type);
+       config.flags = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR;
+       addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer_device_only", "Wait and set GPU-only event single submission", checkSupport, singleSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer_device_only", "Wait and set GPU-only event mutli submission", checkSupport, multiSubmissionCase, config);
+       addFunctionCase(basicTests.get(), "multi_secondary_command_buffer_device_only", "GPU-only event used on secondary command buffer ", checkSupport, secondaryCommandBufferCase, config);
 
        return basicTests.release();
 
diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.cpp
new file mode 100644 (file)
index 0000000..ccbae55
--- /dev/null
@@ -0,0 +1,1453 @@
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2020 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 vktSynchronizationNoneStageTests.cpp
+ * \brief Tests for VK_PIPELINE_STAGE_NONE{_2}_KHR that iterate over each writable layout
+                 and over each readable layout. Data to tested image is writen using method
+                 appropriate for the writable layout and read via readable layout appropriate method.
+                 Betwean read and write operation there are bariers that use none stage.
+                 Implemented tests are also testing generalized layouts (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,
+                 VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR) and access flags (MEMORY_ACCESS_READ|WRITE_BIT) to
+                 test contextual synchronization introduced with VK_KHR_synchronization2 extension.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktSynchronizationNoneStageTests.hpp"
+#include "vktSynchronizationOperation.hpp"
+#include "vktSynchronizationUtil.hpp"
+#include "vktTestCase.hpp"
+
+#include "vkBuilderUtil.hpp"
+#include "vkBarrierUtil.hpp"
+#include "vkImageUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkObjUtil.hpp"
+
+#include "tcuImageCompare.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuStringTemplate.hpp"
+
+#include "deUniquePtr.hpp"
+
+#include <vector>
+
+namespace vkt
+{
+namespace synchronization
+{
+
+using namespace vk;
+using namespace de;
+using namespace tcu;
+
+namespace
+{
+
+static const deUint32 IMAGE_ASPECT_DEPTH_STENCIL       = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+static const deUint32 IMAGE_ASPECT_ALL                         = 0u;
+
+struct TestParams
+{
+       SynchronizationType             type;
+       bool                                    useGenericAccessFlags;
+       VkImageLayout                   writeLayout;
+       VkImageAspectFlags              writeAspect;
+       VkImageLayout                   readLayout;
+       VkImageAspectFlags              readAspect;
+};
+
+// Helper class representing image
+class ImageWrapper
+{
+public:
+
+                       ImageWrapper    () = default;
+       void    create                  (Context& context, SimpleAllocator& alloc, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage);
+
+public:
+       Move<VkImage>                   handle;
+       MovePtr<Allocation>             memory;
+};
+
+void ImageWrapper::create(Context& context, SimpleAllocator& alloc, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage)
+{
+       const DeviceInterface&  vk                                      = context.getDeviceInterface();
+       const VkDevice&                 device                          = context.getDevice();
+       const deUint32                  queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
+       const VkImageCreateInfo imageParams
+       {
+               VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // sType
+               DE_NULL,                                                                // pNext
+               0u,                                                                             // flags
+               VK_IMAGE_TYPE_2D,                                               // imageType
+               format,                                                                 // format
+               extent,                                                                 // extent
+               1u,                                                                             // mipLevels
+               1u,                                                                             // arraySize
+               VK_SAMPLE_COUNT_1_BIT,                                  // samples
+               VK_IMAGE_TILING_OPTIMAL,                                // tiling
+               usage,                                                                  // usage
+               VK_SHARING_MODE_EXCLUSIVE,                              // sharingMode
+               1u,                                                                             // queueFamilyIndexCount
+               &queueFamilyIndex,                                              // pQueueFamilyIndices
+               VK_IMAGE_LAYOUT_UNDEFINED,                              // initialLayout
+       };
+
+       handle = createImage(vk, device, &imageParams);
+       memory = alloc.allocate(getImageMemoryRequirements(vk, device, *handle), MemoryRequirement::Any);
+
+       vk.bindImageMemory(device, *handle, memory->getMemory(), memory->getOffset());
+}
+
+// Helper class representing buffer
+class BufferWrapper
+{
+public:
+
+                       BufferWrapper   () = default;
+       void    create                  (Context& context, SimpleAllocator& alloc, VkDeviceSize size, VkBufferUsageFlags usage);
+
+public:
+       Move<VkBuffer>                  handle;
+       MovePtr<Allocation>             memory;
+};
+
+void BufferWrapper::create(Context& context, SimpleAllocator& alloc, VkDeviceSize size, VkBufferUsageFlags usage)
+{
+       const DeviceInterface&          vk                                      = context.getDeviceInterface();
+       const VkDevice&                         device                          = context.getDevice();
+       const VkBufferCreateInfo        bufferCreateInfo        = makeBufferCreateInfo(size, usage);
+
+       handle = createBuffer(vk, device, &bufferCreateInfo);
+       memory = alloc.allocate(getBufferMemoryRequirements(vk, device, *handle), MemoryRequirement::HostVisible);
+
+       VK_CHECK(vk.bindBufferMemory(device, *handle, memory->getMemory(), memory->getOffset()));
+}
+
+class NoneStageTestInstance : public vkt::TestInstance
+{
+public:
+                                                                       NoneStageTestInstance                   (Context&                       context,
+                                                                                                                                        const TestParams&      testParams);
+       virtual                                                 ~NoneStageTestInstance                  (void) = default;
+
+       tcu::TestStatus                                 iterate                                                 (void) override;
+
+protected:
+
+       VkAccessFlags2KHR                               getAccessFlag                                   (VkAccessFlags2KHR                                      access);
+       VkBufferImageCopy                               buildCopyRegion                                 (VkExtent3D                                                     extent,
+                                                                                                                                        VkImageAspectFlags                                     aspect);
+       void                                                    buildVertexBuffer                               (void);
+       Move<VkRenderPass>                              buildBasicRenderPass                    (VkFormat                                                       outputFormat,
+                                                                                                                                        VkImageLayout                                          outputLayout,
+                                                                                                                                        VkAttachmentLoadOp                                     loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE);
+       Move<VkRenderPass>                              buildComplexRenderPass                  (VkFormat                                                       intermediateFormat,
+                                                                                                                                        VkImageLayout                                          intermediateLayout,
+                                                                                                                                        VkFormat                                                       outputFormat,
+                                                                                                                                        VkImageLayout                                          outputLayout);
+       Move<VkImageView>                               buildImageView                                  (VkImage                                                        image,
+                                                                                                                                        VkFormat                                                       format,
+                                                                                                                                        const VkImageSubresourceRange&         subresourceRange);
+       Move<VkFramebuffer>                             buildFramebuffer                                (VkRenderPass                                           renderPass,
+                                                                                                                                        const VkImageView*                                     outView1,
+                                                                                                                                        const VkImageView*                                     outView2 = DE_NULL);
+       Move<VkSampler>                                 buildSampler                                    (void);
+       Move<VkDescriptorSetLayout>             buildDescriptorSetLayout                (VkDescriptorType                                       descriptorType);
+       Move<VkDescriptorPool>                  buildDescriptorPool                             (VkDescriptorType                                       descriptorType);
+       Move<VkDescriptorSet>                   buildDescriptorSet                              (VkDescriptorPool                                       descriptorPool,
+                                                                                                                                        VkDescriptorSetLayout                          descriptorSetLayout,
+                                                                                                                                        VkDescriptorType                                       descriptorType,
+                                                                                                                                        VkImageView                                            inputView,
+                                                                                                                                        VkImageLayout                                          inputLayout,
+                                                                                                                                        const VkSampler*                                       sampler = DE_NULL);
+       Move<VkPipeline>                                buildPipeline                                   (deUint32                                                       subpass,
+                                                                                                                                        VkImageAspectFlags                                     resultAspect,
+                                                                                                                                        VkPipelineLayout                                       pipelineLayout,
+                                                                                                                                        VkShaderModule                                         vertShaderModule,
+                                                                                                                                        VkShaderModule                                         fragShaderModule,
+                                                                                                                                        VkRenderPass                                           renderPass);
+       bool                                                    verifyResult                                    (const PixelBufferAccess&                       reference,
+                                                                                                                                        const PixelBufferAccess&                       result);
+
+private:
+
+       const TestParams                                m_testParams;
+
+       VkFormat                                                m_referenceImageFormat;
+       VkFormat                                                m_transitionImageFormat;
+       VkFormat                                                m_readImageFormat;
+       VkImageSubresourceRange                 m_referenceSubresourceRange;
+       VkImageSubresourceRange                 m_transitionSubresourceRange;
+       VkImageSubresourceRange                 m_readSubresourceRange;
+       VkImageAspectFlags                              m_transitionImageAspect;
+
+       VkExtent3D                                              m_imageExtent;
+       VkImageLayout                                   m_writeRenderPassOutputLayout;
+
+       // flag indicating that graphics pipeline is constructed to write data to tested image
+       bool                                                    m_usePipelineToWrite;
+
+       // flag indicating that graphics pipeline is constructed to read data from tested image
+       bool                                                    m_usePipelineToRead;
+
+       // flag indicating that write pipeline should be constructed in a special way to fill stencil buffer
+       bool                                                    m_useStencilDuringWrite;
+
+       // flag indicating that read pipeline should be constructed in a special way to use input attachment as a data source
+       bool                                                    m_useInputAttachmentToRead;
+
+       VkPipelineStageFlags2KHR                m_srcStageToNoneStageMask;
+       VkAccessFlags2KHR                               m_srcAccessToNoneAccessMask;
+       VkPipelineStageFlags2KHR                m_dstStageFromNoneStageMask;
+       VkAccessFlags2KHR                               m_dstAccessFromNoneAccessMask;
+
+       SimpleAllocator                                 m_alloc;
+
+       ImageWrapper                                    m_referenceImage;
+       VkImageUsageFlags                               m_referenceImageUsage;
+
+       // objects/variables initialized only when needed
+       ImageWrapper                                    m_imageToWrite;
+       VkImageUsageFlags                               m_imageToWriteUsage;
+
+       ImageWrapper                                    m_imageToRead;
+
+       BufferWrapper                                   m_vertexBuffer;
+       std::vector<Move<VkImageView> > m_attachmentViews;
+
+       std::string                                             m_writeFragShaderName;
+       Move<VkShaderModule>                    m_writeVertShaderModule;
+       Move<VkShaderModule>                    m_writeFragShaderModule;
+       Move<VkRenderPass>                              m_writeRenderPass;
+       Move<VkSampler>                                 m_writeSampler;
+       Move<VkDescriptorSetLayout>             m_writeDescriptorSetLayout;
+       Move<VkDescriptorPool>                  m_writeDescriptorPool;
+       Move<VkDescriptorSet>                   m_writeDescriptorSet;
+       Move<VkPipelineLayout>                  m_writePipelineLayout;
+       Move<VkPipeline>                                m_writePipeline;
+       Move<VkFramebuffer>                             m_writeFramebuffer;
+
+       std::string                                             m_readFragShaderName;
+       Move<VkShaderModule>                    m_readVertShaderModule;
+       Move<VkShaderModule>                    m_readFragShaderModule;
+       Move<VkShaderModule>                    m_readFragShaderModule2;
+       Move<VkRenderPass>                              m_readRenderPass;
+       Move<VkSampler>                                 m_readSampler;
+       Move<VkDescriptorSetLayout>             m_readDescriptorSetLayout;
+       Move<VkDescriptorPool>                  m_readDescriptorPool;
+       Move<VkDescriptorSet>                   m_readDescriptorSet;
+       Move<VkPipelineLayout>                  m_readPipelineLayout;
+       Move<VkPipeline>                                m_readPipeline;
+       Move<VkFramebuffer>                             m_readFramebuffer;
+};
+
+NoneStageTestInstance::NoneStageTestInstance(Context& context, const TestParams& testParams)
+       : vkt::TestInstance(context)
+       , m_testParams          (testParams)
+       , m_imageExtent         { 32, 32, 1 }
+       , m_alloc                       (m_context.getDeviceInterface(),
+               m_context.getDevice(),
+               getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()))
+{
+       // note: for clarity whole configuration of whats going on in iterate method was moved here
+
+       const auto writeLayout  = m_testParams.writeLayout;
+       const auto writeAspect  = m_testParams.writeAspect;
+       const auto readLayout   = m_testParams.readLayout;
+       const auto readAspect   = m_testParams.readAspect;
+
+       // select format that will be used for test
+       if ((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) || (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT))
+       {
+               m_transitionImageFormat                 = VK_FORMAT_D32_SFLOAT;
+               m_transitionImageAspect                 = VK_IMAGE_ASPECT_DEPTH_BIT;
+               m_writeRenderPassOutputLayout   = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+       }
+       else if ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) || (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT))
+       {
+               m_transitionImageFormat                 = VK_FORMAT_S8_UINT;
+               m_transitionImageAspect                 = VK_IMAGE_ASPECT_STENCIL_BIT;
+               m_writeRenderPassOutputLayout   = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
+       }
+       else if ((writeAspect == IMAGE_ASPECT_DEPTH_STENCIL) || (readAspect == IMAGE_ASPECT_DEPTH_STENCIL))
+       {
+               m_transitionImageFormat                 = VK_FORMAT_D24_UNORM_S8_UINT;
+               // note: in test we focus only on depth aspect; no need to check both in those cases
+               m_transitionImageAspect                 = VK_IMAGE_ASPECT_DEPTH_BIT;
+               m_writeRenderPassOutputLayout   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+       }
+       else
+       {
+               m_transitionImageFormat                 = VK_FORMAT_R8G8B8A8_UNORM;
+               m_transitionImageAspect                 = VK_IMAGE_ASPECT_COLOR_BIT;
+               m_writeRenderPassOutputLayout   = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+       }
+
+       m_referenceSubresourceRange             = { m_transitionImageAspect, 0u, 1u, 0u, 1u };
+       m_transitionSubresourceRange    = { m_transitionImageAspect, 0u, 1u, 0u, 1u };
+       m_readSubresourceRange                  = { m_transitionImageAspect, 0u, 1u, 0u, 1u };
+       m_referenceImageFormat                  = m_transitionImageFormat;
+       m_readImageFormat                               = m_transitionImageFormat;
+       m_referenceImageUsage                   = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+       m_imageToWriteUsage                             = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+
+       // pipeline is not created for transfer and general layouts (general layouts in tests follow same path as transfer layouts)
+       m_usePipelineToWrite    = (writeLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (writeLayout != VK_IMAGE_LAYOUT_GENERAL);
+       m_usePipelineToRead             = (readLayout  != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) && (readLayout  != VK_IMAGE_LAYOUT_GENERAL);
+       m_useStencilDuringWrite = false;
+
+       m_srcStageToNoneStageMask               = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR;
+       m_srcAccessToNoneAccessMask             = getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR);
+       m_dstStageFromNoneStageMask             = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR;
+       m_dstAccessFromNoneAccessMask   = getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR);
+
+       // when graphics pipelines are not created only image with gradient is used for test
+       if (!m_usePipelineToWrite && !m_usePipelineToRead)
+       {
+               m_referenceImageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+               return;
+       }
+
+       if (m_usePipelineToWrite)
+       {
+               // depth/stencil layouts need diferent configuration
+               if (writeAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))
+               {
+                       if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT)
+                       {
+                               m_referenceImageFormat                                   = VK_FORMAT_R32_SFLOAT;
+                               m_referenceImageUsage                                   |= VK_IMAGE_USAGE_SAMPLED_BIT;
+                               m_referenceSubresourceRange.aspectMask   = VK_IMAGE_ASPECT_COLOR_BIT;
+                               m_writeFragShaderName                                    = "frag-color-to-depth";
+                       }
+                       else
+                       {
+                               m_referenceImageUsage                                    = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+                               m_useStencilDuringWrite                                  = true;
+                               m_writeFragShaderName                                    = "frag-color-to-stencil";
+                       }
+
+                       m_srcStageToNoneStageMask                = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR;
+                       m_srcAccessToNoneAccessMask              = getAccessFlag(VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR);
+                       m_imageToWriteUsage                             |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+               }
+               else
+               {
+                       m_referenceImageUsage                   |= VK_IMAGE_USAGE_SAMPLED_BIT;
+                       m_srcStageToNoneStageMask                = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR;
+                       m_srcAccessToNoneAccessMask              = getAccessFlag(VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR);
+                       m_writeFragShaderName                    = "frag-color";
+                       m_imageToWriteUsage                             |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+               }
+       }
+
+       if (m_usePipelineToRead)
+       {
+               m_dstStageFromNoneStageMask             = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR;
+               m_dstAccessFromNoneAccessMask   = getAccessFlag(VK_ACCESS_2_SHADER_READ_BIT_KHR);
+
+               m_readSubresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+               if ((readAspect | writeAspect) & VK_IMAGE_ASPECT_DEPTH_BIT)
+                       m_readImageFormat = VK_FORMAT_R32_SFLOAT;
+               else if ((readAspect | writeAspect) & VK_IMAGE_ASPECT_STENCIL_BIT)
+                       m_readImageFormat = VK_FORMAT_R8_UINT;
+
+               // for layouts that operate on depth or stencil (not depth_stencil) use input attachment to read
+               if ((readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) && (readAspect != IMAGE_ASPECT_DEPTH_STENCIL))
+               {
+                       m_useInputAttachmentToRead               = true;
+                       m_readFragShaderName                     = "frag-depth-or-stencil-to-color";
+                       m_imageToWriteUsage                             |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+                       m_dstAccessFromNoneAccessMask    = getAccessFlag(VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR);
+
+                       if (!m_usePipelineToWrite)
+                               m_referenceImageUsage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+               }
+               else // use image sampler for color and depth_stencil layouts
+               {
+                       m_useInputAttachmentToRead               = false;
+                       m_readFragShaderName                     = "frag-color";
+                       m_referenceImageUsage                   |= VK_IMAGE_USAGE_SAMPLED_BIT;
+                       m_imageToWriteUsage                             |= VK_IMAGE_USAGE_SAMPLED_BIT;
+
+                       // for depth_stencil layouts we need to have depth_stencil_attachment usage
+                       if (!m_usePipelineToWrite && (readAspect & VK_IMAGE_ASPECT_STENCIL_BIT))
+                               m_referenceImageUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+                       // when we read stencil as color we need to use usampler2D
+                       if (writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT)
+                               m_readFragShaderName             = "frag-stencil-to-color";
+               }
+       }
+}
+
+VkAccessFlags2KHR NoneStageTestInstance::getAccessFlag(VkAccessFlags2KHR access)
+{
+       if (m_testParams.useGenericAccessFlags)
+       {
+               switch (access)
+               {
+               case VK_ACCESS_2_HOST_READ_BIT_KHR:
+               case VK_ACCESS_2_TRANSFER_READ_BIT_KHR:
+               case VK_ACCESS_2_SHADER_READ_BIT_KHR:
+               case VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR:
+                       return VK_ACCESS_2_MEMORY_READ_BIT_KHR;
+
+               case VK_ACCESS_2_HOST_WRITE_BIT_KHR:
+               case VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR:
+               case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR:
+               case VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR:
+                               return VK_ACCESS_2_MEMORY_WRITE_BIT_KHR;
+
+               default:
+                       TCU_THROW(TestError, "Unhandled access flag");
+               }
+       }
+       return access;
+}
+
+VkBufferImageCopy NoneStageTestInstance::buildCopyRegion(VkExtent3D extent, VkImageAspectFlags aspect)
+{
+       return
+       {
+               0u,                                                             // VkDeviceSize                                 bufferOffset
+               extent.width,                                   // deUint32                                             bufferRowLength
+               extent.height,                                  // deUint32                                             bufferImageHeight
+               { aspect, 0u, 0u, 1u },                 // VkImageSubresourceLayers             imageSubresource
+               { 0, 0, 0 },                                    // VkOffset3D                                   imageOffset
+               extent                                                  // VkExtent3D                                   imageExtent
+       };
+}
+
+void NoneStageTestInstance::buildVertexBuffer()
+{
+       const DeviceInterface&  vk              = m_context.getDeviceInterface();
+       const VkDevice&                 device  = m_context.getDevice();
+
+       std::vector<float> vertices
+       {
+                1.0f,  1.0f, 0.0f, 1.0f,
+               -1.0f,  1.0f, 0.0f, 1.0f,
+                1.0f, -1.0f, 0.0f, 1.0f,
+               -1.0f, -1.0f, 0.0f, 1.0f,
+       };
+       m_vertexBuffer.create(m_context, m_alloc, sizeof(float) * vertices.size(), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
+
+       deMemcpy(m_vertexBuffer.memory->getHostPtr(), vertices.data(), vertices.size() * sizeof(float));
+       flushAlloc(vk, device, *m_vertexBuffer.memory);
+}
+
+Move<VkRenderPass> NoneStageTestInstance::buildBasicRenderPass(VkFormat outputFormat, VkImageLayout outputLayout, VkAttachmentLoadOp loadOp)
+{
+       // output color/depth attachment
+       VkAttachmentDescription2 attachmentDescription
+       {
+               VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,                             // VkStructureType                                      sType
+               DE_NULL,                                                                                                // const void*                                          pNext
+               (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags
+               outputFormat,                                                                                   // VkFormat                                                     format
+               VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples
+               loadOp,                                                                                                 // VkAttachmentLoadOp                           loadOp
+               VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          storeOp
+               loadOp,                                                                                                 // VkAttachmentLoadOp                           stencilLoadOp
+               VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          stencilStoreOp
+               VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                                        initialLayout
+               outputLayout                                                                                    // VkImageLayout                                        finalLayout
+       };
+
+       VkImageAspectFlags              imageAspect             = getImageAspectFlags(mapVkFormat(outputFormat));
+       VkAttachmentReference2  attachmentRef
+       {
+               VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 0u, outputLayout, imageAspect
+       };
+
+       VkAttachmentReference2* pColorAttachment                        = DE_NULL;
+       VkAttachmentReference2* pDepthStencilAttachment         = DE_NULL;
+       if (imageAspect == VK_IMAGE_ASPECT_COLOR_BIT)
+               pColorAttachment = &attachmentRef;
+       else
+               pDepthStencilAttachment = &attachmentRef;
+
+       VkSubpassDescription2 subpassDescription
+       {
+               VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
+               DE_NULL,
+               (VkSubpassDescriptionFlags)0,                                                   // VkSubpassDescriptionFlags            flags
+               VK_PIPELINE_BIND_POINT_GRAPHICS,                                                // VkPipelineBindPoint                          pipelineBindPoint
+               0u,                                                                                                             // deUint32                                                     viewMask
+               0u,                                                                                                             // deUint32                                                     inputAttachmentCount
+               DE_NULL,                                                                                                // const VkAttachmentReference2*        pInputAttachments
+               !!pColorAttachment,                                                                             // deUint32                                                     colorAttachmentCount
+               pColorAttachment,                                                                               // const VkAttachmentReference2*        pColorAttachments
+               DE_NULL,                                                                                                // const VkAttachmentReference2*        pResolveAttachments
+               pDepthStencilAttachment,                                                                // const VkAttachmentReference2*        pDepthStencilAttachment
+               0u,                                                                                                             // deUint32                                                     preserveAttachmentCount
+               DE_NULL                                                                                                 // const deUint32*                                      pPreserveAttachments
+       };
+
+       const VkRenderPassCreateInfo2 renderPassInfo
+       {
+               VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
+               DE_NULL,                                                                                                // const void*                                          pNext
+               (VkRenderPassCreateFlags)0,                                                             // VkRenderPassCreateFlags                      flags
+               1u,                                                                                                             // deUint32                                                     attachmentCount
+               &attachmentDescription,                                                                 // const VkAttachmentDescription*       pAttachments
+               1u,                                                                                                             // deUint32                                                     subpassCount
+               &subpassDescription,                                                                    // const VkSubpassDescription*          pSubpasses
+               0u,                                                                                                             // deUint32                                                     dependencyCount
+               DE_NULL,                                                                                                // const VkSubpassDependency*           pDependencies
+               0u,                                                                                                             // deUint32                                                     correlatedViewMaskCount
+               DE_NULL                                                                                                 // const deUint32*                                      pCorrelatedViewMasks
+       };
+
+       return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo);;
+}
+
+Move<VkRenderPass> NoneStageTestInstance::buildComplexRenderPass(VkFormat intermediateFormat,  VkImageLayout intermediateLayout,
+                                                                                                                                VkFormat outputFormat,                 VkImageLayout outputLayout)
+{
+       std::vector<VkAttachmentDescription2> attachmentDescriptions
+       {
+               // depth/stencil attachment (when used in read pipeline it loads data filed in write pipeline)
+               {
+                       VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,                             // VkStructureType                                      sType
+                       DE_NULL,                                                                                                // const void*                                          pNext
+                       (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags
+                       intermediateFormat,                                                                             // VkFormat                                                     format
+                       VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples
+                       VK_ATTACHMENT_LOAD_OP_LOAD,                                                             // VkAttachmentLoadOp                           loadOp
+                       VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          storeOp
+                       VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp
+                       VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          stencilStoreOp
+                       intermediateLayout,                                                                             // VkImageLayout                                        initialLayout
+                       intermediateLayout                                                                              // VkImageLayout                                        finalLayout
+               },
+               // color attachment
+               {
+                       VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,                             // VkStructureType                                      sType
+                       DE_NULL,                                                                                                // const void*                                          pNext
+                       (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags
+                       outputFormat,                                                                                   // VkFormat                                                     format
+                       VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples
+                       VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           loadOp
+                       VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          storeOp
+                       VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp
+                       VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          stencilStoreOp
+                       VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                                        initialLayout
+                       outputLayout                                                                                    // VkImageLayout                                        finalLayout
+               }
+       };
+
+       VkImageAspectFlags                                      intermediateAspect      = getImageAspectFlags(mapVkFormat(intermediateFormat));
+       VkImageAspectFlags                                      outputAspect            = getImageAspectFlags(mapVkFormat(outputFormat));
+       std::vector<VkAttachmentReference2>     attachmentRefs
+       {
+               { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 0u, intermediateLayout, intermediateAspect },
+               { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 1u, outputLayout, outputAspect }
+       };
+
+       VkAttachmentReference2* pDepthStencilAttachment = &attachmentRefs[0];
+       VkAttachmentReference2* pColorAttachment                = &attachmentRefs[1];
+
+       std::vector<VkSubpassDescription2> subpassDescriptions
+       {
+               {
+                       VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
+                       DE_NULL,
+                       (VkSubpassDescriptionFlags)0,                                           // VkSubpassDescriptionFlags            flags
+                       VK_PIPELINE_BIND_POINT_GRAPHICS,                                        // VkPipelineBindPoint                          pipelineBindPoint
+                       0u,                                                                                                     // deUint32                                                     viewMask
+                       1u,                                                                                                     // deUint32                                                     inputAttachmentCount
+                       pDepthStencilAttachment,                                                        // const VkAttachmentReference2*        pInputAttachments
+                       1u,                                                                                                     // deUint32                                                     colorAttachmentCount
+                       pColorAttachment,                                                                       // const VkAttachmentReference2*        pColorAttachments
+                       DE_NULL,                                                                                        // const VkAttachmentReference2*        pResolveAttachments
+                       DE_NULL,                                                                                        // const VkAttachmentReference2*        pDepthStencilAttachment
+                       0u,                                                                                                     // deUint32                                                     preserveAttachmentCount
+                       DE_NULL                                                                                         // deUint32*                                            pPreserveAttachments
+               }
+       };
+
+       const VkRenderPassCreateInfo2 renderPassInfo
+       {
+               VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
+               DE_NULL,                                                                                                // const void*                                          pNext
+               (VkRenderPassCreateFlags)0,                                                             // VkRenderPassCreateFlags                      flags
+               (deUint32)attachmentDescriptions.size(),                                // deUint32                                                     attachmentCount
+               attachmentDescriptions.data(),                                                  // const VkAttachmentDescription*       pAttachments
+               (deUint32)subpassDescriptions.size(),                                   // deUint32                                                     subpassCount
+               subpassDescriptions.data(),                                                             // const VkSubpassDescription*          pSubpasses
+               0u,                                                                                                             // deUint32                                                     dependencyCount
+               DE_NULL,                                                                                                // const VkSubpassDependency*           pDependencies
+               0u,                                                                                                             // deUint32                                                     correlatedViewMaskCount
+               DE_NULL                                                                                                 // const deUint32*                                      pCorrelatedViewMasks
+       };
+
+       return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo);
+}
+
+Move<VkImageView> NoneStageTestInstance::buildImageView(VkImage image, VkFormat format, const VkImageSubresourceRange& subresourceRange)
+{
+       const DeviceInterface&  vk              = m_context.getDeviceInterface();
+       const VkDevice&                 device  = m_context.getDevice();
+
+       const VkImageViewCreateInfo imageViewParams
+       {
+               VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,                               // VkStructureType                              sType
+               DE_NULL,                                                                                                // const void*                                  pNext
+               0u,                                                                                                             // VkImageViewCreateFlags               flags
+               image,                                                                                                  // VkImage                                              image
+               VK_IMAGE_VIEW_TYPE_2D,                                                                  // VkImageViewType                              viewType
+               format,                                                                                                 // VkFormat                                             format
+               makeComponentMappingRGBA(),                                                             // VkComponentMapping                   components
+               subresourceRange,                                                                               // VkImageSubresourceRange              subresourceRange
+       };
+
+       return createImageView(vk, device, &imageViewParams);
+}
+
+Move<VkFramebuffer> NoneStageTestInstance::buildFramebuffer(VkRenderPass renderPass, const VkImageView* outView1, const VkImageView* outView2)
+{
+       const DeviceInterface&  vk              = m_context.getDeviceInterface();
+       const VkDevice&                 device  = m_context.getDevice();
+
+       std::vector<VkImageView> imageViews = { *outView1 };
+       if (outView2)
+               imageViews.push_back(*outView2);
+
+       const VkFramebufferCreateInfo framebufferParams
+       {
+               VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                              // VkStructureType                              sType
+               DE_NULL,                                                                                                // const void*                                  pNext
+               0u,                                                                                                             // VkFramebufferCreateFlags             flags
+               renderPass,                                                                                             // VkRenderPass                                 renderPass
+               (deUint32)imageViews.size(),                                                    // deUint32                                             attachmentCount
+               imageViews.data(),                                                                              // const VkImageView*                   pAttachments
+               m_imageExtent.width,                                                                    // deUint32                                             width
+               m_imageExtent.height,                                                                   // deUint32                                             height
+               1u,                                                                                                             // deUint32                                             layers
+       };
+       return createFramebuffer(vk, device, &framebufferParams);
+}
+
+Move<VkSampler> NoneStageTestInstance::buildSampler()
+{
+       const DeviceInterface&  vk              = m_context.getDeviceInterface();
+       const VkDevice&                 device  = m_context.getDevice();
+
+       const VkSamplerCreateInfo samplerInfo
+       {
+               VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                                  // VkStructureType                              sType
+               DE_NULL,                                                                                                // const void*                                  pNext
+               0u,                                                                                                             // VkSamplerCreateFlags                 flags
+               VK_FILTER_NEAREST,                                                                              // VkFilter                                             magFilter
+               VK_FILTER_NEAREST,                                                                              // VkFilter                                             minFilter
+               VK_SAMPLER_MIPMAP_MODE_NEAREST,                                                 // VkSamplerMipmapMode                  mipmapMode
+               VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                  // VkSamplerAddressMode                 addressModeU
+               VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                  // VkSamplerAddressMode                 addressModeV
+               VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                  // VkSamplerAddressMode                 addressModeW
+               0.0f,                                                                                                   // float                                                mipLodBias
+               VK_FALSE,                                                                                               // VkBool32                                             anisotropyEnable
+               1.0f,                                                                                                   // float                                                maxAnisotropy
+               DE_FALSE,                                                                                               // VkBool32                                             compareEnable
+               VK_COMPARE_OP_ALWAYS,                                                                   // VkCompareOp                                  compareOp
+               0.0f,                                                                                                   // float                                                minLod
+               0.0f,                                                                                                   // float                                                maxLod
+               VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,                                // VkBorderColor                                borderColor
+               VK_FALSE,                                                                                               // VkBool32                                             unnormalizedCoords
+       };
+       return createSampler(vk, device, &samplerInfo);
+}
+
+Move<VkDescriptorSetLayout> NoneStageTestInstance::buildDescriptorSetLayout(VkDescriptorType descriptorType)
+{
+       const DeviceInterface&          vk              = m_context.getDeviceInterface();
+       const VkDevice&                         device  = m_context.getDevice();
+
+       return
+               DescriptorSetLayoutBuilder()
+               .addSingleSamplerBinding(descriptorType, VK_SHADER_STAGE_FRAGMENT_BIT, DE_NULL)
+               .build(vk, device);
+}
+
+Move<VkDescriptorPool> NoneStageTestInstance::buildDescriptorPool(VkDescriptorType descriptorType)
+{
+       const DeviceInterface&          vk              = m_context.getDeviceInterface();
+       const VkDevice&                         device  = m_context.getDevice();
+
+       return
+               DescriptorPoolBuilder()
+               .addType(descriptorType, 1u)
+               .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+}
+
+Move<VkDescriptorSet> NoneStageTestInstance::buildDescriptorSet(VkDescriptorPool               descriptorPool,
+                                                                                                                               VkDescriptorSetLayout   descriptorSetLayout,
+                                                                                                                               VkDescriptorType                descriptorType,
+                                                                                                                               VkImageView                             inputView,
+                                                                                                                               VkImageLayout                   inputLayout,
+                                                                                                                               const VkSampler*                sampler)
+{
+       const DeviceInterface&          vk                              = m_context.getDeviceInterface();
+       const VkDevice&                         device                  = m_context.getDevice();
+
+       const VkDescriptorImageInfo inputImageInfo      = makeDescriptorImageInfo(sampler ? *sampler : 0u, inputView, inputLayout);
+       Move<VkDescriptorSet>           descriptorSet   = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);
+
+       DescriptorSetUpdateBuilder()
+               .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &inputImageInfo)
+               .update(vk, device);
+
+       return descriptorSet;
+}
+
+Move<VkPipeline> NoneStageTestInstance::buildPipeline(deUint32                         subpass,
+                                                                                                         VkImageAspectFlags    resultAspect,
+                                                                                                         VkPipelineLayout              pipelineLayout,
+                                                                                                         VkShaderModule                vertShaderModule,
+                                                                                                         VkShaderModule                fragShaderModule,
+                                                                                                         VkRenderPass                  renderPass)
+{
+       const DeviceInterface&                  vk                              = m_context.getDeviceInterface();
+       const VkDevice&                                 device                  = m_context.getDevice();
+       const std::vector<VkViewport>   viewports               { makeViewport(m_imageExtent) };
+       const std::vector<VkRect2D>             scissors                { makeRect2D(m_imageExtent) };
+       const bool                                              useDepth                = resultAspect & VK_IMAGE_ASPECT_DEPTH_BIT;
+       const bool                                              useStencil              = resultAspect & VK_IMAGE_ASPECT_STENCIL_BIT;
+
+       const VkStencilOpState stencilOpState = makeStencilOpState(
+               VK_STENCIL_OP_REPLACE,                                                                                  // stencil fail
+               VK_STENCIL_OP_REPLACE,                                                                                  // depth & stencil pass
+               VK_STENCIL_OP_REPLACE,                                                                                  // depth only fail
+               VK_COMPARE_OP_ALWAYS,                                                                                   // compare op
+               1u,                                                                                                                             // compare mask
+               1u,                                                                                                                             // write mask
+               1u);                                                                                                                    // reference
+
+       const VkPipelineDepthStencilStateCreateInfo     depthStencilStateCreateInfo
+       {
+               VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,             // VkStructureType                                                              sType
+               DE_NULL,                                                                                                                // const void*                                                                  pNext
+               (VkPipelineDepthStencilStateCreateFlags)0,                                              // VkPipelineDepthStencilStateCreateFlags               flags
+               useDepth,                                                                                                               // VkBool32                                                                             depthTestEnable
+               useDepth,                                                                                                               // VkBool32                                                                             depthWriteEnable
+               VK_COMPARE_OP_ALWAYS,                                                                                   // VkCompareOp                                                                  depthCompareOp
+               VK_FALSE,                                                                                                               // VkBool32                                                                             depthBoundsTestEnable
+               useStencil,                                                                                                             // VkBool32                                                                             stencilTestEnable
+               stencilOpState,                                                                                                 // VkStencilOpState                                                             front
+               stencilOpState,                                                                                                 // VkStencilOpState                                                             back
+               0.0f,                                                                                                                   // float                                                                                minDepthBounds
+               1.0f,                                                                                                                   // float                                                                                maxDepthBounds
+       };
+
+       return makeGraphicsPipeline(
+               vk,                                                                                                                             // DeviceInterface&                                                             vk
+               device,                                                                                                                 // VkDevice                                                                             device
+               pipelineLayout,                                                                                                 // VkPipelineLayout                                                             pipelineLayout
+               vertShaderModule,                                                                                               // VkShaderModule                                                               vertexShaderModule
+               DE_NULL,                                                                                                                // VkShaderModule                                                               tessellationControlModule
+               DE_NULL,                                                                                                                // VkShaderModule                                                               tessellationEvalModule
+               DE_NULL,                                                                                                                // VkShaderModule                                                               geometryShaderModule
+               fragShaderModule,                                                                                               // VkShaderModule                                                               fragmentShaderModule
+               renderPass,                                                                                                             // VkRenderPass                                                                 renderPass
+               viewports,                                                                                                              // std::vector<VkViewport>&                                             viewports
+               scissors,                                                                                                               // std::vector<VkRect2D>&                                               scissors
+               VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,                                                   // VkPrimitiveTopology                                                  topology
+               subpass,                                                                                                                // deUint32                                                                             subpass
+               0u,                                                                                                                             // deUint32                                                                             patchControlPoints
+               DE_NULL,                                                                                                                // VkPipelineVertexInputStateCreateInfo*                vertexInputStateCreateInfo
+               DE_NULL,                                                                                                                // VkPipelineRasterizationStateCreateInfo*              rasterizationStateCreateInfo
+               DE_NULL,                                                                                                                // VkPipelineMultisampleStateCreateInfo*                multisampleStateCreateInfo
+               &depthStencilStateCreateInfo);                                                                  // VkPipelineDepthStencilStateCreateInfo*               depthStencilStateCreateInfo
+}
+
+tcu::TestStatus NoneStageTestInstance::iterate(void)
+{
+       const DeviceInterface&          vk                                              = m_context.getDeviceInterface();
+       const VkDevice&                         device                                  = m_context.getDevice();
+       const deUint32                          queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
+       VkQueue                                         queue                                   = m_context.getUniversalQueue();
+       Move<VkCommandPool>                     cmdPool                                 = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
+       Move<VkCommandBuffer>           cmdBuffer                               = makeCommandBuffer(vk, device, *cmdPool);
+       const VkDeviceSize                      vertexBufferOffset              = 0;
+       ImageWrapper*                           transitionImagePtr              = &m_referenceImage;
+       ImageWrapper*                           imageToVerifyPtr                = &m_referenceImage;
+       const deUint32                          imageSizeInBytes                = m_imageExtent.width * m_imageExtent.height * 4;
+       SynchronizationWrapperPtr       synchronizationWrapper  = getSynchronizationWrapper(m_testParams.type, vk, false);
+       const VkRect2D                          renderArea                              = makeRect2D(0, 0, m_imageExtent.width, m_imageExtent.height);
+       const VkBufferImageCopy         transitionCopyRegion    = buildCopyRegion(m_imageExtent, m_transitionImageAspect);
+       const VkBufferImageCopy         colorCopyRegion                 = buildCopyRegion(m_imageExtent, VK_IMAGE_ASPECT_COLOR_BIT);
+
+       // create image that will have gradient (without data atm)
+       m_referenceImage.create(m_context, m_alloc, m_referenceImageFormat, m_imageExtent, m_referenceImageUsage);
+
+       // create buffer used for gradient data source
+       BufferWrapper srcBuffer;
+       srcBuffer.create(m_context, m_alloc, imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+
+       // generate gradient
+       std::vector<deUint32>   referenceData   (m_imageExtent.width * m_imageExtent.height);
+       tcu::TextureFormat              referenceFormat (mapVkFormat(m_referenceImageFormat));
+       PixelBufferAccess               referencePBA    (referenceFormat, m_imageExtent.width, m_imageExtent.height, m_imageExtent.depth, referenceData.data());
+       fillWithComponentGradients(referencePBA, tcu::Vec4(0.0f), tcu::Vec4(1.0f));
+       deMemcpy(srcBuffer.memory->getHostPtr(), referenceData.data(), static_cast<size_t>(imageSizeInBytes));
+       flushAlloc(vk, device, *srcBuffer.memory);
+
+       // create buffer for result transfer
+       BufferWrapper                   dstBuffer;
+       tcu::TextureFormat              resultFormat    (mapVkFormat(m_readImageFormat));
+       dstBuffer.create(m_context, m_alloc, imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+
+       if (m_usePipelineToWrite || m_usePipelineToRead)
+       {
+               buildVertexBuffer();
+
+               // create image view for reference image (its always at index 0)
+               m_attachmentViews.push_back(buildImageView(*m_referenceImage.handle, m_referenceImageFormat, m_referenceSubresourceRange));
+
+               // create graphics pipeline used to write image data
+               if (m_usePipelineToWrite)
+               {
+                       // create image that will be used as attachment to write to
+                       m_imageToWrite.create(m_context, m_alloc, m_transitionImageFormat, m_imageExtent, m_imageToWriteUsage);
+                       m_attachmentViews.push_back(buildImageView(*m_imageToWrite.handle, m_transitionImageFormat, m_transitionSubresourceRange));
+
+                       m_writeVertShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
+                       m_writeFragShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get(m_writeFragShaderName), 0);
+
+                       if (m_useStencilDuringWrite)
+                       {
+                               // this is used only for cases where writable layout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL
+                               // in this case generated gradient is only used for verification
+                               m_writeRenderPass                       = buildBasicRenderPass(m_transitionImageFormat, m_writeRenderPassOutputLayout, VK_ATTACHMENT_LOAD_OP_CLEAR);
+                               m_writePipelineLayout           = makePipelineLayout(vk, device, DE_NULL);
+                               m_writePipeline                         = buildPipeline(0u, m_transitionImageAspect, *m_writePipelineLayout,
+                                                                                                                       *m_writeVertShaderModule, *m_writeFragShaderModule, *m_writeRenderPass);
+                               m_writeFramebuffer                      = buildFramebuffer(*m_writeRenderPass, &m_attachmentViews[1].get());
+                       }
+                       else
+                       {
+                               m_writeRenderPass                       = buildBasicRenderPass(m_transitionImageFormat, m_writeRenderPassOutputLayout);
+                               m_writeSampler                          = buildSampler();
+                               m_writeDescriptorSetLayout      = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+                               m_writeDescriptorPool           = buildDescriptorPool(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+                               m_writeDescriptorSet            = buildDescriptorSet(*m_writeDescriptorPool, *m_writeDescriptorSetLayout, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                                                                                                                *m_attachmentViews[0], VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, &m_writeSampler.get());
+                               m_writePipelineLayout           = makePipelineLayout(vk, device, *m_writeDescriptorSetLayout);
+                               m_writePipeline                         = buildPipeline(0u, m_transitionImageAspect, *m_writePipelineLayout,
+                                                                                                                       *m_writeVertShaderModule, *m_writeFragShaderModule, *m_writeRenderPass);
+                               m_writeFramebuffer                      = buildFramebuffer(*m_writeRenderPass, &m_attachmentViews[1].get());
+                       }
+
+                       transitionImagePtr      = &m_imageToWrite;
+                       imageToVerifyPtr        = &m_imageToWrite;
+               }
+
+               // create graphics pipeline used to read image data
+               if (m_usePipelineToRead)
+               {
+                       m_imageToRead.create(m_context, m_alloc, m_readImageFormat, m_imageExtent, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
+                       m_attachmentViews.push_back(buildImageView(*m_imageToRead.handle, m_readImageFormat, m_readSubresourceRange));
+                       imageToVerifyPtr = &m_imageToRead;
+
+                       m_readVertShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
+                       m_readFragShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get(m_readFragShaderName), 0);
+
+                       if (m_useInputAttachmentToRead)
+                       {
+                               m_readDescriptorSetLayout       = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
+                               m_readDescriptorPool            = buildDescriptorPool(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
+                               m_readDescriptorSet                     = buildDescriptorSet(*m_readDescriptorPool, *m_readDescriptorSetLayout, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+                                                                                                                                *m_attachmentViews[m_usePipelineToWrite], m_testParams.readLayout);
+                               m_readRenderPass                        = buildComplexRenderPass(m_transitionImageFormat, m_testParams.readLayout,
+                                                                                                                                        m_readImageFormat, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+                               m_readFramebuffer                       = buildFramebuffer(*m_readRenderPass, &m_attachmentViews[m_usePipelineToWrite].get(),
+                                                                                                                                                                 &m_attachmentViews[m_usePipelineToWrite+1].get());
+                               m_readPipelineLayout            = makePipelineLayout(vk, device, *m_readDescriptorSetLayout);
+                               m_readPipeline                          = buildPipeline(0u, VK_IMAGE_ASPECT_COLOR_BIT, *m_readPipelineLayout,
+                                                                                                                       *m_readVertShaderModule, *m_readFragShaderModule, *m_readRenderPass);
+                       }
+                       else
+                       {
+                               m_readSampler                           = buildSampler();
+                               m_readDescriptorSetLayout       = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+                               m_readDescriptorPool            = buildDescriptorPool(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+                               m_readDescriptorSet                     = buildDescriptorSet(*m_readDescriptorPool, *m_readDescriptorSetLayout, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                                                                                                                *m_attachmentViews[m_usePipelineToWrite], m_testParams.readLayout, &m_readSampler.get());
+                               m_readRenderPass                        = buildBasicRenderPass(m_readImageFormat, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+                               m_readFramebuffer                       = buildFramebuffer(*m_readRenderPass, &m_attachmentViews[m_usePipelineToWrite + 1].get());
+                               m_readPipelineLayout            = makePipelineLayout(vk, device, *m_readDescriptorSetLayout);
+                               m_readPipeline                          = buildPipeline(0u, m_transitionImageAspect, *m_readPipelineLayout,
+                                                                                                                       *m_readVertShaderModule, *m_readFragShaderModule, *m_readRenderPass);
+                       }
+               }
+       }
+
+       beginCommandBuffer(vk, *cmdBuffer);
+
+       // write data from buffer with gradient to image (for stencil_attachment cases we dont need to do that)
+       if (!m_useStencilDuringWrite)
+       {
+               // wait for reference data to be in buffer
+               const VkBufferMemoryBarrier2KHR preBufferMemoryBarrier2 = makeBufferMemoryBarrier2(
+                       VK_PIPELINE_STAGE_2_HOST_BIT_KHR,                                       // VkPipelineStageFlags2KHR                     srcStageMask
+                       getAccessFlag(VK_ACCESS_2_HOST_WRITE_BIT_KHR),          // VkAccessFlags2KHR                            srcAccessMask
+                       VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                           // VkPipelineStageFlags2KHR                     dstStageMask
+                       getAccessFlag(VK_ACCESS_2_TRANSFER_READ_BIT_KHR),       // VkAccessFlags2KHR                            dstAccessMask
+                       *srcBuffer.handle,                                                                      // VkBuffer                                                     buffer
+                       0u,                                                                                                     // VkDeviceSize                                         offset
+                       imageSizeInBytes                                                                        // VkDeviceSize                                         size
+               );
+
+               VkImageLayout copyBufferToImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+               if(m_testParams.writeLayout == VK_IMAGE_LAYOUT_GENERAL)
+                       copyBufferToImageLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+               // change image layout so that we can copy to it data from buffer
+               const VkImageMemoryBarrier2KHR preImageMemoryBarrier2 = makeImageMemoryBarrier2(
+                       VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                           // VkPipelineStageFlags2KHR                     srcStageMask
+                       getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR),      // VkAccessFlags2KHR                            srcAccessMask
+                       VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                           // VkPipelineStageFlags2KHR                     dstStageMask
+                       getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR),      // VkAccessFlags2KHR                            dstAccessMask
+                       VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                                        oldLayout
+                       copyBufferToImageLayout,                                                        // VkImageLayout                                        newLayout
+                       *m_referenceImage.handle,                                                       // VkImage                                                      image
+                       m_referenceSubresourceRange                                                     // VkImageSubresourceRange                      subresourceRange
+               );
+               VkDependencyInfoKHR buffDependencyInfo = makeCommonDependencyInfo(DE_NULL, &preBufferMemoryBarrier2, &preImageMemoryBarrier2);
+               synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &buffDependencyInfo);
+
+               const VkBufferImageCopy* copyRegion = m_usePipelineToWrite ? &colorCopyRegion : &transitionCopyRegion;
+               vk.cmdCopyBufferToImage(*cmdBuffer, *srcBuffer.handle, *m_referenceImage.handle, copyBufferToImageLayout, 1u, copyRegion);
+       }
+
+       if (m_usePipelineToWrite)
+       {
+               // wait till data is transfered to image (in all cases except when stencil_attachment is tested)
+               if (!m_useStencilDuringWrite)
+               {
+                       const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2(
+                               VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                           // VkPipelineStageFlags2KHR                     srcStageMask
+                               getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR),      // VkAccessFlags2KHR                            srcAccessMask
+                               VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR,            // VkPipelineStageFlags2KHR                     dstStageMask
+                               getAccessFlag(VK_ACCESS_2_SHADER_READ_BIT_KHR),         // VkAccessFlags2KHR                            dstAccessMask
+                               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                                        oldLayout
+                               VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,                       // VkImageLayout                                        newLayout
+                               *m_referenceImage.handle,                                                       // VkImage                                                      image
+                               m_referenceSubresourceRange                                                     // VkImageSubresourceRange                      subresourceRange
+                       );
+                       VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2);
+                       synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo);
+               }
+
+               beginRenderPass(vk, *cmdBuffer, *m_writeRenderPass, *m_writeFramebuffer, renderArea, tcu::Vec4(0.0f ,0.0f, 0.0f, 1.0f));
+
+               vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_writePipeline);
+               vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &m_vertexBuffer.handle.get(), &vertexBufferOffset);
+               if (m_useStencilDuringWrite)
+               {
+                       // when writing to stencil buffer draw single triangle (to simulate gradient over 1bit)
+                       vk.cmdDraw(*cmdBuffer, 3u, 1u, 0u, 0u);
+               }
+               else
+               {
+                       vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_writePipelineLayout, 0, 1, &m_writeDescriptorSet.get(), 0, DE_NULL);
+                       vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
+               }
+
+               endRenderPass(vk, *cmdBuffer);
+       }
+
+       // use none stage to wait till data is transfered to image
+       {
+               const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2(
+                       m_srcStageToNoneStageMask,                                                      // VkPipelineStageFlags2KHR                     srcStageMask
+                       m_srcAccessToNoneAccessMask,                                            // VkAccessFlags2KHR                            srcAccessMask
+                       VK_PIPELINE_STAGE_2_NONE_KHR,                                           // VkPipelineStageFlags2KHR                     dstStageMask
+                       VK_ACCESS_2_NONE_KHR,                                                           // VkAccessFlags2KHR                            dstAccessMask
+                       m_testParams.writeLayout,                                                       // VkImageLayout                                        oldLayout
+                       m_testParams.writeLayout,                                                       // VkImageLayout                                        newLayout
+                       *transitionImagePtr->handle,                                            // VkImage                                                      image
+                       m_transitionSubresourceRange                                            // VkImageSubresourceRange                      subresourceRange
+               );
+               VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2);
+               synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo);
+       }
+
+       // use all commands stage to change image layout
+       {
+               const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2(
+                       VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR,                       // VkPipelineStageFlags2KHR                     srcStageMask
+                       VK_ACCESS_2_NONE_KHR,                                                           // VkAccessFlags2KHR                            srcAccessMask
+                       m_dstStageFromNoneStageMask,                                            // VkPipelineStageFlags2KHR                     dstStageMask
+                       m_dstAccessFromNoneAccessMask,                                          // VkAccessFlags2KHR                            dstAccessMask
+                       m_testParams.writeLayout,                                                       // VkImageLayout                                        oldLayout
+                       m_testParams.readLayout,                                                        // VkImageLayout                                        newLayout
+                       *transitionImagePtr->handle,                                            // VkImage                                                      image
+                       m_transitionSubresourceRange                                            // VkImageSubresourceRange                      subresourceRange
+               );
+               VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2);
+               synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo);
+       }
+
+       VkImageLayout copyImageToBufferLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+       if (m_testParams.readLayout == VK_IMAGE_LAYOUT_GENERAL)
+               copyImageToBufferLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+       if (m_usePipelineToRead)
+       {
+               beginRenderPass(vk, *cmdBuffer, *m_readRenderPass, *m_readFramebuffer, renderArea);
+
+               vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_readPipeline);
+               vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_readPipelineLayout, 0, 1, &m_readDescriptorSet.get(), 0, DE_NULL);
+               vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &m_vertexBuffer.handle.get(), &vertexBufferOffset);
+               vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
+
+               endRenderPass(vk, *cmdBuffer);
+
+               // wait till data is transfered to image
+               const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2(
+                       VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR,    // VkPipelineStageFlags2KHR                     srcStageMask
+                       VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR,                             // VkAccessFlags2KHR                            srcAccessMask
+                       VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                                   // VkPipelineStageFlags2KHR                     dstStageMask
+                       getAccessFlag(VK_ACCESS_2_TRANSFER_READ_BIT_KHR),               // VkAccessFlags2KHR                            dstAccessMask
+                       VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                               // VkImageLayout                                        oldLayout
+                       copyImageToBufferLayout,                                                                // VkImageLayout                                        newLayout
+                       *imageToVerifyPtr->handle,                                                              // VkImage                                                      image
+                       m_readSubresourceRange                                                                  // VkImageSubresourceRange                      subresourceRange
+               );
+               VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2);
+               synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo);
+       }
+
+       // read back image
+       {
+               const VkBufferImageCopy* copyRegion = m_usePipelineToRead ? &colorCopyRegion : &transitionCopyRegion;
+               vk.cmdCopyImageToBuffer(*cmdBuffer, *imageToVerifyPtr->handle, copyImageToBufferLayout, *dstBuffer.handle, 1u, copyRegion);
+
+               const VkBufferMemoryBarrier2KHR postBufferMemoryBarrier2 = makeBufferMemoryBarrier2(
+                       VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR,                           // VkPipelineStageFlags2KHR                     srcStageMask
+                       getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR),      // VkAccessFlags2KHR                            srcAccessMask
+                       VK_PIPELINE_STAGE_2_HOST_BIT_KHR,                                       // VkPipelineStageFlags2KHR                     dstStageMask
+                       getAccessFlag(VK_ACCESS_2_HOST_READ_BIT_KHR),           // VkAccessFlags2KHR                            dstAccessMask
+                       *dstBuffer.handle,                                                                      // VkBuffer                                                     buffer
+                       0u,                                                                                                     // VkDeviceSize                                         offset
+                       imageSizeInBytes                                                                        // VkDeviceSize                                         size
+               );
+               VkDependencyInfoKHR bufDependencyInfo = makeCommonDependencyInfo(DE_NULL, &postBufferMemoryBarrier2);
+               synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &bufDependencyInfo);
+       }
+
+       endCommandBuffer(vk, *cmdBuffer);
+
+       Move<VkFence>                                   fence                   = createFence(vk, device);
+       VkCommandBufferSubmitInfoKHR    cmdBuffersInfo  = makeCommonCommandBufferSubmitInfo(*cmdBuffer);
+       synchronizationWrapper->addSubmitInfo(0u, DE_NULL, 1u, &cmdBuffersInfo, 0u, DE_NULL);
+       VK_CHECK(synchronizationWrapper->queueSubmit(queue, *fence));
+       VK_CHECK(vk.waitForFences(device, 1, &fence.get(), VK_TRUE, ~0ull));
+
+       // read image data
+       invalidateAlloc(vk, device, *dstBuffer.memory);
+       PixelBufferAccess resultPBA(resultFormat, m_imageExtent.width, m_imageExtent.height, m_imageExtent.depth, dstBuffer.memory->getHostPtr());
+
+       // if result/reference is depth-stencil format then focus only on depth component
+       if (isCombinedDepthStencilType(referenceFormat.type))
+               referencePBA = getEffectiveDepthStencilAccess(referencePBA, tcu::Sampler::MODE_DEPTH);
+       if (isCombinedDepthStencilType(resultFormat.type))
+               resultPBA = getEffectiveDepthStencilAccess(resultPBA, tcu::Sampler::MODE_DEPTH);
+
+       if (verifyResult(referencePBA, resultPBA))
+               return TestStatus::pass("Pass");
+       return TestStatus::fail("Fail");
+}
+
+bool NoneStageTestInstance::verifyResult(const PixelBufferAccess& reference, const PixelBufferAccess& result)
+{
+       TestLog& log = m_context.getTestContext().getLog();
+
+       if (isIntFormat(m_referenceImageFormat) || isUintFormat(m_referenceImageFormat))
+       {
+               // special case for stencil (1bit gradient - top-left of image is 0, bottom-right is 1)
+
+               bool                            isResultCorrect = true;
+               TextureLevel            errorMaskStorage(TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8),
+                                                                                        m_imageExtent.width, m_imageExtent.height, 1);
+               PixelBufferAccess       errorMask               = errorMaskStorage.getAccess();
+
+               for (deUint32 y = 0; y < m_imageExtent.height; y++)
+                       for (deUint32 x = 0; x < m_imageExtent.width; x++)
+                       {
+                               // skip textels on diagonal (gradient lights texels on diagonal and stencil operation in test does not)
+                               if ((x + y) == (m_imageExtent.width - 1))
+                               {
+                                       errorMask.setPixel(IVec4(0, 0xff, 0, 0xff), x, y, 0);
+                                       continue;
+                               }
+
+                               IVec4   refPix = reference.getPixelInt(x, y, 0);
+                               IVec4   cmpPix = result.getPixelInt(x, y, 0);
+                               bool    isOk = (refPix[0] == cmpPix[0]);
+                               errorMask.setPixel(isOk ? IVec4(0, 0xff, 0, 0xff) : IVec4(0xff, 0, 0, 0xff), x, y, 0);
+                               isResultCorrect &= isOk;
+                       }
+
+               Vec4 pixelBias(0.0f);
+               Vec4 pixelScale(1.0f);
+               if (isResultCorrect)
+               {
+                       log << TestLog::ImageSet("Image comparison", "")
+                               << TestLog::Image("Result", "Result", result, pixelScale, pixelBias)
+                               << TestLog::EndImageSet;
+                       return true;
+               }
+
+               log << TestLog::ImageSet("Image comparison", "")
+                       << TestLog::Image("Result", "Result", result, pixelScale, pixelBias)
+                       << TestLog::Image("Reference", "Reference", reference, pixelScale, pixelBias)
+                       << TestLog::Image("ErrorMask", "Error mask", errorMask)
+                       << TestLog::EndImageSet;
+               return false;
+       }
+
+       return floatThresholdCompare(log, "Image comparison", "", reference, result, tcu::Vec4(0.01f), tcu::COMPARE_LOG_RESULT);
+}
+
+class NoneStageTestCase : public vkt::TestCase
+{
+public:
+                                                       NoneStageTestCase               (tcu::TestContext&              testContext,
+                                                                                                        const std::string&             name,
+                                                                                                        const TestParams&              testParams);
+                                                       ~NoneStageTestCase              (void) = default;
+
+       void                                    initPrograms                    (SourceCollections&             sourceCollections) const override;
+       TestInstance*                   createInstance                  (Context&                               context) const override;
+       void                                    checkSupport                    (Context&                               context) const override;
+
+private:
+       const TestParams                m_testParams;
+};
+
+NoneStageTestCase::NoneStageTestCase(tcu::TestContext& testContext, const std::string& name, const TestParams& testParams)
+       : vkt::TestCase (testContext, name, "")
+       , m_testParams  (testParams)
+{
+}
+
+void NoneStageTestCase::initPrograms(SourceCollections& sourceCollections) const
+{
+       const auto writeLayout  = m_testParams.writeLayout;
+       const auto writeAspect  = m_testParams.writeAspect;
+       const auto readLayout   = m_testParams.readLayout;
+       const auto readAspect   = m_testParams.readAspect;
+
+       // for tests that use only transfer and general layouts we don't create pipeline
+       if (((writeLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) || (readLayout == VK_IMAGE_LAYOUT_GENERAL)) &&
+               ((writeLayout == VK_IMAGE_LAYOUT_GENERAL) || (readLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)))
+               return;
+
+       sourceCollections.glslSources.add("vert") << glu::VertexSource(
+               "#version 450\n"
+               "layout(location = 0) in  vec4 inPosition;\n"
+               "layout(location = 0) out vec2 outUV;\n"
+               "void main(void)\n"
+               "{\n"
+               "  outUV = vec2(inPosition.x * 0.5 + 0.5, inPosition.y * 0.5 + 0.5);\n"
+               "  gl_Position = inPosition;\n"
+               "}\n"
+       );
+
+       sourceCollections.glslSources.add("frag-color") << glu::FragmentSource(
+               "#version 450\n"
+               "layout(binding = 0) uniform sampler2D u_sampler;\n"
+               "layout(location = 0) in vec2 inUV;\n"
+               "layout(location = 0) out vec4 fragColor;\n"
+               "void main(void)\n"
+               "{\n"
+               "  fragColor = texture(u_sampler, inUV);\n"
+               "}\n"
+       );
+
+       if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT)
+       {
+               sourceCollections.glslSources.add("frag-color-to-depth") << glu::FragmentSource(
+                       "#version 450\n"
+                       "layout(binding = 0) uniform sampler2D u_sampler;\n"
+                       "layout(location = 0) in vec2 inUV;\n"
+                       "void main(void)\n"
+                       "{\n"
+                       "  gl_FragDepth = texture(u_sampler, inUV).r;\n"
+                       "}\n"
+               );
+       }
+
+       if (writeAspect & VK_IMAGE_ASPECT_STENCIL_BIT)
+       {
+               sourceCollections.glslSources.add("frag-color-to-stencil") << glu::FragmentSource(
+                       "#version 450\n"
+                       "void main(void)\n"
+                       "{\n"
+                       "}\n"
+               );
+
+               if ((readLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) ||
+                  ((readLayout == VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR) && (readAspect == IMAGE_ASPECT_ALL)))
+               {
+                       // use usampler2D and uvec4 for color
+                       sourceCollections.glslSources.add("frag-stencil-to-color") << glu::FragmentSource(
+                               "#version 450\n"
+                               "layout(binding = 0) uniform usampler2D u_sampler;\n"
+                               "layout(location = 0) in vec2 inUV;\n"
+                               "layout(location = 0) out uvec4 fragColor;\n"
+                               "void main(void)\n"
+                               "{\n"
+                               "  fragColor = texture(u_sampler, inUV);\n"
+                               "}\n"
+                       );
+               }
+       }
+
+       if (readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))
+       {
+               // for stencil only cases we need to use usubpassInput (for depth and depth_stencil we need to use subpassInput)
+               const bool                                                                      readDepth                       = readAspect & VK_IMAGE_ASPECT_DEPTH_BIT;
+               const std::map<std::string, std::string>        specializations
+               {
+                       { "SUBPASS_INPUT",      (readDepth ? "subpassInput"     : "usubpassInput")      },
+                       { "VALUE_TYPE",         (readDepth ? "float"            : "uint")                       }
+               };
+
+               std::string source =
+                       "#version 450\n"
+                       "layout (input_attachment_index = 0, binding = 0) uniform ${SUBPASS_INPUT} depthOrStencilInput;\n"
+                       "layout(location = 0) in vec2 inUV;\n"
+                       "layout(location = 0) out ${VALUE_TYPE} fragColor;\n"
+                       "void main (void)\n"
+                       "{\n"
+                       "  fragColor = subpassLoad(depthOrStencilInput).x;\n"
+                       "}\n";
+               sourceCollections.glslSources.add("frag-depth-or-stencil-to-color")
+                       << glu::FragmentSource(tcu::StringTemplate(source).specialize(specializations));
+       }
+}
+
+TestInstance* NoneStageTestCase::createInstance(Context& context) const
+{
+       return new NoneStageTestInstance(context, m_testParams);
+}
+
+void NoneStageTestCase::checkSupport(Context& context) const
+{
+       context.requireDeviceFunctionality("VK_KHR_synchronization2");
+
+       const auto writeAspect  = m_testParams.writeAspect;
+       const auto readAspect   = m_testParams.readAspect;
+
+       // check whether implementation supports separate depth/stencil layouts
+       if (((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) && (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT)) ||
+               ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) && (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT)))
+       {
+               if(!context.getSeparateDepthStencilLayoutsFeatures().separateDepthStencilLayouts)
+                       TCU_THROW(NotSupportedError, "Implementation does not support separateDepthStencilLayouts");
+       }
+
+       const auto writeLayout  = m_testParams.writeLayout;
+       const auto readLayout   = m_testParams.readLayout;
+       bool usePipelineToWrite = (writeLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (writeLayout != VK_IMAGE_LAYOUT_GENERAL);
+       bool usePipelineToRead  = (readLayout  != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) && (readLayout  != VK_IMAGE_LAYOUT_GENERAL);
+
+       if (!usePipelineToWrite && !usePipelineToRead)
+               return;
+
+       VkFormat transitionImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+       if ((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) || (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT))
+               transitionImageFormat = VK_FORMAT_D32_SFLOAT;
+       else if ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) || (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT))
+               transitionImageFormat = VK_FORMAT_S8_UINT;
+       else if ((writeAspect == IMAGE_ASPECT_DEPTH_STENCIL) || (readAspect == IMAGE_ASPECT_DEPTH_STENCIL))
+               transitionImageFormat = VK_FORMAT_D24_UNORM_S8_UINT;
+
+       struct FormatToCheck
+       {
+               VkFormat                        format;
+               VkImageUsageFlags       usage;
+       };
+       std::vector<FormatToCheck> formatsToCheck
+       {
+               // reference image
+               { transitionImageFormat, (VkImageUsageFlags)VK_IMAGE_USAGE_TRANSFER_DST_BIT },
+
+               // image to write
+               { transitionImageFormat, (VkImageUsageFlags)VK_IMAGE_USAGE_TRANSFER_SRC_BIT }
+       };
+
+       // note: conditions here are analogic to conditions in test case constructor
+       //       everything not needed was cout out leaving only logic related to
+       //       m_referenceImage and m_imageToWrite
+       if (usePipelineToWrite)
+       {
+               if (writeAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))
+               {
+                       if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT)
+                       {
+                               formatsToCheck[0].format = VK_FORMAT_R32_SFLOAT;
+                               formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+                       }
+                       else
+                               formatsToCheck[0].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+                       formatsToCheck[1].usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+               }
+               else
+               {
+                       formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+                       formatsToCheck[1].usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+               }
+       }
+
+       if (usePipelineToRead)
+       {
+               // for layouts that operate on depth or stencil (not depth_stencil) use input attachment to read
+               if ((readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) && (readAspect != IMAGE_ASPECT_DEPTH_STENCIL))
+               {
+                       formatsToCheck[1].usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+
+                       if (!usePipelineToWrite)
+                               formatsToCheck[0].usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+               }
+               else // use image sampler for color and depth_stencil layouts
+               {
+                       formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+
+                       // for depth_stencil layouts we need to have depth_stencil_attachment usage
+                       if (!usePipelineToWrite && (readAspect & VK_IMAGE_ASPECT_STENCIL_BIT))
+                               formatsToCheck[0].usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+               }
+       }
+
+       // it simplifies logic to pop image to write then to add conditions everywhere above
+       if (!usePipelineToWrite)
+               formatsToCheck.pop_back();
+
+       for (const auto& formatData : formatsToCheck)
+       {
+               VkImageFormatProperties                 properties;
+               const vk::InstanceInterface&    vki = context.getInstanceInterface();
+               if (vki.getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(),
+                                                                                                          formatData.format,
+                                                                                                          VK_IMAGE_TYPE_2D,
+                                                                                                          VK_IMAGE_TILING_OPTIMAL,
+                                                                                                          formatData.usage,
+                                                                                                          0,
+                                                                                                          &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
+               {
+                       std::string error = std::string("Format (") +
+                                                               vk::getFormatName(formatData.format) + ") doesn't support required capabilities.";
+                       TCU_THROW(NotSupportedError, error.c_str());
+               }
+       }
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createNoneStageTests(tcu::TestContext& testCtx)
+{
+       de::MovePtr<tcu::TestCaseGroup> noneStageTests(new tcu::TestCaseGroup(testCtx, "none_stage", ""));
+
+       struct LayoutData
+       {
+               VkImageLayout           token;
+               VkImageAspectFlags      aspect;
+               std::string                     name;
+       };
+
+       const std::vector<LayoutData> writableLayoutsData
+       {
+               { VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                                 IMAGE_ASPECT_ALL,                               "transfer_dst" },
+               { VK_IMAGE_LAYOUT_GENERAL,                                                                              IMAGE_ASPECT_ALL,                               "general" },
+               { VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                             VK_IMAGE_ASPECT_COLOR_BIT,              "color_attachment" },
+               { VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,                             IMAGE_ASPECT_DEPTH_STENCIL,             "depth_stencil_attachment" },
+               { VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,                                             VK_IMAGE_ASPECT_DEPTH_BIT,              "depth_attachment" },
+               { VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,                                   VK_IMAGE_ASPECT_STENCIL_BIT,    "stencil_attachment" },
+               { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,                                               VK_IMAGE_ASPECT_COLOR_BIT,              "generic_color_attachment" },
+               { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,                                               VK_IMAGE_ASPECT_DEPTH_BIT,              "generic_depth_attachment" },
+               { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,                                               VK_IMAGE_ASPECT_STENCIL_BIT,    "generic_stencil_attachment" },
+               { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,                                               IMAGE_ASPECT_DEPTH_STENCIL,             "generic_depth_stencil_attachment" },
+       };
+       const std::vector<LayoutData> readableLayoutsData
+       {
+               { VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                                                 IMAGE_ASPECT_ALL,                               "transfer_src" },
+               { VK_IMAGE_LAYOUT_GENERAL,                                                                              IMAGE_ASPECT_ALL,                               "general" },
+               { VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,                                             IMAGE_ASPECT_ALL,                               "shader_read" },
+               { VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,                              IMAGE_ASPECT_DEPTH_STENCIL,             "depth_stencil_read" },
+               { VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,   IMAGE_ASPECT_DEPTH_STENCIL,             "depth_read_stencil_attachment" },
+               { VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,   IMAGE_ASPECT_DEPTH_STENCIL,             "depth_attachment_stencil_read" },
+               { VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,                                              VK_IMAGE_ASPECT_DEPTH_BIT,              "depth_read" },
+               { VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,                                    VK_IMAGE_ASPECT_STENCIL_BIT,    "stencil_read" },
+               { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,                                                IMAGE_ASPECT_ALL,                               "generic_color_read" },
+               { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,                                                VK_IMAGE_ASPECT_DEPTH_BIT,              "generic_depth_read" },
+               { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,                                                VK_IMAGE_ASPECT_STENCIL_BIT,    "generic_stencil_read" },
+               { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR,                                                IMAGE_ASPECT_DEPTH_STENCIL,             "generic_depth_stencil_read" },
+       };
+
+       struct SynchronizationData
+       {
+               SynchronizationType             type;
+               std::string                             casePrefix;
+               bool                                    useGenericAccessFlags;
+       };
+       std::vector<SynchronizationData> synchronizationData
+       {
+               { SynchronizationType::SYNCHRONIZATION2,        "",                                     true },
+               { SynchronizationType::SYNCHRONIZATION2,        "old_access_",          false },
+
+               // using legacy synchronization structures with NONE_STAGE
+               { SynchronizationType::LEGACY,                          "legacy_",                      false }
+       };
+
+       for (const auto& syncData : synchronizationData)
+       {
+               for (const auto& writeData : writableLayoutsData)
+               {
+                       for (const auto& readData : readableLayoutsData)
+                       {
+                               if (readData.aspect && writeData.aspect &&
+                                  (readData.aspect != writeData.aspect))
+                                       continue;
+
+                               const std::string name = syncData.casePrefix + writeData.name + "_to_" + readData.name;
+                               noneStageTests->addChild(new NoneStageTestCase(testCtx, name, {
+                                       syncData.type,
+                                       syncData.useGenericAccessFlags,
+                                       writeData.token,
+                                       writeData.aspect,
+                                       readData.token,
+                                       readData.aspect
+                               }));
+                       }
+               }
+       }
+
+       return noneStageTests.release();
+}
+
+} // synchronization
+} // vkt
diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.hpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationNoneStageTests.hpp
new file mode 100644 (file)
index 0000000..d75bade
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef _VKTSYNCHRONIZATIONNONESTAGETESTS_HPP
+#define _VKTSYNCHRONIZATIONNONESTAGETESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2020 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 Tests VK_PIPELINE_STAGE_NONE{_2}_KHR
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace synchronization
+{
+
+tcu::TestCaseGroup* createNoneStageTests(tcu::TestContext& testCtx);
+
+} // synchronization
+} // vkt
+
+#endif // _VKTSYNCHRONIZATIONNONESTAGETESTS_HPP
index 3cb7fc9..7fb9219 100644 (file)
@@ -34,6 +34,7 @@
 #include "vktSynchronizationSignalOrderTests.hpp"
 #include "vktSynchronizationTimelineSemaphoreTests.hpp"
 #include "vktSynchronizationWin32KeyedMutexTests.hpp"
+#include "vktSynchronizationNoneStageTests.hpp"
 #include "vktSynchronizationUtil.hpp"
 
 #include "deUniquePtr.hpp"
@@ -100,6 +101,7 @@ tcu::TestCaseGroup* createTestsInternal (tcu::TestContext& testCtx, Synchronizat
        {
                testGroup->addChild(createSynchronization2SmokeTests(testCtx));
                testGroup->addChild(createSynchronization2TimelineSemaphoreTests(testCtx));
+               testGroup->addChild(createNoneStageTests(testCtx));
        }
        else // legacy synchronization
        {
index 649a5da..e4997dd 100644 (file)
@@ -26,6 +26,7 @@
 #include "vkCmdUtil.hpp"
 #include "vkBarrierUtil.hpp"
 #include "deStringUtil.hpp"
+#include <set>
 
 namespace vkt
 {
@@ -394,6 +395,98 @@ protected:
                std::size_t             signalSemaphoreValueIndexPlusOne;
        };
 
+       bool isStageFlagAllowed(VkPipelineStageFlags2KHR stage)
+       {
+               // synchronization2 suports more stages then legacy synchronization
+               // and so SynchronizationWrapper can only be used for cases that
+               // operate on stages also supported by legacy synchronization
+               // NOTE: if some tests hits assertion that uses this method then this
+               // test should not use synchronizationWrapper - it should be synchronization2 exclusive
+
+               static const std::set<deUint32> allowedStages
+               {
+                       VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                       VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+                       VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+                       VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+                       VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
+                       VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
+                       VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+                       VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+                       VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                       VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                       VK_PIPELINE_STAGE_HOST_BIT,
+                       VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+                       VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                       VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+                       VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
+                       VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
+                       VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
+                       VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
+                       VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
+                       VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
+                       VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
+                       VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
+                       VK_PIPELINE_STAGE_NONE_KHR,
+               };
+
+               if (stage > static_cast<deUint64>(std::numeric_limits<deUint32>::max()))
+                       return false;
+
+               return (allowedStages.find(static_cast<deUint32>(stage)) != allowedStages.end());
+       }
+
+       bool isAccessFlagAllowed(VkAccessFlags2KHR access)
+       {
+               // synchronization2 suports more access flags then legacy synchronization
+               // and so SynchronizationWrapper can only be used for cases that
+               // operate on access flags also supported by legacy synchronization
+               // NOTE: if some tests hits assertion that uses this method then this
+               // test should not use synchronizationWrapper - it should be synchronization2 exclusive
+
+               static const std::set<deUint32> allowedAccessFlags
+               {
+                       VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+                       VK_ACCESS_INDEX_READ_BIT,
+                       VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+                       VK_ACCESS_UNIFORM_READ_BIT,
+                       VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+                       VK_ACCESS_SHADER_READ_BIT,
+                       VK_ACCESS_SHADER_WRITE_BIT,
+                       VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                       VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+                       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                       VK_ACCESS_TRANSFER_READ_BIT,
+                       VK_ACCESS_TRANSFER_WRITE_BIT,
+                       VK_ACCESS_HOST_READ_BIT,
+                       VK_ACCESS_HOST_WRITE_BIT,
+                       VK_ACCESS_MEMORY_READ_BIT,
+                       VK_ACCESS_MEMORY_WRITE_BIT,
+                       VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+                       VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+                       VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+                       VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+                       VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+                       VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
+                       VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
+                       VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV ,
+                       VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
+                       VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV,
+                       VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV,
+                       VK_ACCESS_NONE_KHR,
+               };
+
+               if (access > static_cast<deUint64>(std::numeric_limits<deUint32>::max()))
+                       return false;
+
+               return (allowedAccessFlags.find(static_cast<deUint32>(access)) != allowedAccessFlags.end());
+       }
+
 public:
        LegacySynchronizationWrapper(const DeviceInterface& vk, bool usingTimelineSemaphores, deUint32 submitInfoCount = 1u)
                : SynchronizationWrapperBase    (vk)
@@ -447,6 +540,7 @@ public:
                        si.waitSemaphoreIndex = m_waitSemaphores.size();
                        for (deUint32 i = 0; i < waitSemaphoreInfoCount; ++i)
                        {
+                               DE_ASSERT(isStageFlagAllowed(pWaitSemaphoreInfos[i].stageMask));
                                m_waitSemaphores.push_back(pWaitSemaphoreInfos[i].semaphore);
                                m_waitDstStageMasks.push_back(static_cast<VkPipelineStageFlags>(pWaitSemaphoreInfos[i].stageMask));
                        }
@@ -469,7 +563,7 @@ public:
                }
        }
 
-       void cmdPipelineBarrier(VkCommandBuffer commandBuffer, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                DE_ASSERT(pDependencyInfo);
 
@@ -490,6 +584,12 @@ public:
                        for (deUint32 i = 0; i < memoryBarrierCount; ++i)
                        {
                                const VkMemoryBarrier2KHR& pMemoryBarrier = pDependencyInfo->pMemoryBarriers[i];
+
+                               DE_ASSERT(isStageFlagAllowed(pMemoryBarrier.srcStageMask));
+                               DE_ASSERT(isStageFlagAllowed(pMemoryBarrier.dstStageMask));
+                               DE_ASSERT(isAccessFlagAllowed(pMemoryBarrier.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(pMemoryBarrier.dstAccessMask));
+
                                srcStageMask |= static_cast<VkPipelineStageFlags>(pMemoryBarrier.srcStageMask);
                                dstStageMask |= static_cast<VkPipelineStageFlags>(pMemoryBarrier.dstStageMask);
                                memoryBarriers.push_back(makeMemoryBarrier(
@@ -508,6 +608,12 @@ public:
                        for (deUint32 i = 0; i < bufferMemoryBarrierCount; ++i)
                        {
                                const VkBufferMemoryBarrier2KHR& pBufferMemoryBarrier = pDependencyInfo->pBufferMemoryBarriers[i];
+
+                               DE_ASSERT(isStageFlagAllowed(pBufferMemoryBarrier.srcStageMask));
+                               DE_ASSERT(isStageFlagAllowed(pBufferMemoryBarrier.dstStageMask));
+                               DE_ASSERT(isAccessFlagAllowed(pBufferMemoryBarrier.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(pBufferMemoryBarrier.dstAccessMask));
+
                                srcStageMask |= static_cast<VkPipelineStageFlags>(pBufferMemoryBarrier.srcStageMask);
                                dstStageMask |= static_cast<VkPipelineStageFlags>(pBufferMemoryBarrier.dstStageMask);
                                bufferMemoryBarriers.push_back(makeBufferMemoryBarrier(
@@ -531,6 +637,12 @@ public:
                        for (deUint32 i = 0; i < imageMemoryBarrierCount; ++i)
                        {
                                const VkImageMemoryBarrier2KHR& pImageMemoryBarrier = pDependencyInfo->pImageMemoryBarriers[i];
+
+                               DE_ASSERT(isStageFlagAllowed(pImageMemoryBarrier.srcStageMask));
+                               DE_ASSERT(isStageFlagAllowed(pImageMemoryBarrier.dstStageMask));
+                               DE_ASSERT(isAccessFlagAllowed(pImageMemoryBarrier.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(pImageMemoryBarrier.dstAccessMask));
+
                                srcStageMask |= static_cast<VkPipelineStageFlags>(pImageMemoryBarrier.srcStageMask);
                                dstStageMask |= static_cast<VkPipelineStageFlags>(pImageMemoryBarrier.dstStageMask);
                                imageMemoryBarriers.push_back(makeImageMemoryBarrier(
@@ -561,7 +673,7 @@ public:
                );
        }
 
-       void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                DE_ASSERT(pDependencyInfo);
 
@@ -573,16 +685,18 @@ public:
                if (pDependencyInfo->pImageMemoryBarriers)
                        srcStageMask = pDependencyInfo->pImageMemoryBarriers[0].srcStageMask;
 
+               DE_ASSERT(isStageFlagAllowed(srcStageMask));
                m_vk.cmdSetEvent(commandBuffer, event, static_cast<VkPipelineStageFlags>(srcStageMask));
        }
 
        void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR flag) override
        {
+               DE_ASSERT(isStageFlagAllowed(flag));
                VkPipelineStageFlags legacyStageMask = static_cast<VkPipelineStageFlags>(flag);
                m_vk.cmdResetEvent(commandBuffer, event, legacyStageMask);
        }
 
-       void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                DE_ASSERT(pDependencyInfo);
 
@@ -607,6 +721,8 @@ public:
                        for (deUint32 i = 0; i < memoryBarrierCount; ++i)
                        {
                                const VkMemoryBarrier2KHR& mb = pDependencyInfo->pMemoryBarriers[i];
+                               DE_ASSERT(isAccessFlagAllowed(mb.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(mb.dstAccessMask));
                                memoryBarriers.push_back(
                                        makeMemoryBarrier(
                                                static_cast<VkAccessFlags>(mb.srcAccessMask),
@@ -625,6 +741,8 @@ public:
                        for (deUint32 i = 0; i < bufferMemoryBarrierCount; ++i)
                        {
                                const VkBufferMemoryBarrier2KHR& bmb = pDependencyInfo->pBufferMemoryBarriers[i];
+                               DE_ASSERT(isAccessFlagAllowed(bmb.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(bmb.dstAccessMask));
                                bufferMemoryBarriers.push_back(
                                        makeBufferMemoryBarrier(
                                                static_cast<VkAccessFlags>(bmb.srcAccessMask),
@@ -648,6 +766,8 @@ public:
                        for (deUint32 i = 0; i < imageMemoryBarrierCount; ++i)
                        {
                                const VkImageMemoryBarrier2KHR& imb = pDependencyInfo->pImageMemoryBarriers[i];
+                               DE_ASSERT(isAccessFlagAllowed(imb.srcAccessMask));
+                               DE_ASSERT(isAccessFlagAllowed(imb.dstAccessMask));
                                imageMemoryBarriers.push_back(
                                        makeImageMemoryBarrier(
                                                static_cast<VkAccessFlags>(imb.srcAccessMask),
@@ -664,6 +784,8 @@ public:
                        pImageMemoryBarriers = &imageMemoryBarriers[0];
                }
 
+               DE_ASSERT(isStageFlagAllowed(srcStageMask));
+               DE_ASSERT(isStageFlagAllowed(dstStageMask));
                m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents,
                        static_cast<VkPipelineStageFlags>(srcStageMask), static_cast<VkPipelineStageFlags>(dstStageMask),
                        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
@@ -777,17 +899,17 @@ public:
                });
        }
 
-       void cmdPipelineBarrier(VkCommandBuffer commandBuffer, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                m_vk.cmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
        }
 
-       void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                m_vk.cmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
        }
 
-       void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkDependencyInfoKHR* pDependencyInfo) override
+       void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfo) override
        {
                m_vk.cmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfo);
        }
index 44fd1c1..f167bd4 100644 (file)
@@ -198,18 +198,18 @@ public:
                                                                                                 bool                                                                           usingSignalTimelineSemaphore = DE_FALSE) = 0;
 
        virtual void                    cmdPipelineBarrier      (vk::VkCommandBuffer                                            commandBuffer,
-                                                                                                vk::VkDependencyInfoKHR*                                       pDependencyInfo) = 0;
+                                                                                                const vk::VkDependencyInfoKHR*                         pDependencyInfo) = 0;
 
        virtual void                    cmdSetEvent                     (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 vk::VkEvent                                                            event,
-                                                                                                vk::VkDependencyInfoKHR*                                       pDependencyInfo) = 0;
+                                                                                                const vk::VkDependencyInfoKHR*                         pDependencyInfo) = 0;
        virtual void                    cmdResetEvent           (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 vk::VkEvent                                                            event,
                                                                                                 vk::VkPipelineStageFlags2KHR                           flag) = 0;
        virtual void                    cmdWaitEvents           (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 deUint32                                                                       eventCount,
                                                                                                 const vk::VkEvent*                                                     pEvents,
-                                                                                                vk::VkDependencyInfoKHR*                                       pDependencyInfo) = 0;
+                                                                                                const vk::VkDependencyInfoKHR*                         pDependencyInfo) = 0;
 
        virtual vk::VkResult    queueSubmit                     (vk::VkQueue                                                            queue,
                                                                                                 vk::VkFence                                                            fence) = 0;
index 0d126f2..6e54d77 100644 (file)
@@ -608977,10 +608977,229 @@ dEQP-VK.synchronization2.timeline_semaphore.wait.one_signal_from_host
 dEQP-VK.synchronization2.timeline_semaphore.wait.host_wait_before_signal
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_device
 dEQP-VK.synchronization2.timeline_semaphore.wait.poll_signal_from_host
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.general_to_general
+dEQP-VK.synchronization2.none_stage.general_to_shader_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_general_to_general
+dEQP-VK.synchronization2.none_stage.old_access_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.old_access_generic_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_general
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_transfer_dst_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_general_to_general
+dEQP-VK.synchronization2.none_stage.legacy_general_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_general_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_stencil_attachment_to_generic_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_color_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_attachment_to_generic_depth_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_stencil_attachment_to_generic_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_transfer_src
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_general
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_shader_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_read_stencil_attachment
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_depth_attachment_stencil_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_color_read
+dEQP-VK.synchronization2.none_stage.legacy_generic_depth_stencil_attachment_to_generic_depth_stencil_read
 dEQP-VK.synchronization2.basic.event.device_set_reset
 dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer
 dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer
+dEQP-VK.synchronization2.basic.event.single_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_submit_multi_command_buffer_device_only
+dEQP-VK.synchronization2.basic.event.multi_secondary_command_buffer_device_only
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.multi_queue
 dEQP-VK.synchronization2.basic.binary_semaphore.one_queue_typed