Fix synchronization in compressed texture sampling tests

Tests sampling compressed textures contained multiple synchronization
errors, most of them related to:

* Render pass load operations not properly synchronized with previous
  writes.
* Barriers that did not properly synchronize all layers of a cube map.
* Improper initial layout transitions.

Affected tests:
dEQP-VK.image.sample_texture.*
dEQP-VKSC.image.sample_texture.*

VK-GL-CTS issue: 3763
Components: Vulkan

Change-Id: I2f2572a7f6a05c55c904014fafc3a655dbb03ee3

diff --git a/external/vulkancts/modules/vulkan/image/vktImageSampleCompressedTextureTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageSampleCompressedTextureTests.cpp
index e343047..0e0a457 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageSampleCompressedTextureTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageSampleCompressedTextureTests.cpp
@@ -71,7 +71,6 @@ using tcu::Vec4;
 using std::vector;
 using de::MovePtr;
 using tcu::TextureLevel;
-using tcu::PixelBufferAccess;
 using tcu::ConstPixelBufferAccess;
 
 const VkDeviceSize     BUFFERSIZE      = 100u * 1024;
@@ -79,12 +78,17 @@ const int                   WIDTH           = 80;
 const int                      HEIGHT          = 80;
 const int                      FACES           = 6;
 
+uint32_t getLayerCount (const bool cubemap)
+{
+       return (cubemap ? static_cast<uint32_t>(FACES) : 1u);
+}
+
 inline VkImageCreateInfo makeImageCreateInfo (const IVec3& size, const VkFormat& format, bool storageImage, bool cubemap)
 {
        VkImageUsageFlags       usageFlags      = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
                                                                          | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
        VkImageCreateFlags      createFlags     = cubemap ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : DE_NULL;
-       const deUint32          layerCount      = cubemap ? 6u : 1u;
+       const deUint32          layerCount      = getLayerCount(cubemap);
 
        if (storageImage)
        {
@@ -162,12 +166,6 @@ SampleDrawnTextureTestInstance::SampleDrawnTextureTestInstance (Context& context
 {
 }
 
-template<typename T>
-inline size_t sizeInBytes (const vector<T>& vec)
-{
-       return vec.size() * sizeof(vec[0]);
-}
-
 Move<VkSampler> makeSampler (const DeviceInterface& vk, const VkDevice& device)
 {
        const VkSamplerCreateInfo samplerParams =
@@ -298,7 +296,8 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
        // Create a storage image. The first pipeline fills it and the second pipeline
        // uses it as a sampling source.
        const VkImageCreateInfo                 imageCreateInfo                 = makeImageCreateInfo(imageSize, m_imageFormat, true, m_cubemap);
-       const VkImageSubresourceRange   imageSubresourceRange   = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1, 0, 1);
+       const auto                                              layerCount                              = getLayerCount(m_cubemap);
+       const VkImageSubresourceRange   imageSubresourceRange   = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1, 0, layerCount);
        const ImageWithMemory                   storageImage                    (vk, device, m_context.getDefaultAllocator(), imageCreateInfo, MemoryRequirement::Any);
 
        // Create image views and descriptor sets for the first pipeline
@@ -441,8 +440,11 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
        Move<VkImageView>                               targetImageView                 = makeImageView(vk, device, *targetImage, VK_IMAGE_VIEW_TYPE_2D, renderedImageFormat, targetSubresourceRange);
 
        // Clear the render target image as black and do a layout transition.
+       const auto clearColor = makeClearValueColor(Vec4(0.0f, 0.0f, 0.0f, 0.0f)).color;
        clearColorImage(vk, device, m_context.getUniversalQueue(), m_context.getUniversalQueueFamilyIndex(), targetImage.get(),
-                                       Vec4(0, 0, 0, 0), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+                                       clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                                       (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),
+                                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
 
        const VkPushConstantRange               pushConstantRange2              =
        {
@@ -455,10 +457,11 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
 
        // Vertices for a full quad and texture coordinates for each vertex.
        const vector<Vertex>                    vertices                                = generateVertices();
+       const uint32_t                                  vertexCount                             = static_cast<uint32_t>(vertices.size());
        Move<VkBuffer>                                  vertexBuffer                    = makeVertexBuffer(vk, device, queueFamilyIndex);
        de::MovePtr<Allocation>                 vertexBufferAlloc               = bindBuffer(vk, device, allocator, *vertexBuffer, MemoryRequirement::HostVisible);
        const VkDeviceSize                              vertexBufferOffset              = 0ull;
-       deMemcpy(vertexBufferAlloc->getHostPtr(), &vertices[0], sizeInBytes(vertices));
+       deMemcpy(vertexBufferAlloc->getHostPtr(), de::dataOrNull(vertices), de::dataSize(vertices));
        flushAlloc(vk, device, *vertexBufferAlloc);
 
        const auto                                              vtxBindingDescription   = Vertex::getBindingDescription();
@@ -499,11 +502,10 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
        beginCommandBuffer(vk, *cmdBuffer);
 
        // Do a layout transition for the storage image.
-       const VkImageSubresourceRange   imageSubresourceRange2  = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1, 0, m_cubemap ? 6 : 1);
-       const auto                                              barrier1                                = makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
+       const auto                                              barrier1                                = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
                                                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
-                                                                                                                                                                        storageImage.get(), imageSubresourceRange2);
-       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier1);
+                                                                                                                                                                        storageImage.get(), imageSubresourceRange);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier1);
 
        // Bind the vertices and the descriptors used in the graphics pipeline.
        vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
@@ -551,12 +553,12 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
                                vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipelineLayout, 0u, 1u, &(cubeSamplerDescriptorSets[face].get()), 0u, DE_NULL);
 
                                beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, makeRect2D(0, 0, imageSize.x(), imageSize.y()),0u, DE_NULL);
-                               vk.cmdDraw(*cmdBuffer, 6u, 1u, 0u, 0u);
+                               vk.cmdDraw(*cmdBuffer, vertexCount, 1u, 0u, 0u);
                                endRenderPass(vk, *cmdBuffer);
 
                                if (face < FACES-1)
                                {
-                                       const auto barrier4 = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                                       const auto barrier4 = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, (VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT),
                                                                                                                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                                                                                                                 targetImage.get(), targetSubresourceRange);
                                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
@@ -569,7 +571,7 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
                        vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipelineLayout, 0u, 1u, &(graphicsDescriptorSet.get()), 0u, DE_NULL);
 
                        beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, makeRect2D(0, 0, imageSize.x(), imageSize.y()),0u, DE_NULL);
-                       vk.cmdDraw(*cmdBuffer, 6u, 1u, 0u, 0u);
+                       vk.cmdDraw(*cmdBuffer, vertexCount, 1u, 0u, 0u);
                        endRenderPass(vk, *cmdBuffer);
                }
 
@@ -579,7 +581,7 @@ tcu::TestStatus SampleDrawnTextureTestInstance::iterate (void)
                                                                                                                 VK_IMAGE_LAYOUT_GENERAL, storageImage.get(), imageSubresourceRange);
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier3);
 
-                       const auto barrier4 = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                       const auto barrier4 = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, (VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT),
                                                                                                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                                                                                                 targetImage.get(), targetSubresourceRange);
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier4);