From 7c07b8294d2ee0ca4741e2ed377970ee8a3f5215 Mon Sep 17 00:00:00 2001 From: Toni Merilehti Date: Tue, 4 Sep 2018 10:49:25 +0300 Subject: [PATCH] Add tests for subpass dependencies New tests for external subpass dependencies between render pass instances as well as implicitly added subpass dependencies. Tests verify that the render passes are synchronized correctly using external subpass dependencies. Also the conversion functions to RenderPass/RenderPass2 are now implemented in vktRenderPassTestsUtil. New tests: dEQP-VK.renderpass*.subpass_dependencies.* Components: Vulkan VK-GL-CTS issue: 1143, 1148 VK-GL-CTS public issue: 97 Change-Id: Icc73a8cfc137ed6d64246c451cee1b1293c1d11b --- AndroidGen.mk | 1 + android/cts/master/vk-master.txt | 36 + .../modules/vulkan/renderpass/CMakeLists.txt | 2 + .../vktRenderPassMultisampleResolveTests.cpp | 6 - .../renderpass/vktRenderPassMultisampleTests.cpp | 6 - .../renderpass/vktRenderPassSampleReadTests.cpp | 6 - .../vktRenderPassSparseRenderTargetTests.cpp | 6 - .../vktRenderPassSubpassDependencyTests.cpp | 1028 ++++++++++++++++++++ .../vktRenderPassSubpassDependencyTests.hpp | 38 + .../vulkan/renderpass/vktRenderPassTests.cpp | 9 +- .../vulkan/renderpass/vktRenderPassTestsUtil.cpp | 430 +++++++- .../vulkan/renderpass/vktRenderPassTestsUtil.hpp | 166 ++++ .../mustpass/1.1.3/vk-default-no-waivers.txt | 36 + external/vulkancts/mustpass/1.1.3/vk-default.txt | 36 + 14 files changed, 1775 insertions(+), 31 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.cpp create mode 100644 external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.hpp diff --git a/AndroidGen.mk b/AndroidGen.mk index e5befa8..b3e0978 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -214,6 +214,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassSampleReadTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassSparseRenderTargetTests.cpp \ + external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassUnusedAttachmentTests.cpp \ diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index e7fe93c..a010679 100755 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -255001,6 +255001,18 @@ dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint. dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.dedicated_allocation.simple.color dEQP-VK.renderpass.dedicated_allocation.simple.depth dEQP-VK.renderpass.dedicated_allocation.simple.stencil @@ -261592,6 +261604,18 @@ dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.sampleread.numsamples_2_add dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_0 dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_1 @@ -266498,6 +266522,18 @@ dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass2.dedicated_allocation.simple.color dEQP-VK.renderpass2.dedicated_allocation.simple.depth dEQP-VK.renderpass2.dedicated_allocation.simple.stencil diff --git a/external/vulkancts/modules/vulkan/renderpass/CMakeLists.txt b/external/vulkancts/modules/vulkan/renderpass/CMakeLists.txt index 9201f54..16734d4 100644 --- a/external/vulkancts/modules/vulkan/renderpass/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/renderpass/CMakeLists.txt @@ -15,6 +15,8 @@ set(DEQP_VK_RENDER_PASS_SRCS vktRenderPassSampleReadTests.hpp vktRenderPassSparseRenderTargetTests.cpp vktRenderPassSparseRenderTargetTests.hpp + vktRenderPassSubpassDependencyTests.cpp + vktRenderPassSubpassDependencyTests.hpp vktRenderPassUnusedAttachmentTests.cpp vktRenderPassUnusedAttachmentTests.hpp ) diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp index 36d0e77..0248889 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp @@ -93,12 +93,6 @@ enum MAX_COLOR_ATTACHMENT_COUNT = 4u }; -enum RenderPassType -{ - RENDERPASS_TYPE_LEGACY = 0, - RENDERPASS_TYPE_RENDERPASS2, -}; - template de::SharedPtr safeSharedPtr (T* ptr) { diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleTests.cpp index 8f2371d..6160afa 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleTests.cpp @@ -91,12 +91,6 @@ enum MAX_COLOR_ATTACHMENT_COUNT = 4u }; -enum RenderPassType -{ - RENDERPASS_TYPE_LEGACY = 0, - RENDERPASS_TYPE_RENDERPASS2, -}; - template de::SharedPtr safeSharedPtr (T* ptr) { diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSampleReadTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSampleReadTests.cpp index 4f54852..259c1c4 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSampleReadTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSampleReadTests.cpp @@ -62,12 +62,6 @@ namespace { using namespace renderpass; -enum RenderPassType -{ - RENDERPASS_TYPE_LEGACY = 0, - RENDERPASS_TYPE_RENDERPASS2, -}; - de::MovePtr createBufferMemory (const DeviceInterface& vk, VkDevice device, Allocator& allocator, diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSparseRenderTargetTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSparseRenderTargetTests.cpp index e0c9c5d..19f308d 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSparseRenderTargetTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSparseRenderTargetTests.cpp @@ -64,12 +64,6 @@ namespace { using namespace renderpass; -enum RenderPassType -{ - RENDERPASS_TYPE_LEGACY = 0, - RENDERPASS_TYPE_RENDERPASS2, -}; - de::MovePtr createBufferMemory (const DeviceInterface& vk, VkDevice device, Allocator& allocator, diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.cpp new file mode 100644 index 0000000..3a2f308 --- /dev/null +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.cpp @@ -0,0 +1,1028 @@ +/*------------------------------------------------------------------------- + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2018 Google Inc. + * Copyright (c) 2018 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 sparse render target. + *//*--------------------------------------------------------------------*/ + +#include "vktRenderPassSubpassDependencyTests.hpp" +#include "vktRenderPassTestsUtil.hpp" + +#include "vktTestCaseUtil.hpp" +#include "vktTestGroupUtil.hpp" +#include "vkImageUtil.hpp" +#include "vkQueryUtil.hpp" +#include "vkRefUtil.hpp" +#include "vkCmdUtil.hpp" +#include "vkObjUtil.hpp" + +#include "tcuImageCompare.hpp" +#include "tcuResultCollector.hpp" +#include "tcuTextureUtil.hpp" + +using namespace vk; + +using tcu::UVec4; +using tcu::Vec2; +using tcu::UVec2; +using tcu::Vec4; + +using tcu::ConstPixelBufferAccess; +using tcu::PixelBufferAccess; + +using tcu::TestLog; + +using std::string; +using std::vector; +using de::SharedPtr; + +typedef de::SharedPtr > SharedPtrVkImage; +typedef de::SharedPtr > SharedPtrVkImageView; +typedef de::SharedPtr > SharedPtrVkPipeline; +typedef de::SharedPtr > SharedPtrVkSampler; +typedef de::SharedPtr > SharedPtrVkRenderPass; +typedef de::SharedPtr > SharedPtrVkFramebuffer; +typedef de::SharedPtr > SharedPtrVkDescriptorPool; +typedef de::SharedPtr > SharedPtrVkDescriptorLayout; +typedef de::SharedPtr > SharedPtrVkDescriptorSet; +typedef de::SharedPtr > SharedPtrVkPipelineLayout; +typedef de::SharedPtr > SharedPtrVkPipeline; + +namespace vkt +{ +namespace +{ +using namespace renderpass; + +template +inline SharedPtr > makeSharedPtr(Move move) +{ + return SharedPtr >(new Unique(move)); +} + +de::MovePtr createBufferMemory (const DeviceInterface& vk, + VkDevice device, + Allocator& allocator, + VkBuffer buffer) +{ + de::MovePtr allocation (allocator.allocate(getBufferMemoryRequirements(vk, device, buffer), MemoryRequirement::HostVisible)); + + VK_CHECK(vk.bindBufferMemory(device, buffer, allocation->getMemory(), allocation->getOffset())); + return allocation; +} + +vector createAndAllocateImages (const DeviceInterface& vk, + VkDevice device, + Allocator& allocator, + vector >& imageMemories, + deUint32 universalQueueFamilyIndex, + VkFormat format, + deUint32 width, + deUint32 height, + vector renderPasses) +{ + vector images; + + for (size_t imageNdx = 0; imageNdx < renderPasses.size(); imageNdx++) + { + const VkExtent3D imageExtent = + { + width, // uint32_t width + height, // uint32_t height + 1u // uint32_t depth + }; + + const VkImageCreateInfo imageCreateInfo = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + 0u, // VkImageCreateFlags flags + VK_IMAGE_TYPE_2D, // VkImageType imageType + format, // VkFormat format + imageExtent, // VkExtent3D extent + 1u, // uint32_t mipLevels + 1u, // uint32_t arrayLayers + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + | VK_IMAGE_USAGE_SAMPLED_BIT + | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode + 1u, // uint32_t queueFamilyIndexCount + &universalQueueFamilyIndex, // const uint32_t* pQueueFamilyIndices + VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout + }; + + images.push_back(makeSharedPtr(vk::createImage(vk, device, &imageCreateInfo, DE_NULL))); + imageMemories.push_back((de::SharedPtr)allocator.allocate(getImageMemoryRequirements(vk, device, **images[imageNdx]), MemoryRequirement::Any).release()); + VK_CHECK(vk.bindImageMemory(device, **images[imageNdx], imageMemories[imageNdx]->getMemory(), imageMemories[imageNdx]->getOffset())); + } + + return images; +} + +Move createImageView (const DeviceInterface& vk, + VkDevice device, + VkImageViewCreateFlags flags, + VkImage image, + VkImageViewType viewType, + VkFormat format, + VkComponentMapping components, + VkImageSubresourceRange subresourceRange) +{ + const VkImageViewCreateInfo pCreateInfo = + { + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + flags, // VkImageViewCreateFlags flags + image, // VkImage image + viewType, // VkImageViewType viewType + format, // VkFormat format + components, // VkComponentMapping components + subresourceRange, // VkImageSubresourceRange subresourceRange + }; + + return createImageView(vk, device, &pCreateInfo);; +} + +vector createImageViews (const DeviceInterface& vkd, + VkDevice device, + vector images, + VkFormat format, + VkImageAspectFlags aspect) +{ + vector imageViews; + + for (size_t imageViewNdx = 0; imageViewNdx < images.size(); imageViewNdx++) + { + const VkImageSubresourceRange range = + { + aspect, // VkImageAspectFlags aspectMask + 0u, // uint32_t baseMipLevel + 1u, // uint32_t levelCount + 0u, // uint32_t baseArrayLayer + 1u // uint32_t layerCount + }; + + imageViews.push_back(makeSharedPtr(createImageView(vkd, device, 0u, **images[imageViewNdx], VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range))); + } + + return imageViews; +} + +vector createSamplers (const DeviceInterface& vkd, + const VkDevice device, + vector& renderPasses) +{ + vector samplers; + + for (size_t samplerNdx = 0; samplerNdx < renderPasses.size() - 1; samplerNdx++) + { + 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 + VK_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 unnormalizedCoordinates + }; + + samplers.push_back(makeSharedPtr(createSampler(vkd, device, &samplerInfo))); + } + + return samplers; +} + +Move createBuffer (const DeviceInterface& vkd, + VkDevice device, + VkFormat format, + deUint32 width, + deUint32 height) +{ + const VkBufferUsageFlags bufferUsage (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); + const VkDeviceSize pixelSize = mapVkFormat(format).getPixelSize(); + const VkBufferCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + 0u, // VkBufferCreateFlags flags + width * height * pixelSize, // VkDeviceSize size + bufferUsage, // VkBufferUsageFlags usage + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode + 0u, // uint32_t queueFamilyIndexCount + DE_NULL // const uint32_t* pQueueFamilyIndices + }; + + return createBuffer(vkd, device, &createInfo); +} + +vector createRenderPasses (const DeviceInterface& vkd, + VkDevice device, + vector renderPassInfos, + const RenderPassType renderPassType) +{ + vector renderPasses; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPassInfos.size(); renderPassNdx++) + { + renderPasses.push_back(makeSharedPtr(createRenderPass(vkd, device, renderPassInfos[renderPassNdx], renderPassType))); + } + + return renderPasses; +} + +vector createFramebuffers (const DeviceInterface& vkd, + VkDevice device, + vector& renderPasses, + vector& dstImageViews, + deUint32 width, + deUint32 height) +{ + vector framebuffers; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPasses.size(); renderPassNdx++) + { + VkRenderPass renderPass (**renderPasses[renderPassNdx]); + + const VkFramebufferCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + 0u, // VkFramebufferCreateFlags flags + renderPass, // VkRenderPass renderPass + 1u, // uint32_t attachmentCount + &**dstImageViews[renderPassNdx], // const VkImageView* pAttachments + width, // uint32_t width + height, // uint32_t height + 1u // uint32_t layers + }; + + framebuffers.push_back(makeSharedPtr(createFramebuffer(vkd, device, &createInfo))); + } + + return framebuffers; +} + +vector createDescriptorSetLayouts (const DeviceInterface& vkd, + VkDevice device, + vector& samplers) +{ + vector layouts; + + for (size_t layoutNdx = 0; layoutNdx < samplers.size(); layoutNdx++) + { + const VkDescriptorSetLayoutBinding bindings = + { + 0u, // uint32_t binding + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // VkDescriptorType descriptorType + 1u, // uint32_t descriptorCount + VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags + &**samplers[layoutNdx] // const VkSampler* pImmutableSamplers + }; + + const VkDescriptorSetLayoutCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + 0u, // VkDescriptorSetLayoutCreateFlags flags + 1u, // uint32_t bindingCount + &bindings // const VkDescriptorSetLayoutBinding* pBindings + }; + + layouts.push_back(makeSharedPtr(createDescriptorSetLayout(vkd, device, &createInfo))); + } + + return layouts; +} + +vector createDescriptorPools (const DeviceInterface& vkd, + VkDevice device, + vector& layouts) +{ + vector descriptorPools; + + for (size_t poolNdx = 0; poolNdx < layouts.size(); poolNdx++) + { + const VkDescriptorPoolSize size = + { + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // VkDescriptorType type + 1u // uint32_t descriptorCount + }; + + const VkDescriptorPoolCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, // VkDescriptorPoolCreateFlags flags + 1u, // uint32_t maxSets + 1u, // uint32_t poolSizeCount + &size // const VkDescriptorPoolSize* pPoolSizes + }; + + descriptorPools.push_back(makeSharedPtr(createDescriptorPool(vkd, device, &createInfo))); + } + + return descriptorPools; +} + +vector createDescriptorSets (const DeviceInterface& vkd, + VkDevice device, + vector& pools, + vector& layouts, + vector& imageViews, + vector& samplers) +{ + vector descriptorSets; + + for (size_t setNdx = 0; setNdx < layouts.size(); setNdx++) + { + const VkDescriptorSetAllocateInfo allocateInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + **pools[setNdx], // VkDescriptorPool descriptorPool + 1u, // uint32_t descriptorSetCount + &**layouts[setNdx] // const VkDescriptorSetLayout* pSetLayouts + }; + + descriptorSets.push_back(makeSharedPtr(allocateDescriptorSet(vkd, device, &allocateInfo))); + + { + const VkDescriptorImageInfo imageInfo = + { + **samplers[setNdx], // VkSampler sampler + **imageViews[setNdx], // VkImageView imageView + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL // VkImageLayout imageLayout + }; + + const VkWriteDescriptorSet write = + { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType + DE_NULL, // const void* pNext + **descriptorSets[setNdx], // VkDescriptorSet dstSet + 0u, // uint32_t dstBinding + 0u, // uint32_t dstArrayElement + 1u, // uint32_t descriptorCount + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // VkDescriptorType descriptorType + &imageInfo, // const VkDescriptorImageInfo* pImageInfo + DE_NULL, // const VkDescriptorBufferInfo* pBufferInfo + DE_NULL // const VkBufferView* pTexelBufferView + }; + + vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); + } + } + + return descriptorSets; +} + +vector createRenderPipelineLayouts (const DeviceInterface& vkd, + VkDevice device, + vector& renderPasses, + vector& descriptorSetLayouts) +{ + vector pipelineLayouts; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPasses.size(); renderPassNdx++) + { + const VkPipelineLayoutCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + (vk::VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags + renderPassNdx > 0 ? 1u : 0u, // deUint32 setLayoutCount + renderPassNdx > 0 ? &**descriptorSetLayouts[renderPassNdx - 1] : DE_NULL, // const VkDescriptorSetLayout* pSetLayouts + 0u, // deUint32 pushConstantRangeCount + DE_NULL // const VkPushConstantRange* pPushConstantRanges + }; + + pipelineLayouts.push_back(makeSharedPtr(createPipelineLayout(vkd, device, &createInfo))); + } + + return pipelineLayouts; +} + +vector createRenderPipelines (const DeviceInterface& vkd, + VkDevice device, + vector& renderPasses, + vector& pipelineLayouts, + const BinaryCollection& binaryCollection, + deUint32 width, + deUint32 height) +{ + vector pipelines; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPasses.size(); renderPassNdx++) + { + const Unique vertexShaderModule (createShaderModule(vkd, device, binaryCollection.get("quad-vert-" + de::toString(renderPassNdx)), 0u)); + const Unique fragmentShaderModule (createShaderModule(vkd, device, binaryCollection.get("quad-frag-" + de::toString(renderPassNdx)), 0u)); + + const VkPipelineVertexInputStateCreateInfo vertexInputState = + { + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + (VkPipelineVertexInputStateCreateFlags)0u, // VkPipelineVertexInputStateCreateFlags flags + 0u, // uint32_t vertexBindingDescriptionCount + DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions + 0u, // uint32_t vertexAttributeDescriptionCount + DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + }; + + const std::vector viewports (1, makeViewport(tcu::UVec2(width, height))); + const std::vector scissors (1, makeRect2D(tcu::UVec2(width, height))); + const VkRenderPass renderPass (**renderPasses[renderPassNdx]); + const VkPipelineLayout layout (**pipelineLayouts[renderPassNdx]); + + pipelines.push_back(makeSharedPtr(makeGraphicsPipeline(vkd, // const DeviceInterface& vk + device, // const VkDevice device + layout, // const VkPipelineLayout pipelineLayout + *vertexShaderModule, // const VkShaderModule vertexShaderModule + DE_NULL, // const VkShaderModule tessellationControlShaderModule + DE_NULL, // const VkShaderModule tessellationEvalShaderModule + DE_NULL, // const VkShaderModule geometryShaderModule + *fragmentShaderModule, // const VkShaderModule fragmentShaderModule + renderPass, // const VkRenderPass renderPass + viewports, // const std::vector& viewports + scissors, // const std::vector& scissors + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology + 0u, // const deUint32 subpass + 0u, // const deUint32 patchControlPoints + &vertexInputState))); // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo + } + + return pipelines; +} + +struct TestConfig +{ + TestConfig (VkFormat format_, + UVec2 imageSize_, + vector renderPasses_, + RenderPassType renderPassType_, + deUint32 blurKernel_ = 4) + : format (format_) + , imageSize (imageSize_) + , renderPasses (renderPasses_) + , renderPassType (renderPassType_) + , blurKernel (blurKernel_) + { + } + + VkFormat format; + UVec2 imageSize; + vector renderPasses; + RenderPassType renderPassType; + deUint32 blurKernel; +}; + +class SubpassDependencyTestInstance : public TestInstance +{ +public: + SubpassDependencyTestInstance (Context& context, TestConfig testConfig); + ~SubpassDependencyTestInstance (void); + + tcu::TestStatus iterate (void); + + template + tcu::TestStatus iterateInternal (void); + +private: + const bool m_extensionSupported; + const RenderPassType m_renderPassType; + + const deUint32 m_width; + const deUint32 m_height; + const deUint32 m_blurKernel; + const VkFormat m_format; + + vector > m_imageMemories; + vector m_images; + vector m_imageViews; + vector m_samplers; + + const Unique m_dstBuffer; + const de::UniquePtr m_dstBufferMemory; + + vector m_renderPasses; + vector m_framebuffers; + + vector m_subpassDescriptorSetLayouts; + vector m_subpassDescriptorPools; + vector m_subpassDescriptorSets; + + vector m_renderPipelineLayouts; + vector m_renderPipelines; + + const Unique m_commandPool; + tcu::ResultCollector m_resultCollector; +}; + +SubpassDependencyTestInstance::SubpassDependencyTestInstance (Context& context, TestConfig testConfig) + : TestInstance (context) + , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2")) + , m_renderPassType (testConfig.renderPassType) + , m_width (testConfig.imageSize.x()) + , m_height (testConfig.imageSize.y()) + , m_blurKernel (testConfig.blurKernel) + , m_format (testConfig.format) + , m_images (createAndAllocateImages(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), m_imageMemories, context.getUniversalQueueFamilyIndex(), m_format, m_width, m_height, testConfig.renderPasses)) + , m_imageViews (createImageViews(context.getDeviceInterface(), context.getDevice(), m_images, m_format, VK_IMAGE_ASPECT_COLOR_BIT)) + , m_samplers (createSamplers(context.getDeviceInterface(), context.getDevice(), testConfig.renderPasses)) + , m_dstBuffer (createBuffer(context.getDeviceInterface(), context.getDevice(), m_format, m_width, m_height)) + , m_dstBufferMemory (createBufferMemory(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), *m_dstBuffer)) + , m_renderPasses (createRenderPasses(context.getDeviceInterface(), context.getDevice(), testConfig.renderPasses, testConfig.renderPassType)) + , m_framebuffers (createFramebuffers(context.getDeviceInterface(), context.getDevice(), m_renderPasses, m_imageViews, m_width, m_height)) + , m_subpassDescriptorSetLayouts (createDescriptorSetLayouts(context.getDeviceInterface(), context.getDevice(), m_samplers)) + , m_subpassDescriptorPools (createDescriptorPools(context.getDeviceInterface(), context.getDevice(), m_subpassDescriptorSetLayouts)) + , m_subpassDescriptorSets (createDescriptorSets(context.getDeviceInterface(), context.getDevice(), m_subpassDescriptorPools, m_subpassDescriptorSetLayouts, m_imageViews, m_samplers)) + , m_renderPipelineLayouts (createRenderPipelineLayouts(context.getDeviceInterface(), context.getDevice(), m_renderPasses, m_subpassDescriptorSetLayouts)) + , m_renderPipelines (createRenderPipelines(context.getDeviceInterface(), context.getDevice(), m_renderPasses, m_renderPipelineLayouts, context.getBinaryCollection(), m_width, m_height)) + , m_commandPool (createCommandPool(context.getDeviceInterface(), context.getDevice(), VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, context.getUniversalQueueFamilyIndex())) +{ +} + +SubpassDependencyTestInstance::~SubpassDependencyTestInstance (void) +{ +} + +tcu::TestStatus SubpassDependencyTestInstance::iterate (void) +{ + switch (m_renderPassType) + { + case RENDERPASS_TYPE_LEGACY: + return iterateInternal(); + case RENDERPASS_TYPE_RENDERPASS2: + return iterateInternal(); + default: + TCU_THROW(InternalError, "Impossible"); + } +} + +template +tcu::TestStatus SubpassDependencyTestInstance::iterateInternal (void) +{ + const DeviceInterface& vkd (m_context.getDeviceInterface()); + const Unique commandBuffer (allocateCommandBuffer(vkd, m_context.getDevice(), *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); + const typename RenderpassSubpass::SubpassBeginInfo subpassBeginInfo (DE_NULL, VK_SUBPASS_CONTENTS_INLINE); + const typename RenderpassSubpass::SubpassEndInfo subpassEndInfo (DE_NULL); + + beginCommandBuffer(vkd, *commandBuffer); + + for (size_t renderPassNdx = 0; renderPassNdx < m_renderPasses.size(); renderPassNdx++) + { + // Begin render pass + { + VkRect2D renderArea = + { + { 0u, 0u }, // VkOffset2D offset + { m_width, m_height } // VkExtent2D extent + }; + + const VkRenderPassBeginInfo beginInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType + DE_NULL, // const void* pNext + **m_renderPasses[renderPassNdx], // VkRenderPass renderPass + **m_framebuffers[renderPassNdx], // VkFramebuffer framebuffer + renderArea, // VkRect2D renderArea + 0u, // uint32_t clearValueCount + DE_NULL // const VkClearValue* pClearValues + }; + + RenderpassSubpass::cmdBeginRenderPass(vkd, *commandBuffer, &beginInfo, &subpassBeginInfo); + } + + vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_renderPipelines[renderPassNdx]); + + // Use results from the previous pass as input texture + if (renderPassNdx > 0) + vkd.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_renderPipelineLayouts[renderPassNdx], 0, 1, &**m_subpassDescriptorSets[renderPassNdx - 1], 0, DE_NULL); + + vkd.cmdDraw(*commandBuffer, 6u, 1u, 0u, 0u); + + RenderpassSubpass::cmdEndRenderPass(vkd, *commandBuffer, &subpassEndInfo); + } + + // Memory barrier between rendering and copy + { + VkImageSubresourceRange imageSubresourceRange = + { + VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask + 0u, // uint32_t baseMipLevel + 1u, // uint32_t levelCount + 0u, // uint32_t baseArrayLayer + 1u // uint32_t layerCount + }; + + const VkImageMemoryBarrier barrier = + { + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType + DE_NULL, // const void* pNext + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask + VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // VkImageLayout oldLayout + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout + VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex + VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex + **m_images[m_renderPasses.size() - 1], // VkImage image + imageSubresourceRange // VkImageSubresourceRange subresourceRange + }; + + vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &barrier); + } + + // Copy image memory to buffer + { + const VkImageSubresourceLayers imageSubresourceLayers = + { + VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask + 0u, // deUint32 mipLevel + 0u, // deUint32 baseArrayLayer + 1u // deUint32 layerCount + }; + + const VkBufferImageCopy region = + { + 0u, // VkDeviceSize bufferOffset + 0u, // uint32_t bufferRowLength + 0u, // uint32_t bufferImageHeight + imageSubresourceLayers, // VkImageSubresourceLayers imageSubresource + { 0u, 0u, 0u }, // VkOffset3D imageOffset + { m_width, m_height, 1u } // VkExtent3D imageExtent + }; + + vkd.cmdCopyImageToBuffer(*commandBuffer, **m_images[m_renderPasses.size() - 1], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_dstBuffer, 1u, ®ion); + } + + // Memory barrier between copy and host access + { + const VkBufferMemoryBarrier barrier = + { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType + DE_NULL, // const void* pNext + VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask + VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask + VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex + VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex + *m_dstBuffer, // VkBuffer buffer + 0u, // VkDeviceSize offset + VK_WHOLE_SIZE // VkDeviceSize size + }; + + vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &barrier, 0u, DE_NULL); + } + + endCommandBuffer(vkd, *commandBuffer); + submitCommandsAndWait(vkd, m_context.getDevice(), m_context.getUniversalQueue(), *commandBuffer); + invalidateMappedMemoryRange(vkd, m_context.getDevice(), m_dstBufferMemory->getMemory(), m_dstBufferMemory->getOffset(), VK_WHOLE_SIZE); + + { + const tcu::TextureFormat format (mapVkFormat(m_format)); + const void* const ptr (m_dstBufferMemory->getHostPtr()); + const tcu::ConstPixelBufferAccess access (format, m_width, m_height, 1, ptr); + tcu::TextureLevel reference (format, m_width, m_height); + tcu::TextureLevel textureA (format, m_width, m_height); + tcu::TextureLevel textureB (format, m_width, m_height); + + for (deUint32 renderPassNdx = 0; renderPassNdx < m_renderPasses.size(); renderPassNdx++) + { + // First pass renders four quads of different color, which will be blurred in the following passes + if (renderPassNdx == 0) + { + for (deUint32 y = 0; y < m_height; y++) + for (deUint32 x = 0; x < m_width; x++) + { + if (x <= (m_width - 1) / 2 && y <= (m_height - 1) / 2) + textureA.getAccess().setPixel(Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y); + else if (x > (m_width - 1) / 2 && y <= (m_height - 1) / 2) + textureA.getAccess().setPixel(Vec4(0.0f, 1.0f, 0.0f, 1.0f), x, y); + else if (x <= (m_width - 1) / 2 && y > (m_height - 1) / 2) + textureA.getAccess().setPixel(Vec4(0.0f, 0.0f, 1.0f, 1.0f), x, y); + else + textureA.getAccess().setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), x, y); + } + } + // Blur previous pass + else + { + for (deUint32 y = 0; y < m_height; y++) + for (deUint32 x = 0; x < m_width; x++) + { + Vec4 blurColor (Vec4(0.0)); + + for (deUint32 sampleNdx = 0; sampleNdx < (m_blurKernel + 1); sampleNdx++) + { + if (renderPassNdx % 2 == 0) + { + // Do a horizontal blur + blurColor += 0.12f * textureB.getAccess().getPixel(deClamp32((deInt32)x - (m_blurKernel / 2) + sampleNdx, 0u, m_width - 1u), y); + } + else + { + // Do a vertical blur + blurColor += 0.12f * textureA.getAccess().getPixel(x, deClamp32((deInt32)y - (m_blurKernel / 2) + sampleNdx, 0u, m_height - 1u)); + } + } + + renderPassNdx % 2 == 0 ? textureA.getAccess().setPixel(blurColor, x, y) : textureB.getAccess().setPixel(blurColor, x, y); + } + } + } + + reference = m_renderPasses.size() % 2 == 0 ? textureB : textureA; + + { + // Allow error of 4 times the minimum presentable difference + const Vec4 threshold (4.0f * 1.0f / ((UVec4(1u) << tcu::getTextureFormatMantissaBitDepth(format).cast()) - 1u).cast()); + + if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "", "", reference.getAccess(), access, threshold, tcu::COMPARE_LOG_ON_ERROR)) + m_resultCollector.fail("Compare failed."); + } + } + + return tcu::TestStatus(m_resultCollector.getResult(), m_resultCollector.getMessage()); +} + +struct Programs +{ + void init (vk::SourceCollections& dst, TestConfig testConfig) const + { + std::ostringstream fragmentShader; + std::string fragmentColor; + std::string inputAttachment; + std::string outputColor; + std::string variables; + + for (size_t renderPassNdx = 0; renderPassNdx < testConfig.renderPasses.size(); renderPassNdx++) + { + dst.glslSources.add("quad-vert-" + de::toString(renderPassNdx)) << glu::VertexSource( + "#version 450\n" + "layout(location = 0) out highp vec2 vtxTexCoords;\n" + "highp float;\n" + "void main (void)\n" + "{\n" + " vec4 position;" + " position = vec4(((gl_VertexIndex + 2) / 3) % 2 == 0 ? -1.0 : 1.0,\n" + " ((gl_VertexIndex + 1) / 3) % 2 == 0 ? -1.0 : 1.0, 0.0, 1.0);\n" + " gl_Position = position;\n" + " vtxTexCoords = position.xy / 2.0 + vec2(0.5);" + "}\n"); + + // First pass renders four quads of different color + if (renderPassNdx == 0) + { + dst.glslSources.add("quad-frag-" + de::toString(renderPassNdx)) << glu::FragmentSource( + "#version 450\n" + "layout(location = 0) in highp vec2 vtxTexCoords;\n" + "layout(location = 0) out highp vec4 o_color;\n" + "void main (void)\n" + "{\n" + " if (gl_FragCoord.x <= " + de::toString(testConfig.imageSize.x() / 2) + " && gl_FragCoord.y <= " + de::toString(testConfig.imageSize.y() / 2) + ")\n" + " o_color = vec4(1.0, 0.0, 0.0, 1.0);\n" + " else if (gl_FragCoord.x > " + de::toString(testConfig.imageSize.x() / 2) + " && gl_FragCoord.y <= " + de::toString(testConfig.imageSize.y() / 2) + ")\n" + " o_color = vec4(0.0, 1.0, 0.0, 1.0);\n" + " else if (gl_FragCoord.x <= " + de::toString(testConfig.imageSize.x() / 2) + " && gl_FragCoord.y > " + de::toString(testConfig.imageSize.y() / 2) + ")\n" + " o_color = vec4(0.0, 0.0, 1.0, 1.0);\n" + " else\n" + " o_color = vec4(0.0, 0.0, 0.0, 1.0);\n" + "" + "}\n"); + } + else + { + if (renderPassNdx % 2 == 0) + { + // Blur previous pass horizontally + dst.glslSources.add("quad-frag-" + de::toString(renderPassNdx)) << glu::FragmentSource( + "#version 450\n" + "layout(binding = 0) uniform sampler2D previousPass;\n" + "layout(location = 0) in highp vec2 vtxTexCoords;\n" + "layout(location = 0) out highp vec4 o_color;\n" + "void main (void)\n" + "{\n" + " vec2 step = vec2(1.0 / " + de::toString(testConfig.imageSize.x()) + ", 1.0 / " + de::toString(testConfig.imageSize.y()) + ");\n" + " vec2 minCoord = vec2(0.0, 0.0);\n" + " vec2 maxCoord = vec2(1.0, 1.0);\n" + " vec4 blurColor = vec4(0.0);\n" + " for(int sampleNdx = 0; sampleNdx < " + de::toString(testConfig.blurKernel + 1) + "; sampleNdx++)\n" + " {\n" + " vec2 sampleCoord = vec2((vtxTexCoords.x - " + de::toString(testConfig.blurKernel / 2) + " * step.x) + step.x * sampleNdx, vtxTexCoords.y);\n" + " blurColor += 0.12 * texture(previousPass, clamp(sampleCoord, minCoord, maxCoord));\n" + " }\n" + " o_color = blurColor;\n" + "}\n"); + } + else + { + // Blur previous pass vertically + dst.glslSources.add("quad-frag-" + de::toString(renderPassNdx)) << glu::FragmentSource( + "#version 450\n" + "layout(binding = 0) uniform highp sampler2D previousPass;\n" + "layout(location = 0) in highp vec2 vtxTexCoords;\n" + "layout(location = 0) out highp vec4 o_color;\n" + "void main (void)\n" + "{\n" + " vec2 step = vec2(1.0 / " + de::toString(testConfig.imageSize.x()) + ", 1.0 / " + de::toString(testConfig.imageSize.y()) + ");\n" + " vec2 minCoord = vec2(0.0, 0.0);\n" + " vec2 maxCoord = vec2(1.0, 1.0);\n" + " vec4 blurColor = vec4(0.0);\n" + " for(int sampleNdx = 0; sampleNdx < " + de::toString(testConfig.blurKernel + 1) + "; sampleNdx++)\n" + " {\n" + " vec2 sampleCoord = vec2(vtxTexCoords.x, (vtxTexCoords.y - " + de::toString(testConfig.blurKernel / 2) + " * step.y) + step.y * sampleNdx);\n" + " blurColor += 0.12 * texture(previousPass, clamp(sampleCoord, minCoord, maxCoord));\n" + " }\n" + " o_color = blurColor;\n" + "}\n"); + } + } + } + } +}; + +void initTests (tcu::TestCaseGroup* group, const RenderPassType renderPassType) +{ + tcu::TestContext& testCtx(group->getTestContext()); + + // Test external subpass dependencies + { + const deUint32 renderPassCounts[] = { 2u, 3u, 5u}; + + const UVec2 renderSizes[] = + { + UVec2(64, 64), + UVec2(128, 128), + UVec2(512, 512) + }; + + de::MovePtr externalGroup (new tcu::TestCaseGroup(testCtx, "external_subpass", "external_subpass")); + + for (size_t renderSizeNdx = 0; renderSizeNdx < DE_LENGTH_OF_ARRAY(renderSizes); renderSizeNdx++) + { + string groupName ("render_size_" + de::toString(renderSizes[renderSizeNdx].x()) + "_" + de::toString(renderSizes[renderSizeNdx].y())); + de::MovePtr renderSizeGroup (new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupName.c_str())); + + for (size_t renderPassCountNdx = 0; renderPassCountNdx < DE_LENGTH_OF_ARRAY(renderPassCounts); renderPassCountNdx++) + { + vector renderPasses; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPassCounts[renderPassCountNdx]; renderPassNdx++) + { + vector attachments; + vector colorAttachmentReferences; + + const VkFormat format (VK_FORMAT_R8G8B8A8_UNORM); + const VkSampleCountFlagBits sampleCount (VK_SAMPLE_COUNT_1_BIT); + const VkAttachmentLoadOp loadOp (VK_ATTACHMENT_LOAD_OP_DONT_CARE); + const VkAttachmentStoreOp storeOp (VK_ATTACHMENT_STORE_OP_STORE); + const VkAttachmentLoadOp stencilLoadOp (VK_ATTACHMENT_LOAD_OP_DONT_CARE); + const VkAttachmentStoreOp stencilStoreOp (VK_ATTACHMENT_STORE_OP_DONT_CARE); + const VkImageLayout initialLayout (VK_IMAGE_LAYOUT_UNDEFINED); + const VkImageLayout finalLayout (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + const VkImageLayout subpassLayout (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + + attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout)); + colorAttachmentReferences.push_back(AttachmentReference((deUint32)0, subpassLayout)); + + const VkImageLayout depthStencilLayout (VK_IMAGE_LAYOUT_GENERAL); + const vector subpasses (1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector(), colorAttachmentReferences, vector(), + AttachmentReference(VK_ATTACHMENT_UNUSED, depthStencilLayout), vector())); + vector deps; + + deps.push_back(SubpassDependency(VK_SUBPASS_EXTERNAL, // deUint32 srcPass + 0, // deUint32 dstPass + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags dstStageMask + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask + VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask + 0)); // VkDependencyFlags flags + + deps.push_back(SubpassDependency(0, // deUint32 srcPass + VK_SUBPASS_EXTERNAL, // deUint32 dstPass + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags srcStageMask + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags dstStageMask + VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask + 0)); // VkDependencyFlags flags + + RenderPass renderPass (attachments, subpasses, deps); + + renderPasses.push_back(renderPass); + } + + const deUint32 blurKernel (12u); + const TestConfig testConfig (VK_FORMAT_R8G8B8A8_UNORM, renderSizes[renderSizeNdx], renderPasses, renderPassType, blurKernel); + const string testName ("render_passes_" + de::toString(renderPassCounts[renderPassCountNdx])); + + renderSizeGroup->addChild(new InstanceFactory1(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName.c_str(), testName.c_str(), testConfig)); + } + + externalGroup->addChild(renderSizeGroup.release()); + } + + group->addChild(externalGroup.release()); + } + + // Test implicit subpass dependencies + { + const deUint32 renderPassCounts[] = { 2u, 3u, 5u }; + + de::MovePtr implicitGroup (new tcu::TestCaseGroup(testCtx, "implicit_dependencies", "implicit_dependencies")); + + for (size_t renderPassCountNdx = 0; renderPassCountNdx < DE_LENGTH_OF_ARRAY(renderPassCounts); renderPassCountNdx++) + { + vector renderPasses; + + for (size_t renderPassNdx = 0; renderPassNdx < renderPassCounts[renderPassCountNdx]; renderPassNdx++) + { + vector attachments; + vector colorAttachmentReferences; + + const VkFormat format (VK_FORMAT_R8G8B8A8_UNORM); + const VkSampleCountFlagBits sampleCount (VK_SAMPLE_COUNT_1_BIT); + const VkAttachmentLoadOp loadOp (VK_ATTACHMENT_LOAD_OP_DONT_CARE); + const VkAttachmentStoreOp storeOp (VK_ATTACHMENT_STORE_OP_STORE); + const VkAttachmentLoadOp stencilLoadOp (VK_ATTACHMENT_LOAD_OP_DONT_CARE); + const VkAttachmentStoreOp stencilStoreOp (VK_ATTACHMENT_STORE_OP_DONT_CARE); + const VkImageLayout initialLayout (VK_IMAGE_LAYOUT_UNDEFINED); + const VkImageLayout finalLayout (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + const VkImageLayout subpassLayout (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + + attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout)); + colorAttachmentReferences.push_back(AttachmentReference((deUint32)0, subpassLayout)); + + const VkImageLayout depthStencilLayout (VK_IMAGE_LAYOUT_GENERAL); + const vector subpasses (1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector(), colorAttachmentReferences, vector(), AttachmentReference(VK_ATTACHMENT_UNUSED, depthStencilLayout), vector())); + vector deps; + + // The first render pass lets the implementation add all subpass dependencies implicitly. + // On the following passes only the dependency from external to first subpass is defined as + // we need to make sure we have the image ready from previous render pass. In this case + // the dependency from subpass 0 to external is added implicitly by the implementation. + if (renderPassNdx > 0) + { + deps.push_back(SubpassDependency(VK_SUBPASS_EXTERNAL, // deUint32 srcPass + 0, // deUint32 dstPass + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags dstStageMask + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask + VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask + 0)); // VkDependencyFlags flags + } + + RenderPass renderPass (attachments, subpasses, deps); + + renderPasses.push_back(renderPass); + } + + const deUint32 blurKernel (12u); + const TestConfig testConfig (VK_FORMAT_R8G8B8A8_UNORM, UVec2(128, 128), renderPasses, renderPassType, blurKernel); + const string testName ("render_passes_" + de::toString(renderPassCounts[renderPassCountNdx])); + + implicitGroup->addChild(new InstanceFactory1(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName.c_str(), testName.c_str(), testConfig)); + } + + group->addChild(implicitGroup.release()); + } +} +} // anonymous + +tcu::TestCaseGroup* createRenderPassSubpassDependencyTests (tcu::TestContext& testCtx) +{ + return createTestGroup(testCtx, "subpass_dependencies", "Subpass dependency tests", initTests, RENDERPASS_TYPE_LEGACY); +} + +tcu::TestCaseGroup* createRenderPass2SubpassDependencyTests (tcu::TestContext& testCtx) +{ + return createTestGroup(testCtx, "subpass_dependencies", "Subpass dependency tests", initTests, RENDERPASS_TYPE_RENDERPASS2); +} +} // vkt diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.hpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.hpp new file mode 100644 index 0000000..3ad544d --- /dev/null +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassSubpassDependencyTests.hpp @@ -0,0 +1,38 @@ +#ifndef _VKTRENDERPASSSUBPASSDEPENDENCYTESTS_HPP +#define _VKTRENDERPASSSUBPASSDEPENDENCYTESTS_HPP +/*------------------------------------------------------------------------- + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2018 Google Inc. + * Copyright (c) 2018 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 for subpass dependency tests + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "tcuTestCase.hpp" + +namespace vkt +{ + +tcu::TestCaseGroup* createRenderPassSubpassDependencyTests (tcu::TestContext& testCtx); +tcu::TestCaseGroup* createRenderPass2SubpassDependencyTests (tcu::TestContext& testCtx); + +} // vkt + +#endif // _VKTRENDERPASSSUBPASSDEPENDENCYTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp index 193c7d0..fd87d42 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp @@ -28,6 +28,7 @@ #include "vktRenderPassMultisampleResolveTests.hpp" #include "vktRenderPassSampleReadTests.hpp" #include "vktRenderPassSparseRenderTargetTests.hpp" +#include "vktRenderPassSubpassDependencyTests.hpp" #include "vktRenderPassUnusedAttachmentTests.hpp" #include "vktTestCaseUtil.hpp" @@ -104,12 +105,6 @@ enum AllocationKind ALLOCATION_KIND_DEDICATED, }; -enum RenderPassType -{ - RENDERPASS_TYPE_LEGACY = 0, - RENDERPASS_TYPE_RENDERPASS2, -}; - struct TestConfigExternal { TestConfigExternal (AllocationKind allocationKind_, @@ -7000,6 +6995,7 @@ tcu::TestCaseGroup* createRenderPassTestsInternal (tcu::TestContext& testCtx, Re suballocationTestGroup->addChild((renderPassType == RENDERPASS_TYPE_LEGACY) ? createRenderPassMultisampleTests(testCtx) : createRenderPass2MultisampleTests(testCtx)); suballocationTestGroup->addChild((renderPassType == RENDERPASS_TYPE_LEGACY) ? createRenderPassMultisampleResolveTests(testCtx) : createRenderPass2MultisampleResolveTests(testCtx)); + suballocationTestGroup->addChild((renderPassType == RENDERPASS_TYPE_LEGACY) ? createRenderPassSubpassDependencyTests(testCtx) : createRenderPass2SubpassDependencyTests(testCtx)); renderpassTests->addChild(suballocationTestGroup.release()); renderpassTests->addChild(dedicatedAllocationTestGroup.release()); @@ -7008,6 +7004,7 @@ tcu::TestCaseGroup* createRenderPassTestsInternal (tcu::TestContext& testCtx, Re { renderpassTests->addChild(createRenderPassMultisampleTests(testCtx)); renderpassTests->addChild(createRenderPassMultisampleResolveTests(testCtx)); + renderpassTests->addChild(createRenderPassSubpassDependencyTests(testCtx)); } renderpassTests->addChild((renderPassType == RENDERPASS_TYPE_LEGACY) ? createRenderPassSampleReadTests(testCtx) : createRenderPass2SampleReadTests(testCtx)); diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.cpp index 85c3d76..7f63a93 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.cpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.cpp @@ -23,8 +23,11 @@ #include "vktRenderPassTestsUtil.hpp" #include "tcuTestCase.hpp" +#include "vkMemUtil.hpp" #include "vkRefUtil.hpp" +#include + using namespace vk; namespace vkt @@ -364,7 +367,432 @@ void RenderpassSubpass2::cmdEndRenderPass (const DeviceInterface& vk, vk.cmdEndRenderPass2KHR(cmdBuffer, pSubpassEndInfo); } +// For internal to RP/RP2 conversions + +AttachmentReference::AttachmentReference (deUint32 attachment, + VkImageLayout layout, + VkImageAspectFlags aspectMask) + + :m_attachment (attachment) + ,m_layout (layout) + ,m_aspectMask (aspectMask) +{ +} + +deUint32 AttachmentReference::getAttachment (void) const +{ + return m_attachment; +} + +VkImageLayout AttachmentReference::getImageLayout (void) const +{ + return m_layout; +} + +VkImageAspectFlags AttachmentReference::getAspectMask (void) const +{ + return m_aspectMask; +} + +void AttachmentReference::setImageLayout (VkImageLayout layout) +{ + m_layout = layout; +} + +Subpass::Subpass (VkPipelineBindPoint pipelineBindPoint, + VkSubpassDescriptionFlags flags, + const std::vector& inputAttachments, + const std::vector& colorAttachments, + const std::vector& resolveAttachments, + AttachmentReference depthStencilAttachment, + const std::vector& preserveAttachments, + bool omitBlendState) + + :m_pipelineBindPoint (pipelineBindPoint) + ,m_flags (flags) + ,m_inputAttachments (inputAttachments) + ,m_colorAttachments (colorAttachments) + ,m_resolveAttachments (resolveAttachments) + ,m_depthStencilAttachment (depthStencilAttachment) + ,m_preserveAttachments (preserveAttachments) + ,m_omitBlendState (omitBlendState) +{ +} + +VkPipelineBindPoint Subpass::getPipelineBindPoint (void) const +{ + return m_pipelineBindPoint; +} + +VkSubpassDescriptionFlags Subpass::getFlags (void) const +{ + return m_flags; +} + +const std::vector& Subpass::getInputAttachments (void) const +{ + return m_inputAttachments; +} + +const std::vector& Subpass::getColorAttachments (void) const +{ + return m_colorAttachments; +} + +const std::vector& Subpass::getResolveAttachments (void) const +{ + return m_resolveAttachments; +} + +const AttachmentReference& Subpass::getDepthStencilAttachment (void) const +{ + return m_depthStencilAttachment; +} + +const std::vector& Subpass::getPreserveAttachments (void) const +{ + return m_preserveAttachments; +} + +bool Subpass::getOmitBlendState (void) const +{ + return m_omitBlendState; +} + +SubpassDependency::SubpassDependency (deUint32 srcPass, + deUint32 dstPass, + + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + + VkAccessFlags srcAccessMask, + VkAccessFlags dstAccessMask, + + VkDependencyFlags flags) + + : m_srcPass (srcPass) + , m_dstPass (dstPass) + + , m_srcStageMask (srcStageMask) + , m_dstStageMask (dstStageMask) + + , m_srcAccessMask (srcAccessMask) + , m_dstAccessMask (dstAccessMask) + , m_flags (flags) +{ +} + +deUint32 SubpassDependency::getSrcPass (void) const +{ + return m_srcPass; +} + +deUint32 SubpassDependency::getDstPass (void) const +{ + return m_dstPass; +} + +VkPipelineStageFlags SubpassDependency::getSrcStageMask (void) const +{ + return m_srcStageMask; +} + +VkPipelineStageFlags SubpassDependency::getDstStageMask (void) const +{ + return m_dstStageMask; +} + +VkAccessFlags SubpassDependency::getSrcAccessMask (void) const +{ + return m_srcAccessMask; +} + +VkAccessFlags SubpassDependency::getDstAccessMask (void) const +{ + return m_dstAccessMask; +} + +VkDependencyFlags SubpassDependency::getFlags (void) const +{ + return m_flags; +} + +Attachment::Attachment (VkFormat format, + VkSampleCountFlagBits samples, + + VkAttachmentLoadOp loadOp, + VkAttachmentStoreOp storeOp, + + VkAttachmentLoadOp stencilLoadOp, + VkAttachmentStoreOp stencilStoreOp, + + VkImageLayout initialLayout, + VkImageLayout finalLayout) + + : m_format (format) + , m_samples (samples) + , m_loadOp (loadOp) + , m_storeOp (storeOp) + , m_stencilLoadOp (stencilLoadOp) + , m_stencilStoreOp (stencilStoreOp) + , m_initialLayout (initialLayout) + , m_finalLayout (finalLayout) +{ +} + +VkFormat Attachment::getFormat (void) const +{ + return m_format; +} + +VkSampleCountFlagBits Attachment::getSamples (void) const +{ + return m_samples; +} + +VkAttachmentLoadOp Attachment::getLoadOp (void) const +{ + return m_loadOp; +} + +VkAttachmentStoreOp Attachment::getStoreOp (void) const +{ + return m_storeOp; +} + +VkAttachmentLoadOp Attachment::getStencilLoadOp (void) const +{ + return m_stencilLoadOp; +} + +VkAttachmentStoreOp Attachment::getStencilStoreOp (void) const +{ + return m_stencilStoreOp; +} + +VkImageLayout Attachment::getInitialLayout (void) const +{ + return m_initialLayout; +} + +VkImageLayout Attachment::getFinalLayout (void) const +{ + return m_finalLayout; +} + +RenderPass::RenderPass (const std::vector& attachments, + const std::vector& subpasses, + const std::vector& dependencies, + const std::vector inputAspects) + + : m_attachments (attachments) + , m_subpasses (subpasses) + , m_dependencies (dependencies) + , m_inputAspects (inputAspects) +{ +} + +const std::vector& RenderPass::getAttachments (void) const +{ + return m_attachments; +} + +const std::vector& RenderPass::getSubpasses (void) const +{ + return m_subpasses; +} + +const std::vector& RenderPass::getDependencies (void) const +{ + return m_dependencies; +} + +const std::vector& RenderPass::getInputAspects (void) const +{ + return m_inputAspects; +} + +template +AttachmentDesc createAttachmentDescription (const Attachment& attachment) +{ + const AttachmentDesc attachmentDescription // VkAttachmentDescription || VkAttachmentDescription2KHR + ( + // || VkStructureType sType; + DE_NULL, // || const void* pNext; + 0u, // VkAttachmentDescriptionFlags flags; || VkAttachmentDescriptionFlags flags; + attachment.getFormat(), // VkFormat format; || VkFormat format; + attachment.getSamples(), // VkSampleCountFlagBits samples; || VkSampleCountFlagBits samples; + attachment.getLoadOp(), // VkAttachmentLoadOp loadOp; || VkAttachmentLoadOp loadOp; + attachment.getStoreOp(), // VkAttachmentStoreOp storeOp; || VkAttachmentStoreOp storeOp; + attachment.getStencilLoadOp(), // VkAttachmentLoadOp stencilLoadOp; || VkAttachmentLoadOp stencilLoadOp; + attachment.getStencilStoreOp(), // VkAttachmentStoreOp stencilStoreOp; || VkAttachmentStoreOp stencilStoreOp; + attachment.getInitialLayout(), // VkImageLayout initialLayout; || VkImageLayout initialLayout; + attachment.getFinalLayout() // VkImageLayout finalLayout; || VkImageLayout finalLayout; + ); + + return attachmentDescription; +} + +template +AttachmentRef createAttachmentReference (const AttachmentReference& referenceInfo) +{ + const AttachmentRef reference // VkAttachmentReference || VkAttachmentReference2KHR + ( + // || VkStructureType sType; + DE_NULL, // || const void* pNext; + referenceInfo.getAttachment(), // deUint32 attachment; || deUint32 attachment; + referenceInfo.getImageLayout(), // VkImageLayout layout; || VkImageLayout layout; + referenceInfo.getAspectMask() // || VkImageAspectFlags aspectMask; + ); + + return reference; +} + +template +SubpassDesc createSubpassDescription (const Subpass& subpass, + std::vector* attachmentReferenceLists, + std::vector* preserveAttachmentReferences) +{ + std::vector& inputAttachmentReferences = attachmentReferenceLists[0]; + std::vector& colorAttachmentReferences = attachmentReferenceLists[1]; + std::vector& resolveAttachmentReferences = attachmentReferenceLists[2]; + std::vector& depthStencilAttachmentReferences = attachmentReferenceLists[3]; + + for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++) + colorAttachmentReferences.push_back(createAttachmentReference(subpass.getColorAttachments()[attachmentNdx])); + + for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++) + inputAttachmentReferences.push_back(createAttachmentReference(subpass.getInputAttachments()[attachmentNdx])); + + for (size_t attachmentNdx = 0; attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++) + resolveAttachmentReferences.push_back(createAttachmentReference(subpass.getResolveAttachments()[attachmentNdx])); + + depthStencilAttachmentReferences.push_back(createAttachmentReference(subpass.getDepthStencilAttachment())); + + for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++) + preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx]); + + DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size()); + + { + const SubpassDesc subpassDescription // VkSubpassDescription || VkSubpassDescription2KHR + ( + // || VkStructureType sType; + DE_NULL, // || const void* pNext; + subpass.getFlags(), // VkSubpassDescriptionFlags flags; || VkSubpassDescriptionFlags flags; + subpass.getPipelineBindPoint(), // VkPipelineBindPoint pipelineBindPoint; || VkPipelineBindPoint pipelineBindPoint; + 0u, // || deUint32 viewMask; + (deUint32)inputAttachmentReferences.size(), // deUint32 inputAttachmentCount; || deUint32 inputAttachmentCount; + inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0], // const VkAttachmentReference* pInputAttachments; || const VkAttachmentReference2KHR* pInputAttachments; + (deUint32)colorAttachmentReferences.size(), // deUint32 colorAttachmentCount; || deUint32 colorAttachmentCount; + colorAttachmentReferences.empty() ? DE_NULL : &colorAttachmentReferences[0], // const VkAttachmentReference* pColorAttachments; || const VkAttachmentReference2KHR* pColorAttachments; + resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0], // const VkAttachmentReference* pResolveAttachments; || const VkAttachmentReference2KHR* pResolveAttachments; + &depthStencilAttachmentReferences[0], // const VkAttachmentReference* pDepthStencilAttachment; || const VkAttachmentReference2KHR* pDepthStencilAttachment; + (deUint32)preserveAttachmentReferences->size(), // deUint32 preserveAttachmentCount; || deUint32 preserveAttachmentCount; + preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0] // const deUint32* pPreserveAttachments; || const deUint32* pPreserveAttachments; + ); + + return subpassDescription; + } +} + +template +SubpassDep createSubpassDependency (const SubpassDependency& dependencyInfo) +{ + const SubpassDep dependency // VkSubpassDependency || VkSubpassDependency2KHR + ( + // || VkStructureType sType + DE_NULL, // || const void* pNext + dependencyInfo.getSrcPass(), // deUint32 srcSubpass || deUint32 srcSubpass + dependencyInfo.getDstPass(), // deUint32 dstSubpass || deUint32 dstSubpass + dependencyInfo.getSrcStageMask(), // VkPipelineStageFlags srcStageMask || VkPipelineStageFlags srcStageMask + dependencyInfo.getDstStageMask(), // VkPipelineStageFlags dstStageMask || VkPipelineStageFlags dstStageMask + dependencyInfo.getSrcAccessMask(), // VkAccessFlags srcAccessMask || VkAccessFlags srcAccessMask + dependencyInfo.getDstAccessMask(), // VkAccessFlags dstAccessMask || VkAccessFlags dstAccessMask + dependencyInfo.getFlags(), // VkDependencyFlags dependencyFlags || VkDependencyFlags dependencyFlags + 0u // deInt32 viewOffset || deInt32 viewOffset + ); + + return dependency; +} + +de::MovePtr createRenderPassInputAttachmentAspectCreateInfo (const RenderPass& renderPassInfo) +{ + de::MovePtr result (DE_NULL); + + if (!renderPassInfo.getInputAspects().empty()) + { + const VkRenderPassInputAttachmentAspectCreateInfo inputAspectCreateInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + DE_NULL, + + (deUint32)renderPassInfo.getInputAspects().size(), + renderPassInfo.getInputAspects().data(), + }; + + result = de::MovePtr(new VkRenderPassInputAttachmentAspectCreateInfo(inputAspectCreateInfo)); + } + + return result; +} + +template +Move createRenderPass (const DeviceInterface& vk, + VkDevice device, + const RenderPass& renderPassInfo) +{ + const size_t perSubpassAttachmentReferenceLists = 4; + std::vector attachments; + std::vector subpasses; + std::vector dependencies; + std::vector > attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists); + std::vector > preserveAttachments(renderPassInfo.getSubpasses().size()); + de::MovePtr inputAspectCreateInfo(createRenderPassInputAttachmentAspectCreateInfo(renderPassInfo)); + + for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++) + attachments.push_back(createAttachmentDescription(renderPassInfo.getAttachments()[attachmentNdx])); + + for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++) + subpasses.push_back(createSubpassDescription(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx])); + + for (size_t depNdx = 0; depNdx < renderPassInfo.getDependencies().size(); depNdx++) + dependencies.push_back(createSubpassDependency(renderPassInfo.getDependencies()[depNdx])); + + const RenderPassCreateInfo renderPassCreator // VkRenderPassCreateInfo || VkRenderPassCreateInfo2KHR + ( + // VkStructureType sType; || VkStructureType sType; + inputAspectCreateInfo.get(), // const void* pNext; || const void* pNext; + (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags; || VkRenderPassCreateFlags flags; + (deUint32)attachments.size(), // deUint32 attachmentCount; || deUint32 attachmentCount; + (attachments.empty() ? DE_NULL : &attachments[0]), // const VkAttachmentDescription* pAttachments; || const VkAttachmentDescription2KHR* pAttachments; + (deUint32)subpasses.size(), // deUint32 subpassCount; || deUint32 subpassCount; + (subpasses.empty() ? DE_NULL : &subpasses[0]), // const VkSubpassDescription* pSubpasses; || const VkSubpassDescription2KHR* pSubpasses; + (deUint32)dependencies.size(), // deUint32 dependencyCount; || deUint32 dependencyCount; + (dependencies.empty() ? DE_NULL : &dependencies[0]), // const VkSubpassDependency* pDependencies; || const VkSubpassDependency2KHR* pDependencies; + 0u, // || deUint32 correlatedViewMaskCount; + DE_NULL // || const deUint32* pCorrelatedViewMasks; + ); + + return renderPassCreator.createRenderPass(vk, device); +} + +Move createRenderPass (const DeviceInterface& vk, + VkDevice device, + const RenderPass& renderPassInfo, + const RenderPassType renderPassType) +{ + switch (renderPassType) + { + case RENDERPASS_TYPE_LEGACY: + return createRenderPass(vk, device, renderPassInfo); + case RENDERPASS_TYPE_RENDERPASS2: + return createRenderPass(vk, device, renderPassInfo); + default: + TCU_THROW(InternalError, "Impossible"); + } +} + } // renderpass } // vkt - diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.hpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.hpp index 63ab7f4..e2762dd 100644 --- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.hpp +++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.hpp @@ -26,8 +26,11 @@ #include "tcuDefs.hpp" #include "vkRef.hpp" #include "vkDefs.hpp" +#include "vkMemUtil.hpp" #include "vkTypeUtil.hpp" +#include + namespace vkt { namespace renderpass @@ -35,6 +38,12 @@ namespace renderpass using namespace vk; +enum RenderPassType +{ + RENDERPASS_TYPE_LEGACY = 0, + RENDERPASS_TYPE_RENDERPASS2, +}; + class AttachmentDescription1 : public vk::VkAttachmentDescription { public: @@ -251,6 +260,163 @@ public: const SubpassEndInfo* pSubpassEndInfo); }; +// For internal to RP/RP2 conversions + +class AttachmentReference +{ +public: + AttachmentReference (deUint32 attachment, + VkImageLayout layout, + VkImageAspectFlags aspectMask = static_cast(0u)); + + deUint32 getAttachment (void) const; + VkImageLayout getImageLayout (void) const; + VkImageAspectFlags getAspectMask (void) const; + void setImageLayout (VkImageLayout layout); + +private: + deUint32 m_attachment; + VkImageLayout m_layout; + VkImageAspectFlags m_aspectMask; +}; + +class Subpass +{ +public: + Subpass (VkPipelineBindPoint pipelineBindPoint, + VkSubpassDescriptionFlags flags, + const std::vector& inputAttachments, + const std::vector& colorAttachments, + const std::vector& resolveAttachments, + AttachmentReference depthStencilAttachment, + const std::vector& preserveAttachments, + bool omitBlendState = false); + + VkPipelineBindPoint getPipelineBindPoint (void) const; + VkSubpassDescriptionFlags getFlags (void) const; + const std::vector& getInputAttachments (void) const; + const std::vector& getColorAttachments (void) const; + const std::vector& getResolveAttachments (void) const; + const AttachmentReference& getDepthStencilAttachment (void) const; + const std::vector& getPreserveAttachments (void) const; + bool getOmitBlendState (void) const; + +private: + VkPipelineBindPoint m_pipelineBindPoint; + VkSubpassDescriptionFlags m_flags; + + std::vector m_inputAttachments; + std::vector m_colorAttachments; + std::vector m_resolveAttachments; + AttachmentReference m_depthStencilAttachment; + + std::vector m_preserveAttachments; + bool m_omitBlendState; +}; + +class SubpassDependency +{ +public: + SubpassDependency (deUint32 srcPass, + deUint32 dstPass, + + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + + VkAccessFlags srcAccessMask, + VkAccessFlags dstAccessMask, + + VkDependencyFlags flags); + + deUint32 getSrcPass (void) const; + deUint32 getDstPass (void) const; + + VkPipelineStageFlags getSrcStageMask (void) const; + VkPipelineStageFlags getDstStageMask (void) const; + + VkAccessFlags getSrcAccessMask (void) const; + VkAccessFlags getDstAccessMask (void) const; + + VkDependencyFlags getFlags (void) const; + +private: + deUint32 m_srcPass; + deUint32 m_dstPass; + + VkPipelineStageFlags m_srcStageMask; + VkPipelineStageFlags m_dstStageMask; + + VkAccessFlags m_srcAccessMask; + VkAccessFlags m_dstAccessMask; + VkDependencyFlags m_flags; +}; + +class Attachment +{ +public: + Attachment (VkFormat format, + VkSampleCountFlagBits samples, + + VkAttachmentLoadOp loadOp, + VkAttachmentStoreOp storeOp, + + VkAttachmentLoadOp stencilLoadOp, + VkAttachmentStoreOp stencilStoreOp, + + VkImageLayout initialLayout, + VkImageLayout finalLayout); + + VkFormat getFormat (void) const; + VkSampleCountFlagBits getSamples (void) const; + + VkAttachmentLoadOp getLoadOp (void) const; + VkAttachmentStoreOp getStoreOp (void) const; + + VkAttachmentLoadOp getStencilLoadOp (void) const; + VkAttachmentStoreOp getStencilStoreOp (void) const; + + VkImageLayout getInitialLayout (void) const; + VkImageLayout getFinalLayout (void) const; + +private: + VkFormat m_format; + VkSampleCountFlagBits m_samples; + + VkAttachmentLoadOp m_loadOp; + VkAttachmentStoreOp m_storeOp; + + VkAttachmentLoadOp m_stencilLoadOp; + VkAttachmentStoreOp m_stencilStoreOp; + + VkImageLayout m_initialLayout; + VkImageLayout m_finalLayout; +}; + +class RenderPass +{ +public: + RenderPass (const std::vector& attachments, + const std::vector& subpasses, + const std::vector& dependencies, + const std::vector inputAspects = std::vector()); + + const std::vector& getAttachments (void) const; + const std::vector& getSubpasses (void) const; + const std::vector& getDependencies (void) const; + const std::vector& getInputAspects (void) const; + +private: + std::vector m_attachments; + std::vector m_subpasses; + std::vector m_dependencies; + std::vector m_inputAspects; +}; + +Move createRenderPass (const DeviceInterface& vk, + VkDevice device, + const RenderPass& renderPassInfo, + const RenderPassType renderPassType); + } // renderpass } // vkt diff --git a/external/vulkancts/mustpass/1.1.3/vk-default-no-waivers.txt b/external/vulkancts/mustpass/1.1.3/vk-default-no-waivers.txt index 1e63a9a..f797506 100644 --- a/external/vulkancts/mustpass/1.1.3/vk-default-no-waivers.txt +++ b/external/vulkancts/mustpass/1.1.3/vk-default-no-waivers.txt @@ -255018,6 +255018,18 @@ dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint. dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.dedicated_allocation.simple.color dEQP-VK.renderpass.dedicated_allocation.simple.depth dEQP-VK.renderpass.dedicated_allocation.simple.stencil @@ -261609,6 +261621,18 @@ dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.sampleread.numsamples_2_add dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_0 dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_1 @@ -266515,6 +266539,18 @@ dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass2.dedicated_allocation.simple.color dEQP-VK.renderpass2.dedicated_allocation.simple.depth dEQP-VK.renderpass2.dedicated_allocation.simple.stencil diff --git a/external/vulkancts/mustpass/1.1.3/vk-default.txt b/external/vulkancts/mustpass/1.1.3/vk-default.txt index f09fa77..a482964 100644 --- a/external/vulkancts/mustpass/1.1.3/vk-default.txt +++ b/external/vulkancts/mustpass/1.1.3/vk-default.txt @@ -254980,6 +254980,18 @@ dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint. dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.dedicated_allocation.simple.color dEQP-VK.renderpass.dedicated_allocation.simple.depth dEQP-VK.renderpass.dedicated_allocation.simple.stencil @@ -261571,6 +261583,18 @@ dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass.sampleread.numsamples_2_add dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_0 dEQP-VK.renderpass.sampleread.numsamples_2_selected_sample_1 @@ -266477,6 +266501,18 @@ dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sint.samples_4 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_2 dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.r32g32b32a32_sfloat.samples_4 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_64_64.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_128_128.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.external_subpass.render_size_512_512.render_passes_5 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_2 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_3 +dEQP-VK.renderpass2.suballocation.subpass_dependencies.implicit_dependencies.render_passes_5 dEQP-VK.renderpass2.dedicated_allocation.simple.color dEQP-VK.renderpass2.dedicated_allocation.simple.depth dEQP-VK.renderpass2.dedicated_allocation.simple.stencil -- 2.7.4