Fix stageMask (0x1) usage in renderpass, image and texture tests

Pipeline barriers using PIPELINE_STAGE_TOP_OF_PIPE_BIT with nonzero
access mask were modified to use proper pipeline stage flags.

Memory barrier structure members were renamed to match the current
specification.

Affects:

dEQP-VK.renderpass.suballocation.simple.*
dEQP-VK.renderpass.suballocation.formats.*
dEQP-VK.renderpass.suballocation.attachment.*
dEQP-VK.renderpass.suballocation.attachment_allocation.*
dEQP-VK.renderpass.dedicated_allocation.simple.*
dEQP-VK.renderpass.dedicated_allocation.formats.*
dEQP-VK.renderpass.dedicated_allocation.attachment.*
dEQP-VK.renderpass.dedicated_allocation.attachment_allocation.*
dEQP-VK.image.store.*
dEQP-VK.image.load_store.*
dEQP-VK.image.format_reinterpret.*
dEQP-VK.image.qualifiers.restrict.*
dEQP-VK.image.atomic_operations.*
dEQP-VK.image.texel_view_compatible.*
dEQP-VK.image.extended_usage_bit.attachment_write.*
dEQP-VK.image.extended_usage_bit.texture_write.*
dEQP-VK.texture.*

VK-GL-CTS issue: 806

Change-Id: Iab4699f095d4ea1206736cb0435863f17bd3bca3

diff --git a/external/vulkancts/modules/vulkan/image/vktImageAtomicOperationTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageAtomicOperationTests.cpp
index e9f311d..c90e9e5 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageAtomicOperationTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageAtomicOperationTests.cpp
@@ -545,7 +545,7 @@ tcu::TestStatus     BinaryAtomicInstanceBase::iterate (void)
                                                                m_resultImage->get(),
                                                                subresourceRange);
 
                                                                m_resultImage->get(),
                                                                subresourceRange);
 

-       deviceInterface.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, 0u, DE_NULL, 1u, &inputBufferPostHostWriteBarrier, 1u, &resultImagePreCopyBarrier);
+       deviceInterface.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, 0u, DE_NULL, 1u, &inputBufferPostHostWriteBarrier, 1u, &resultImagePreCopyBarrier);

 
        const VkBufferImageCopy         bufferImageCopyParams = makeBufferImageCopy(makeExtent3D(getLayerSize(m_imageType, m_imageSize)), getNumLayers(m_imageType, m_imageSize));
 
 
        const VkBufferImageCopy         bufferImageCopyParams = makeBufferImageCopy(makeExtent3D(getLayerSize(m_imageType, m_imageSize)), getNumLayers(m_imageType, m_imageSize));
 

diff --git a/external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp b/external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp
index 6b02414..5a068a5 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp
@@ -585,7 +585,7 @@ void BasicComputeTestInstance::copyDataToImage (const VkCommandBuffer&      cmdBuffer
                                                                                                                                        VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                                                                                                                                        imageBuffer.get(), 0ull, m_data.size());
 
                                                                                                                                        VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                                                                                                                                        imageBuffer.get(), 0ull, m_data.size());
 

-               vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+               vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,

                                (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &FlushHostCopyBarrier, 1u, &preCopyImageBarrier);
 
                for (deUint32 mipNdx = 0u; mipNdx < imageData.getImageInfo(imageNdx).mipLevels; ++mipNdx)
                                (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &FlushHostCopyBarrier, 1u, &preCopyImageBarrier);
 
                for (deUint32 mipNdx = 0u; mipNdx < imageData.getImageInfo(imageNdx).mipLevels; ++mipNdx)


@@ -1571,9 +1571,9 @@ void GraphicsAttachmentsTestInstance::transcodeRead ()
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);

                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);

 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);


@@ -1705,9 +1705,9 @@ void GraphicsAttachmentsTestInstance::transcodeWrite ()
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);

                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);

 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);


@@ -1928,7 +1928,7 @@ bool GraphicsAttachmentsTestInstance::verifyDecompression (const std::vector<deU
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        // Copy buffer to image
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        // Copy buffer to image

-       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &refSrcCopyBufferBarrierPre, 1u, &refSrcCopyImageBarrierPre);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &refSrcCopyBufferBarrierPre, 1u, &refSrcCopyImageBarrierPre);

        vk.cmdCopyBufferToImage(*cmdBuffer, refSrcImageBuffer->get(), refSrcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &copyBufferToImageRegion);
        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, DE_NULL, 1u, &refSrcCopyImageBarrierPost);
 
        vk.cmdCopyBufferToImage(*cmdBuffer, refSrcImageBuffer->get(), refSrcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &copyBufferToImageRegion);
        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, DE_NULL, 1u, &refSrcCopyImageBarrierPost);
 


@@ -2133,9 +2133,9 @@ void GraphicsTextureTestInstance::transcodeRead ()
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);

                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);

 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);


@@ -2273,9 +2273,9 @@ void GraphicsTextureTestInstance::transcodeWrite ()
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image
                        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
                        // Copy buffer to image

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);

                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
                        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);

-                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
+                       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);

 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
 
                        // Define destination image layout
                        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);

diff --git a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp
index 89842f8..568eddd 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp
@@ -700,7 +700,7 @@ void ImageStoreTestInstance::commandBeforeCompute (const VkCommandBuffer cmdBuff
                VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
                m_constantsBuffer->get(), 0ull, constantsBufferSize);
 
                VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
                m_constantsBuffer->get(), 0ull, constantsBufferSize);
 

-       vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &writeConstantsBarrier, 1, &setImageLayoutBarrier);
+       vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &writeConstantsBarrier, 1, &setImageLayoutBarrier);

 }
 
 void ImageStoreTestInstance::commandBetweenShaderInvocations (const VkCommandBuffer cmdBuffer)
 }
 
 void ImageStoreTestInstance::commandBetweenShaderInvocations (const VkCommandBuffer cmdBuffer)


@@ -1102,7 +1102,7 @@ void ImageLoadStoreTestInstance::commandBeforeCompute (const VkCommandBuffer cmd
                        VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                        m_imageBuffer->get(), 0ull, m_imageSizeBytes);
 
                        VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                        m_imageBuffer->get(), 0ull, m_imageSizeBytes);
 

-               vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,
+               vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,

                        (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &barrierFlushHostWriteBeforeCopy, DE_LENGTH_OF_ARRAY(preCopyImageBarriers), preCopyImageBarriers);
        }
        {
                        (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &barrierFlushHostWriteBeforeCopy, DE_LENGTH_OF_ARRAY(preCopyImageBarriers), preCopyImageBarriers);
        }
        {

diff --git a/external/vulkancts/modules/vulkan/image/vktImageMutableTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageMutableTests.cpp
index d977131..1194896 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageMutableTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageMutableTests.cpp
@@ -1144,7 +1144,7 @@ void UploadDownloadExecutor::uploadClear(Context& context)
                subresourceRange                                                                // VkImageSubresourceRange      subresourceRange;
        };
 
                subresourceRange                                                                // VkImageSubresourceRange      subresourceRange;
        };
 

-       m_vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
+       m_vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,

                0u, DE_NULL, 0u, DE_NULL, 1u, &imageInitBarrier);
 
        for (deUint32 layer = 0; layer < m_caseDef.numLayers; layer++)
                0u, DE_NULL, 0u, DE_NULL, 1u, &imageInitBarrier);
 
        for (deUint32 layer = 0; layer < m_caseDef.numLayers; layer++)


@@ -1262,8 +1262,8 @@ void UploadDownloadExecutor::uploadCopy(Context& context)
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
                DE_NULL,                                                                                        // const void*                          pNext;
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
                DE_NULL,                                                                                        // const void*                          pNext;

-               0u,                                                                                                     // VkAccessFlags                        outputMask;
-               VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                        inputMask;
+               0u,                                                                                                     // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                        dstAccessMask;

                VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;
                VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;


@@ -1300,8 +1300,8 @@ void UploadDownloadExecutor::uploadCopy(Context& context)
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
                DE_NULL,                                                                                        // const void*                          pNext;
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
                DE_NULL,                                                                                        // const void*                          pNext;

-               VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                        outputMask;
-               VK_ACCESS_TRANSFER_READ_BIT,                                            // VkAccessFlags                        inputMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_READ_BIT,                                            // VkAccessFlags                        dstAccessMask;

                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;


@@ -1310,7 +1310,7 @@ void UploadDownloadExecutor::uploadCopy(Context& context)
                makeColorSubresourceRange(0, m_caseDef.numLayers)       // VkImageSubresourceRange      subresourceRange;
        };
 
                makeColorSubresourceRange(0, m_caseDef.numLayers)       // VkImageSubresourceRange      subresourceRange;
        };
 

-       m_vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
+       m_vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,

                0u, DE_NULL, 0u, DE_NULL, 1u, &imagePostInitBarrier);
 
        m_imageLayoutAfterUpload        = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
                0u, DE_NULL, 0u, DE_NULL, 1u, &imagePostInitBarrier);
 
        m_imageLayoutAfterUpload        = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;


@@ -1581,8 +1581,8 @@ void UploadDownloadExecutor::copyImageToBuffer(VkImage                            sourceImage,
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
                DE_NULL,                                                                        // const void*                          pNext;
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
                DE_NULL,                                                                        // const void*                          pNext;

-               srcAccessMask,                                                          // VkAccessFlags                        outputMask;
-               VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        inputMask;
+               srcAccessMask,                                                          // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;

                oldLayout,                                                                      // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
                oldLayout,                                                                      // VkImageLayout                        oldLayout;
                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
index dbdb50d..a2db54e 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
@@ -763,8 +763,8 @@ VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags                    srcAccessMask
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
                DE_NULL,                                                                                // const void*                          pNext;
        {
                VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
                DE_NULL,                                                                                // const void*                          pNext;

-               srcAccessMask,                                                                  // VkAccessFlags                        outputMask;
-               dstAccessMask,                                                                  // VkAccessFlags                        inputMask;
+               srcAccessMask,                                                                  // VkAccessFlags                        srcAccessMask;
+               dstAccessMask,                                                                  // VkAccessFlags                        dstAccessMask;

                oldLayout,                                                                              // VkImageLayout                        oldLayout;
                newLayout,                                                                              // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
                oldLayout,                                                                              // VkImageLayout                        oldLayout;
                newLayout,                                                                              // VkImageLayout                        newLayout;
                VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp
index ab46dab..a2dfe40 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp
@@ -400,9 +400,9 @@ void GraphicsAttachmentsTestInstance::transcode (std::vector<deUint8>& srcData,
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        //Copy buffer to image
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        //Copy buffer to image

-       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);

        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);

-       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);

 
        beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
 
 
        beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
 


@@ -657,7 +657,7 @@ void GraphicsTextureTestInstance::transcode (std::vector<deUint8>& srcData, std:
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        //Copy buffer to image
        vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 
        //Copy buffer to image

-       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrier, 1u, &srcCopyImageBarrier);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrier, 1u, &srcCopyImageBarrier);

        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &srcCopyRegion);
        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
 
        vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &srcCopyRegion);
        vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
 

diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp
index ebbfa16..6cf4906 100644 (file)
--- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp
+++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp
@@ -567,8 +567,8 @@ public:
                                                                                                 VkPipelineStageFlags   srcStageMask,
                                                                                                 VkPipelineStageFlags   dstStageMask,
 
                                                                                                 VkPipelineStageFlags   srcStageMask,
                                                                                                 VkPipelineStageFlags   dstStageMask,
 

-                                                                                                VkAccessFlags                  outputMask,
-                                                                                                VkAccessFlags                  inputMask,
+                                                                                                VkAccessFlags                  srcAccessMask,
+                                                                                                VkAccessFlags                  dstAccessMask,

 
                                                                                                 VkDependencyFlags              flags)
                : m_srcPass                     (srcPass)
 
                                                                                                 VkDependencyFlags              flags)
                : m_srcPass                     (srcPass)


@@ -577,8 +577,8 @@ public:
                , m_srcStageMask        (srcStageMask)
                , m_dstStageMask        (dstStageMask)
 
                , m_srcStageMask        (srcStageMask)
                , m_dstStageMask        (dstStageMask)
 

-               , m_outputMask          (outputMask)
-               , m_inputMask           (inputMask)
+               , m_srcAccessMask       (srcAccessMask)
+               , m_dstAccessMask       (dstAccessMask)

                , m_flags                       (flags)
        {
        }
                , m_flags                       (flags)
        {
        }


@@ -589,8 +589,8 @@ public:
        VkPipelineStageFlags    getSrcStageMask         (void) const { return m_srcStageMask;   }
        VkPipelineStageFlags    getDstStageMask         (void) const { return m_dstStageMask;   }
 
        VkPipelineStageFlags    getSrcStageMask         (void) const { return m_srcStageMask;   }
        VkPipelineStageFlags    getDstStageMask         (void) const { return m_dstStageMask;   }
 

-       VkAccessFlags                   getOutputMask           (void) const { return m_outputMask;             }
-       VkAccessFlags                   getInputMask            (void) const { return m_inputMask;              }
+       VkAccessFlags                   getSrcAccessMask        (void) const { return m_srcAccessMask;  }
+       VkAccessFlags                   getDstAccessMask        (void) const { return m_dstAccessMask;  }

 
        VkDependencyFlags               getFlags                        (void) const { return m_flags;          }
 
 
        VkDependencyFlags               getFlags                        (void) const { return m_flags;          }
 


@@ -601,8 +601,8 @@ private:
        VkPipelineStageFlags    m_srcStageMask;
        VkPipelineStageFlags    m_dstStageMask;
 
        VkPipelineStageFlags    m_srcStageMask;
        VkPipelineStageFlags    m_dstStageMask;
 

-       VkAccessFlags                   m_outputMask;
-       VkAccessFlags                   m_inputMask;
+       VkAccessFlags                   m_srcAccessMask;
+       VkAccessFlags                   m_dstAccessMask;

        VkDependencyFlags               m_flags;
 };
 
        VkDependencyFlags               m_flags;
 };
 


@@ -893,8 +893,8 @@ void logRenderPassInfo (TestLog&                    log,
                        log << TestLog::Message << "Source Stage Mask: " << dep.getSrcStageMask() << TestLog::EndMessage;
                        log << TestLog::Message << "Destination Stage Mask: " << dep.getDstStageMask() << TestLog::EndMessage;
 
                        log << TestLog::Message << "Source Stage Mask: " << dep.getSrcStageMask() << TestLog::EndMessage;
                        log << TestLog::Message << "Destination Stage Mask: " << dep.getDstStageMask() << TestLog::EndMessage;
 

-                       log << TestLog::Message << "Input Mask: " << dep.getInputMask() << TestLog::EndMessage;
-                       log << TestLog::Message << "Output Mask: " << dep.getOutputMask() << TestLog::EndMessage;
+                       log << TestLog::Message << "Input Mask: " << dep.getDstAccessMask() << TestLog::EndMessage;
+                       log << TestLog::Message << "Output Mask: " << dep.getSrcAccessMask() << TestLog::EndMessage;

                        log << TestLog::Message << "Dependency Flags: " << getDependencyFlagsStr(dep.getFlags()) << TestLog::EndMessage;
                }
        }
                        log << TestLog::Message << "Dependency Flags: " << getDependencyFlagsStr(dep.getFlags()) << TestLog::EndMessage;
                }
        }


@@ -1134,8 +1134,8 @@ VkSubpassDependency createSubpassDependency       (const SubpassDependency& dependency
                dependencyInfo.getSrcStageMask(),       // srcStageMask;
                dependencyInfo.getDstStageMask(),       // destStageMask;
 
                dependencyInfo.getSrcStageMask(),       // srcStageMask;
                dependencyInfo.getDstStageMask(),       // destStageMask;
 

-               dependencyInfo.getOutputMask(),         // outputMask;
-               dependencyInfo.getInputMask(),          // inputMask;
+               dependencyInfo.getSrcAccessMask(),      // srcAccessMask;
+               dependencyInfo.getDstAccessMask(),      // dstAccessMask;

 
                dependencyInfo.getFlags()                       // dependencyFlags;
        };
 
                dependencyInfo.getFlags()                       // dependencyFlags;
        };


@@ -2403,7 +2403,7 @@ void pushImageInitializationCommands (const DeviceInterface&                                                              vk,
 
                if (!initializeLayouts.empty())
                        vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
 
                if (!initializeLayouts.empty())
                        vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,

-                                                                 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+                                                                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0,

                                                                  0, (const VkMemoryBarrier*)DE_NULL,
                                                                  0, (const VkBufferMemoryBarrier*)DE_NULL,
                                                                  (deUint32)initializeLayouts.size(), &initializeLayouts[0]);
                                                                  0, (const VkMemoryBarrier*)DE_NULL,
                                                                  0, (const VkBufferMemoryBarrier*)DE_NULL,
                                                                  (deUint32)initializeLayouts.size(), &initializeLayouts[0]);


@@ -2489,7 +2489,7 @@ void pushImageInitializationCommands (const DeviceInterface&                                                              vk,
 
                if (!renderPassLayouts.empty())
                        vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
 
                if (!renderPassLayouts.empty())
                        vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,

-                                                                 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+                                                                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0,

                                                                  0, (const VkMemoryBarrier*)DE_NULL,
                                                                  0, (const VkBufferMemoryBarrier*)DE_NULL,
                                                                  (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);
                                                                  0, (const VkMemoryBarrier*)DE_NULL,
                                                                  0, (const VkBufferMemoryBarrier*)DE_NULL,
                                                                  (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.cpp
index 13dcec2..219e0fd 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.cpp
@@ -871,7 +871,7 @@ void TextureRenderer::clearImage(VkImage image)
        vkd.cmdClearColorImage(*commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &subResourcerange);
 
        addImageTransitionBarrier(*commandBuffer, image,
        vkd.cmdClearColorImage(*commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &subResourcerange);
 
        addImageTransitionBarrier(*commandBuffer, image,

-                                                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                            // VkPipelineStageFlags         srcStageMask
+                                                         VK_PIPELINE_STAGE_TRANSFER_BIT,                                       // VkPipelineStageFlags         srcStageMask

                                                          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                           // VkPipelineStageFlags         dstStageMask
                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                         // VkAccessFlags                        srcAccessMask
                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                         // VkAccessFlags                        dstAccessMask
                                                          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                           // VkPipelineStageFlags         dstStageMask
                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                         // VkAccessFlags                        srcAccessMask
                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                         // VkAccessFlags                        dstAccessMask


@@ -1559,8 +1559,8 @@ void TextureRenderer::renderQuad (tcu::Surface&                                                                   result,
                {
                        VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType              sType;
                        DE_NULL,                                                                        // const void*                  pNext;
                {
                        VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType              sType;
                        DE_NULL,                                                                        // const void*                  pNext;

-                       VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkMemoryOutputFlags  outputMask;
-                       VK_ACCESS_HOST_READ_BIT,                                        // VkMemoryInputFlags   inputMask;
+                       VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                srcAccessMask;
+                       VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags                dstAccessMask;

                        VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                             srcQueueFamilyIndex;
                        VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                             destQueueFamilyIndex;
                        *m_resultBuffer,                                                        // VkBuffer                             buffer;
                        VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                             srcQueueFamilyIndex;
                        VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                             destQueueFamilyIndex;
                        *m_resultBuffer,                                                        // VkBuffer                             buffer;