projects / platform / upstream / VK-GL-CTS.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | compact (merge: 9fd36f1 a85d854)
Merge vk-gl-cts/vulkan-cts-1.2.8 into vk-gl-cts/vulkan-cts-1.3.0
authorMatthew Netsch <quic_mnetsch@quicinc.com>
Fri, 4 Feb 2022 15:38:48 +0000 (10:38 -0500)
committerMatthew Netsch <quic_mnetsch@quicinc.com>
Fri, 4 Feb 2022 16:39:34 +0000 (11:39 -0500)
Change-Id: I0d1eb20fc6b29d9e4c05f1dd9c4f729e8a0453ce

1  2 
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp patch | diff1 | diff2 | blob | history
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp patch | diff1 | diff2 | blob | history

diff --combined external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp
index 7f4786a,617b61a..f4e25bb
--- 1/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp
--- 2/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.cpp
@@@ -399,7 -399,7 +399,7 @@@ protected
                std::size_t             signalSemaphoreValueIndexPlusOne;
        };
  
 -      bool isStageFlagAllowed(VkPipelineStageFlags2KHR stage) const
 +      bool isStageFlagAllowed(VkPipelineStageFlags2 stage) const
        {
                // synchronization2 suports more stages then legacy synchronization
                // and so SynchronizationWrapper can only be used for cases that
@@@ -435,7 -435,7 +435,7 @@@
                        VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
                        VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
                        VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
 -                      VK_PIPELINE_STAGE_NONE_KHR,
 +                      VK_PIPELINE_STAGE_NONE,
                };
  
                if (stage > static_cast<deUint64>(std::numeric_limits<deUint32>::max()))
@@@ -444,7 -444,7 +444,7 @@@
                return (allowedStages.find(static_cast<deUint32>(stage)) != allowedStages.end());
        }
  
 -      bool isAccessFlagAllowed(VkAccessFlags2KHR access) const
 +      bool isAccessFlagAllowed(VkAccessFlags2 access) const
        {
                // synchronization2 suports more access flags then legacy synchronization
                // and so SynchronizationWrapper can only be used for cases that
@@@ -482,7 -482,7 +482,7 @@@
                        VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,
                        VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV,
                        VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV,
 -                      VK_ACCESS_NONE_KHR,
 +                      VK_ACCESS_NONE,
                };
  
                if (access > static_cast<deUint64>(std::numeric_limits<deUint32>::max()))
@@@ -509,11 -509,11 +509,11 @@@ public
        ~LegacySynchronizationWrapper() = default;
  
        void addSubmitInfo(deUint32                                                             waitSemaphoreInfoCount,
 -                                         const VkSemaphoreSubmitInfoKHR*              pWaitSemaphoreInfos,
 +                                         const VkSemaphoreSubmitInfo*                 pWaitSemaphoreInfos,
                                           deUint32                                                             commandBufferInfoCount,
 -                                         const VkCommandBufferSubmitInfoKHR*  pCommandBufferInfos,
 +                                         const VkCommandBufferSubmitInfo*             pCommandBufferInfos,
                                           deUint32                                                             signalSemaphoreInfoCount,
 -                                         const VkSemaphoreSubmitInfoKHR*              pSignalSemaphoreInfos,
 +                                         const VkSemaphoreSubmitInfo*                 pSignalSemaphoreInfos,
                                           bool                                                                 usingWaitTimelineSemaphore,
                                           bool                                                                 usingSignalTimelineSemaphore) override
        {
@@@ -567,12 -567,12 +567,12 @@@
                }
        }
  
 -      void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const override
        {
                DE_ASSERT(pDependencyInfo);
  
 -              VkPipelineStageFlags    srcStageMask                            = VK_PIPELINE_STAGE_NONE_KHR;
 -              VkPipelineStageFlags    dstStageMask                            = VK_PIPELINE_STAGE_NONE_KHR;
 +              VkPipelineStageFlags    srcStageMask                            = VK_PIPELINE_STAGE_NONE;
 +              VkPipelineStageFlags    dstStageMask                            = VK_PIPELINE_STAGE_NONE;
                deUint32                                memoryBarrierCount                      = pDependencyInfo->memoryBarrierCount;
                VkMemoryBarrier*                pMemoryBarriers                         = DE_NULL;
                deUint32                                bufferMemoryBarrierCount        = pDependencyInfo->bufferMemoryBarrierCount;
@@@ -580,14 -580,14 +580,14 @@@
                deUint32                                imageMemoryBarrierCount         = pDependencyInfo->imageMemoryBarrierCount;
                VkImageMemoryBarrier*   pImageMemoryBarriers            = DE_NULL;
  
 -              // translate VkMemoryBarrier2KHR to VkMemoryBarrier
 +              // translate VkMemoryBarrier2 to VkMemoryBarrier
                std::vector<VkMemoryBarrier> memoryBarriers;
                if (memoryBarrierCount)
                {
                        memoryBarriers.reserve(memoryBarrierCount);
                        for (deUint32 i = 0; i < memoryBarrierCount; ++i)
                        {
 -                              const VkMemoryBarrier2KHR& pMemoryBarrier = pDependencyInfo->pMemoryBarriers[i];
 +                              const VkMemoryBarrier2& pMemoryBarrier = pDependencyInfo->pMemoryBarriers[i];
  
                                DE_ASSERT(isStageFlagAllowed(pMemoryBarrier.srcStageMask));
                                DE_ASSERT(isStageFlagAllowed(pMemoryBarrier.dstStageMask));
@@@ -604,14 -604,14 +604,14 @@@
                        pMemoryBarriers = &memoryBarriers[0];
                }
  
 -              // translate VkBufferMemoryBarrier2KHR to VkBufferMemoryBarrier
 +              // translate VkBufferMemoryBarrier2 to VkBufferMemoryBarrier
                std::vector<VkBufferMemoryBarrier> bufferMemoryBarriers;
                if (bufferMemoryBarrierCount)
                {
                        bufferMemoryBarriers.reserve(bufferMemoryBarrierCount);
                        for (deUint32 i = 0; i < bufferMemoryBarrierCount; ++i)
                        {
 -                              const VkBufferMemoryBarrier2KHR& pBufferMemoryBarrier = pDependencyInfo->pBufferMemoryBarriers[i];
 +                              const VkBufferMemoryBarrier2& pBufferMemoryBarrier = pDependencyInfo->pBufferMemoryBarriers[i];
  
                                DE_ASSERT(isStageFlagAllowed(pBufferMemoryBarrier.srcStageMask));
                                DE_ASSERT(isStageFlagAllowed(pBufferMemoryBarrier.dstStageMask));
@@@ -633,14 -633,14 +633,14 @@@
                        pBufferMemoryBarriers = &bufferMemoryBarriers[0];
                }
  
 -              // translate VkImageMemoryBarrier2KHR to VkImageMemoryBarrier
 +              // translate VkImageMemoryBarrier2 to VkImageMemoryBarrier
                std::vector<VkImageMemoryBarrier> imageMemoryBarriers;
                if (imageMemoryBarrierCount)
                {
                        imageMemoryBarriers.reserve(imageMemoryBarrierCount);
                        for (deUint32 i = 0; i < imageMemoryBarrierCount; ++i)
                        {
 -                              const VkImageMemoryBarrier2KHR& pImageMemoryBarrier = pDependencyInfo->pImageMemoryBarriers[i];
 +                              const VkImageMemoryBarrier2& pImageMemoryBarrier = pDependencyInfo->pImageMemoryBarriers[i];
  
                                DE_ASSERT(isStageFlagAllowed(pImageMemoryBarrier.srcStageMask));
                                DE_ASSERT(isStageFlagAllowed(pImageMemoryBarrier.dstStageMask));
@@@ -677,11 -677,11 +677,11 @@@
                );
        }
  
 -      void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const override
        {
                DE_ASSERT(pDependencyInfo);
  
 -              VkPipelineStageFlags2KHR srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR;
 +              VkPipelineStageFlags2 srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
                if (pDependencyInfo->pMemoryBarriers)
                        srcStageMask = pDependencyInfo->pMemoryBarriers[0].srcStageMask;
                if (pDependencyInfo->pBufferMemoryBarriers)
@@@ -693,19 -693,19 +693,19 @@@
                m_vk.cmdSetEvent(commandBuffer, event, static_cast<VkPipelineStageFlags>(srcStageMask));
        }
  
 -      void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR flag) const override
 +      void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 flag) const override
        {
                DE_ASSERT(isStageFlagAllowed(flag));
                VkPipelineStageFlags legacyStageMask = static_cast<VkPipelineStageFlags>(flag);
                m_vk.cmdResetEvent(commandBuffer, event, legacyStageMask);
        }
  
 -      void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfo) const override
        {
                DE_ASSERT(pDependencyInfo);
  
 -              VkPipelineStageFlags2KHR                        srcStageMask                            = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR;
 -              VkPipelineStageFlags2KHR                        dstStageMask                            = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR;
 +              VkPipelineStageFlags2                           srcStageMask                            = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
 +              VkPipelineStageFlags2                           dstStageMask                            = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
                deUint32                                                        memoryBarrierCount                      = pDependencyInfo->memoryBarrierCount;
                deUint32                                                        bufferMemoryBarrierCount        = pDependencyInfo->bufferMemoryBarrierCount;
                deUint32                                                        imageMemoryBarrierCount         = pDependencyInfo->imageMemoryBarrierCount;
@@@ -724,7 -724,7 +724,7 @@@
                        memoryBarriers.reserve(memoryBarrierCount);
                        for (deUint32 i = 0; i < memoryBarrierCount; ++i)
                        {
 -                              const VkMemoryBarrier2KHR& mb = pDependencyInfo->pMemoryBarriers[i];
 +                              const VkMemoryBarrier2& mb = pDependencyInfo->pMemoryBarriers[i];
                                DE_ASSERT(isAccessFlagAllowed(mb.srcAccessMask));
                                DE_ASSERT(isAccessFlagAllowed(mb.dstAccessMask));
                                memoryBarriers.push_back(
@@@ -744,7 -744,7 +744,7 @@@
                        bufferMemoryBarriers.reserve(bufferMemoryBarrierCount);
                        for (deUint32 i = 0; i < bufferMemoryBarrierCount; ++i)
                        {
 -                              const VkBufferMemoryBarrier2KHR& bmb = pDependencyInfo->pBufferMemoryBarriers[i];
 +                              const VkBufferMemoryBarrier2& bmb = pDependencyInfo->pBufferMemoryBarriers[i];
                                DE_ASSERT(isAccessFlagAllowed(bmb.srcAccessMask));
                                DE_ASSERT(isAccessFlagAllowed(bmb.dstAccessMask));
                                bufferMemoryBarriers.push_back(
@@@ -769,7 -769,7 +769,7 @@@
                        imageMemoryBarriers.reserve(imageMemoryBarrierCount);
                        for (deUint32 i = 0; i < imageMemoryBarrierCount; ++i)
                        {
 -                              const VkImageMemoryBarrier2KHR& imb = pDependencyInfo->pImageMemoryBarriers[i];
 +                              const VkImageMemoryBarrier2& imb = pDependencyInfo->pImageMemoryBarriers[i];
                                DE_ASSERT(isAccessFlagAllowed(imb.srcAccessMask));
                                DE_ASSERT(isAccessFlagAllowed(imb.dstAccessMask));
                                imageMemoryBarriers.push_back(
@@@ -879,58 -879,58 +879,58 @@@ public
        ~Synchronization2Wrapper() = default;
  
        void addSubmitInfo(deUint32                                                             waitSemaphoreInfoCount,
 -                                         const VkSemaphoreSubmitInfoKHR*              pWaitSemaphoreInfos,
 +                                         const VkSemaphoreSubmitInfo*                 pWaitSemaphoreInfos,
                                           deUint32                                                             commandBufferInfoCount,
 -                                         const VkCommandBufferSubmitInfoKHR*  pCommandBufferInfos,
 +                                         const VkCommandBufferSubmitInfo*             pCommandBufferInfos,
                                           deUint32                                                             signalSemaphoreInfoCount,
 -                                         const VkSemaphoreSubmitInfoKHR*              pSignalSemaphoreInfos,
 +                                         const VkSemaphoreSubmitInfo*                 pSignalSemaphoreInfos,
                                           bool                                                                 usingWaitTimelineSemaphore,
                                           bool                                                                 usingSignalTimelineSemaphore) override
        {
                DE_UNREF(usingWaitTimelineSemaphore);
                DE_UNREF(usingSignalTimelineSemaphore);
  
 -              m_submitInfo.push_back(VkSubmitInfo2KHR{
 -                      VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR,            // VkStructureType                                              sType
 +              m_submitInfo.push_back(VkSubmitInfo2{
 +                      VK_STRUCTURE_TYPE_SUBMIT_INFO_2,                        // VkStructureType                                              sType
                        DE_NULL,                                                                        // const void*                                                  pNext
 -                      0u,                                                                                     // VkSubmitFlagsKHR                                             flags
 +                      0u,                                                                                     // VkSubmitFlags                                                flags
                        waitSemaphoreInfoCount,                                         // deUint32                                                             waitSemaphoreInfoCount
 -                      pWaitSemaphoreInfos,                                            // const VkSemaphoreSubmitInfoKHR*              pWaitSemaphoreInfos
 +                      pWaitSemaphoreInfos,                                            // const VkSemaphoreSubmitInfo*                 pWaitSemaphoreInfos
                        commandBufferInfoCount,                                         // deUint32                                                             commandBufferInfoCount
 -                      pCommandBufferInfos,                                            // const VkCommandBufferSubmitInfoKHR*  pCommandBufferInfos
 +                      pCommandBufferInfos,                                            // const VkCommandBufferSubmitInfo*             pCommandBufferInfos
                        signalSemaphoreInfoCount,                                       // deUint32                                                             signalSemaphoreInfoCount
 -                      pSignalSemaphoreInfos                                           // const VkSemaphoreSubmitInfoKHR*              pSignalSemaphoreInfos
 +                      pSignalSemaphoreInfos                                           // const VkSemaphoreSubmitInfo*                 pSignalSemaphoreInfos
                });
        }
  
 -      void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdPipelineBarrier(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const override
        {
 -              m_vk.cmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
 +              m_vk.cmdPipelineBarrier2(commandBuffer, pDependencyInfo);
        }
  
 -      void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const override
        {
 -              m_vk.cmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
 +              m_vk.cmdSetEvent2(commandBuffer, event, pDependencyInfo);
        }
  
 -      void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfo) const override
 +      void cmdWaitEvents(VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfo) const override
        {
 -              m_vk.cmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfo);
 +              m_vk.cmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfo);
        }
  
 -      void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR flag) const override
 +      void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 flag) const override
        {
 -              m_vk.cmdResetEvent2KHR(commandBuffer, event, flag);
 +              m_vk.cmdResetEvent2(commandBuffer, event, flag);
        }
  
        VkResult queueSubmit(VkQueue queue, VkFence fence) override
        {
 -              return m_vk.queueSubmit2KHR(queue, static_cast<deUint32>(m_submitInfo.size()), &m_submitInfo[0], fence);
 +              return m_vk.queueSubmit2(queue, static_cast<deUint32>(m_submitInfo.size()), &m_submitInfo[0], fence);
        }
  
  protected:
  
 -      std::vector<VkSubmitInfo2KHR> m_submitInfo;
 +      std::vector<VkSubmitInfo2> m_submitInfo;
  };
  
  SynchronizationWrapperPtr getSynchronizationWrapper(SynchronizationType               type,
@@@ -949,15 -949,15 +949,15 @@@ void submitCommandsAndWait(Synchronizat
                                                   const VkQueue                                queue,
                                                   const VkCommandBuffer                cmdBuffer)
  {
 -      VkCommandBufferSubmitInfoKHR commandBufferInfoCount = makeCommonCommandBufferSubmitInfo(cmdBuffer);
 +      VkCommandBufferSubmitInfo commandBufferInfoCount = makeCommonCommandBufferSubmitInfo(cmdBuffer);
  
        synchronizationWrapper->addSubmitInfo(
                0u,                                                                             // deUint32                                                             waitSemaphoreInfoCount
 -              DE_NULL,                                                                // const VkSemaphoreSubmitInfoKHR*              pWaitSemaphoreInfos
 +              DE_NULL,                                                                // const VkSemaphoreSubmitInfo*                 pWaitSemaphoreInfos
                1u,                                                                             // deUint32                                                             commandBufferInfoCount
 -              &commandBufferInfoCount,                                // const VkCommandBufferSubmitInfoKHR*  pCommandBufferInfos
 +              &commandBufferInfoCount,                                // const VkCommandBufferSubmitInfo*             pCommandBufferInfos
                0u,                                                                             // deUint32                                                             signalSemaphoreInfoCount
 -              DE_NULL                                                                 // const VkSemaphoreSubmitInfoKHR*              pSignalSemaphoreInfos
 +              DE_NULL                                                                 // const VkSemaphoreSubmitInfo*                 pSignalSemaphoreInfos
        );
  
        const Unique<VkFence> fence(createFence(vk, device));
@@@ -1033,43 -1033,44 +1033,44 @@@ bool isIndirectBuffer (const ResourceTy
        }
  }
  
 -VkCommandBufferSubmitInfoKHR makeCommonCommandBufferSubmitInfo (const VkCommandBuffer cmdBuf)
 +VkCommandBufferSubmitInfo makeCommonCommandBufferSubmitInfo (const VkCommandBuffer cmdBuf)
  {
        return
        {
 -              VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR,       // VkStructureType              sType
 +              VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,           // VkStructureType              sType
                DE_NULL,                                                                                        // const void*                  pNext
                cmdBuf,                                                                                         // VkCommandBuffer              commandBuffer
                0u                                                                                                      // uint32_t                             deviceMask
        };
  }
  
 -VkSemaphoreSubmitInfoKHR makeCommonSemaphoreSubmitInfo(VkSemaphore semaphore, deUint64 value, VkPipelineStageFlags2KHR stageMask)
 +VkSemaphoreSubmitInfo makeCommonSemaphoreSubmitInfo(VkSemaphore semaphore, deUint64 value, VkPipelineStageFlags2 stageMask)
  {
        return
        {
 -              VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,    // VkStructureType                              sType
 +              VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,                // VkStructureType                              sType
                DE_NULL,                                                                                // const void*                                  pNext
                semaphore,                                                                              // VkSemaphore                                  semaphore
                value,                                                                                  // deUint64                                             value
 -              stageMask,                                                                              // VkPipelineStageFlags2KHR             stageMask
 +              stageMask,                                                                              // VkPipelineStageFlags2                stageMask
                0u                                                                                              // deUint32                                             deviceIndex
        };
  }
  
- VkDependencyInfo makeCommonDependencyInfo(const VkMemoryBarrier2* pMemoryBarrier, const VkBufferMemoryBarrier2* pBufferMemoryBarrier, const VkImageMemoryBarrier2* pImageMemoryBarrier)
 -VkDependencyInfoKHR makeCommonDependencyInfo(const VkMemoryBarrier2KHR* pMemoryBarrier, const VkBufferMemoryBarrier2KHR* pBufferMemoryBarrier, const VkImageMemoryBarrier2KHR* pImageMemoryBarrier,
 -                                                                                       bool eventDependency)
++VkDependencyInfo makeCommonDependencyInfo(const VkMemoryBarrier2* pMemoryBarrier, const VkBufferMemoryBarrier2* pBufferMemoryBarrier, const VkImageMemoryBarrier2* pImageMemoryBarrier,
++                                                                                   bool eventDependency)
  {
        return
        {
-               VK_STRUCTURE_TYPE_DEPENDENCY_INFO,                      // VkStructureType                                      sType
-               DE_NULL,                                                                        // const void*                                          pNext
-               VK_DEPENDENCY_BY_REGION_BIT,                            // VkDependencyFlags                            dependencyFlags
-               !!pMemoryBarrier,                                                       // deUint32                                                     memoryBarrierCount
-               pMemoryBarrier,                                                         // const VkMemoryBarrier2*              pMemoryBarriers
-               !!pBufferMemoryBarrier,                                         // deUint32                                                     bufferMemoryBarrierCount
-               pBufferMemoryBarrier,                                           // const VkBufferMemoryBarrier2* pBufferMemoryBarriers
-               !!pImageMemoryBarrier,                                          // deUint32                                                     imageMemoryBarrierCount
-               pImageMemoryBarrier                                                     // const VkImageMemoryBarrier2* pImageMemoryBarriers
 -              VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,                          // VkStructureType                                      sType
++              VK_STRUCTURE_TYPE_DEPENDENCY_INFO,                              // VkStructureType                                      sType
+               DE_NULL,                                                                                        // const void*                                          pNext
+               eventDependency ? (VkDependencyFlags)0u : (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT,       // VkDependencyFlags                            dependencyFlags
+               !!pMemoryBarrier,                                                                       // deUint32                                                     memoryBarrierCount
+               pMemoryBarrier,                                                                         // const VkMemoryBarrier2KHR*           pMemoryBarriers
+               !!pBufferMemoryBarrier,                                                         // deUint32                                                     bufferMemoryBarrierCount
+               pBufferMemoryBarrier,                                                           // const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers
+               !!pImageMemoryBarrier,                                                          // deUint32                                                     imageMemoryBarrierCount
+               pImageMemoryBarrier                                                                     // const VkImageMemoryBarrier2KHR*      pImageMemoryBarriers
        };
  }
  
diff --combined external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp
index d78001f,c937cc7..4d99be1
--- 1/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp
--- 2/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationUtil.hpp
@@@ -189,27 -189,27 +189,27 @@@ public
        virtual ~SynchronizationWrapperBase() = default;
  
        virtual void                    addSubmitInfo           (deUint32                                                                       waitSemaphoreInfoCount,
 -                                                                                               const vk::VkSemaphoreSubmitInfoKHR*            pWaitSemaphoreInfos,
 +                                                                                               const vk::VkSemaphoreSubmitInfo*                       pWaitSemaphoreInfos,
                                                                                                 deUint32                                                                       commandBufferInfoCount,
 -                                                                                               const vk::VkCommandBufferSubmitInfoKHR*        pCommandBufferInfos,
 +                                                                                               const vk::VkCommandBufferSubmitInfo*           pCommandBufferInfos,
                                                                                                 deUint32                                                                       signalSemaphoreInfoCount,
 -                                                                                               const vk::VkSemaphoreSubmitInfoKHR*            pSignalSemaphoreInfos,
 +                                                                                               const vk::VkSemaphoreSubmitInfo*                       pSignalSemaphoreInfos,
                                                                                                 bool                                                                           usingWaitTimelineSemaphore = DE_FALSE,
                                                                                                 bool                                                                           usingSignalTimelineSemaphore = DE_FALSE) = 0;
  
        virtual void                    cmdPipelineBarrier      (vk::VkCommandBuffer                                            commandBuffer,
 -                                                                                               const vk::VkDependencyInfoKHR*                         pDependencyInfo) const = 0;
 +                                                                                               const vk::VkDependencyInfo*                            pDependencyInfo) const = 0;
  
        virtual void                    cmdSetEvent                     (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 vk::VkEvent                                                            event,
 -                                                                                               const vk::VkDependencyInfoKHR*                         pDependencyInfo) const = 0;
 +                                                                                               const vk::VkDependencyInfo*                            pDependencyInfo) const = 0;
        virtual void                    cmdResetEvent           (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 vk::VkEvent                                                            event,
 -                                                                                               vk::VkPipelineStageFlags2KHR                           flag) const = 0;
 +                                                                                               vk::VkPipelineStageFlags2                                      flag) const = 0;
        virtual void                    cmdWaitEvents           (vk::VkCommandBuffer                                            commandBuffer,
                                                                                                 deUint32                                                                       eventCount,
                                                                                                 const vk::VkEvent*                                                     pEvents,
 -                                                                                               const vk::VkDependencyInfoKHR*                         pDependencyInfo) const = 0;
 +                                                                                               const vk::VkDependencyInfo*                            pDependencyInfo) const = 0;
  
        virtual vk::VkResult    queueSubmit                     (vk::VkQueue                                                            queue,
                                                                                                 vk::VkFence                                                            fence) = 0;
@@@ -299,7 -299,7 +299,7 @@@ std::string                                                        getResourceNam
  bool                                                          isIndirectBuffer                                                        (const ResourceType type);
  vk::VkCommandBufferSubmitInfoKHR      makeCommonCommandBufferSubmitInfo                       (const vk::VkCommandBuffer cmdBuf);
  vk::VkSemaphoreSubmitInfoKHR          makeCommonSemaphoreSubmitInfo                           (vk::VkSemaphore semaphore, deUint64 value, vk::VkPipelineStageFlags2KHR stageMask);
- vk::VkDependencyInfoKHR                               makeCommonDependencyInfo                                        (const vk::VkMemoryBarrier2KHR* pMemoryBarrier = DE_NULL, const vk::VkBufferMemoryBarrier2KHR* pBufferMemoryBarrier = DE_NULL, const vk::VkImageMemoryBarrier2KHR* pImageMemoryBarrier = DE_NULL);
+ vk::VkDependencyInfoKHR                               makeCommonDependencyInfo                                        (const vk::VkMemoryBarrier2KHR* pMemoryBarrier = DE_NULL, const vk::VkBufferMemoryBarrier2KHR* pBufferMemoryBarrier = DE_NULL, const vk::VkImageMemoryBarrier2KHR* pImageMemoryBarrier = DE_NULL, bool eventDependency = DE_FALSE);
  
  } // synchronization
  } // vkt
Domain: Graphics System / GL;