Add barriers to read query data after copy

When the query pool results that were copied out to a buffer, a barrier
should be placed to ensure the data is written before the host read it,
specially if the memory allocated is non-host-coherent. The invalidation
of the mapped memory is not enough in that case.

Affected tests:

  dEQP-VK.query_pool.occlusion_query.copy*
  dEQP-VK.pipeline.timestamp.transfer_tests.*copy_query_pool_results*
  dEQP-VK.pipeline.timestamp.misc_tests.two_cmd_buffers_primary*

Components: Vulkan
VK-GL-CTS issue: 1756

Change-Id: I115c9e62f1b369e0f1ad9a30f9a6982c876beb74

diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineTimestampTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineTimestampTests.cpp
index 97f4752..cba58e9 100644 (file)
--- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineTimestampTests.cpp
+++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineTimestampTests.cpp
@@ -1918,6 +1918,22 @@ void TransferTestInstance::configCommandBuffer(void)
                        {
                                vk.cmdWriteTimestamp(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, *m_queryPool, 0u);
                                vk.cmdCopyQueryPoolResults(*m_cmdBuffer, *m_queryPool, 0u, 1u, *m_dstBuffer, 0u, 8u, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
+
+                               const vk::VkBufferMemoryBarrier bufferBarrier =
+                               {
+                                       vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,    // VkStructureType      sType;
+                                       DE_NULL,                                                                                // const void*          pNext;
+                                       vk::VK_ACCESS_TRANSFER_WRITE_BIT,                               // VkAccessFlags        srcAccessMask;
+                                       vk::VK_ACCESS_HOST_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
+                                       VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
+                                       VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
+                                       *m_dstBuffer,                                                                   // VkBuffer                     buffer;
+                                       0ull,                                                                                   // VkDeviceSize         offset;
+                                       VK_WHOLE_SIZE                                                                   // VkDeviceSize         size;
+                               };
+                               vk.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u,
+                                                                         0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
+
                                vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, 1u);
                                break;
                        }
@@ -2154,6 +2170,19 @@ void TwoCmdBuffersTestInstance::configCommandBuffer (void)
                (const VkCommandBufferInheritanceInfo*)DE_NULL  // const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
        };
 
+       const vk::VkBufferMemoryBarrier bufferBarrier =
+       {
+               vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,    // VkStructureType      sType;
+               DE_NULL,                                                                                // const void*          pNext;
+               vk::VK_ACCESS_TRANSFER_WRITE_BIT,                               // VkAccessFlags        srcAccessMask;
+               vk::VK_ACCESS_HOST_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
+               VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
+               VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
+               *m_dstBuffer,                                                                   // VkBuffer                     buffer;
+               0ull,                                                                                   // VkDeviceSize         offset;
+               VK_WHOLE_SIZE                                                                   // VkDeviceSize         size;
+       };
+
        if (m_cmdBufferLevel == VK_COMMAND_BUFFER_LEVEL_PRIMARY)
        {
                VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
@@ -2163,6 +2192,8 @@ void TwoCmdBuffersTestInstance::configCommandBuffer (void)
                VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
                VK_CHECK(vk.beginCommandBuffer(*m_secondCmdBuffer, &cmdBufferBeginInfo));
                vk.cmdCopyQueryPoolResults(*m_secondCmdBuffer, *m_queryPool, 0u, 1u, *m_dstBuffer, 0u, 0u, 0u);
+               vk.cmdPipelineBarrier(*m_secondCmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u,
+                                                         0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
                VK_CHECK(vk.endCommandBuffer(*m_secondCmdBuffer));
        }
        else
@@ -2194,6 +2225,8 @@ void TwoCmdBuffersTestInstance::configCommandBuffer (void)
                VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
                vk.cmdExecuteCommands(m_cmdBuffer.get(), 1u, &m_secondCmdBuffer.get());
                vk.cmdCopyQueryPoolResults(*m_cmdBuffer, *m_queryPool, 0u, 1u, *m_dstBuffer, 0u, 0u, 0u);
+               vk.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u,
+                                                         0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
                VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
        }
 }

diff --git a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
index 2bbdf0d..1de50d9 100644 (file)
--- a/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
+++ b/external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp
@@ -832,6 +832,21 @@ vk::Move<vk::VkCommandBuffer> OcclusionQueryTestInstance::recordRender (vk::VkCo
                && !hasSeparateCopyCmdBuf())
        {
                vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
+               const vk::VkBufferMemoryBarrier bufferBarrier =
+               {
+                       vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,    // VkStructureType      sType;
+                       DE_NULL,                                                                                // const void*          pNext;
+                       vk::VK_ACCESS_TRANSFER_WRITE_BIT,                               // VkAccessFlags        srcAccessMask;
+                       vk::VK_ACCESS_HOST_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
+                       VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
+                       VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
+                       m_queryPoolResultsBuffer->object(),                             // VkBuffer                     buffer;
+                       0ull,                                                                                   // VkDeviceSize         offset;
+                       VK_WHOLE_SIZE                                                                   // VkDeviceSize         size;
+               };
+
+               vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u,
+                                                         0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
        }
 
        transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_GENERAL,
@@ -852,6 +867,21 @@ vk::Move<vk::VkCommandBuffer> OcclusionQueryTestInstance::recordCopyResults (vk:
 
        beginCommandBuffer(vk, *cmdBuffer);
        vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
+       const vk::VkBufferMemoryBarrier bufferBarrier =
+       {
+               vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,    // VkStructureType      sType;
+               DE_NULL,                                                                                // const void*          pNext;
+               vk::VK_ACCESS_TRANSFER_WRITE_BIT,                               // VkAccessFlags        srcAccessMask;
+               vk::VK_ACCESS_HOST_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
+               VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
+               VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
+               m_queryPoolResultsBuffer->object(),                             // VkBuffer                     buffer;
+               0ull,                                                                                   // VkDeviceSize         offset;
+               VK_WHOLE_SIZE                                                                   // VkDeviceSize         size;
+       };
+
+       vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0u,
+                                                 0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
        endCommandBuffer(vk, *cmdBuffer);
 
        return cmdBuffer;