Add support for extension VK_KHR_synchronization2.

- MVKPhysicalDevice add support for VkPhysicalDeviceSynchronization2Features.
- Pass sync2 structs to MVKPipelineBarrier, MVKCmdPipelineBarrier, MVKCmdSetEvent,
  MVKCmdResetEvent, MVKCmdWaitEvents, MVKRenderPass, MVKQueue & MVKQueueSubmission.
- Replace use of VkPipelineStageFlags & VkAccessFlags
  with VkPipelineStageFlags2 & VkAccessFlags2.
- Add stage masks to MVKPipelineBarrier, and redefine apply*MemoryBarrier()
  functions to remove separately passing stage masks.
- Add MVKSemaphoreSubmitInfo to track semaphores in MVKQueueSubmission.
- Add MVKCommandBufferSubmitInfo to track command buffers
  in MVKQueueCommandBufferSubmission.
- Add MVKSubpassDependency to combine VkSubpassDependency & VkMemoryBarrier2 in MVKRenderPass.
- Remove abstract MVKCmdSetResetEvent superclass.
- Streamline code in MVKMTLFunction::operator= (unrelated).

Docs/MoltenVK_Runtime_UserGuide.md

@@ -350,6 +350,7 @@ In addition to core *Vulkan* functionality, **MoltenVK**  also supports the foll
 - `VK_KHR_surface`
 - `VK_KHR_swapchain`
 - `VK_KHR_swapchain_mutable_format`
+- `VK_KHR_synchronization2`
 - `VK_KHR_timeline_semaphore`
 - `VK_KHR_uniform_buffer_standard_layout`
 - `VK_KHR_variable_pointers`

Docs/Whats_New.md

@@ -18,6 +18,8 @@ MoltenVK 1.2.6
 
 Released TBD
 
+- Add support for extensions:
+	- `VK_KHR_synchronization2`
 - Fix rare case where vertex attribute buffers are not bound to Metal 
   when no other bindings change between pipelines.
 - Ensure objects retained for life of `MTLCommandBuffer` during `vkCmdBlitImage()` & `vkQueuePresentKHR()`.

MoltenVK/MoltenVK/API/mvk_datatypes.h

@@ -414,13 +414,13 @@ MTLWinding mvkMTLWindingFromSpvExecutionMode(uint32_t spvMode);
 MTLTessellationPartitionMode mvkMTLTessellationPartitionModeFromSpvExecutionMode(uint32_t spvMode);
 
 /**
- * Returns the combination of Metal MTLRenderStage bits corresponding to the specified Vulkan VkPiplineStageFlags,
+ * Returns the combination of Metal MTLRenderStage bits corresponding to the specified Vulkan VkPipelineStageFlags2,
  * taking into consideration whether the barrier is to be placed before or after the specified pipeline stages.
  */
-MTLRenderStages mvkMTLRenderStagesFromVkPipelineStageFlags(VkPipelineStageFlags vkStages, bool placeBarrierBefore);
+MTLRenderStages mvkMTLRenderStagesFromVkPipelineStageFlags(VkPipelineStageFlags2 vkStages, bool placeBarrierBefore);
 
-/** Returns the combination of Metal MTLBarrierScope bits corresponding to the specified Vulkan VkAccessFlags. */
-MTLBarrierScope mvkMTLBarrierScopeFromVkAccessFlags(VkAccessFlags vkAccess);
+/** Returns the combination of Metal MTLBarrierScope bits corresponding to the specified Vulkan VkAccessFlags2. */
+MTLBarrierScope mvkMTLBarrierScopeFromVkAccessFlags(VkAccessFlags2 vkAccess);
 
 #pragma mark -
 #pragma mark Geometry conversions

MoltenVK/MoltenVK/Commands/MVKCmdPipeline.h

@@ -41,6 +41,9 @@ template <size_t N>
 class MVKCmdPipelineBarrier : public MVKCommand {
 
 public:
+	VkResult setContent(MVKCommandBuffer* cmdBuff,
+						const VkDependencyInfo* pDependencyInfo);
+
 	VkResult setContent(MVKCommandBuffer* cmdBuff,
 						VkPipelineStageFlags srcStageMask,
 						VkPipelineStageFlags dstStageMask,
@@ -59,8 +62,6 @@ class MVKCmdPipelineBarrier : public MVKCommand {
 	bool coversTextures();
 
 	MVKSmallVector<MVKPipelineBarrier, N> _barriers;
-	VkPipelineStageFlags _srcStageMask;
-	VkPipelineStageFlags _dstStageMask;
 	VkDependencyFlags _dependencyFlags;
 };
 
@@ -281,49 +282,46 @@ class MVKCmdPushDescriptorSetWithTemplate : public MVKCommand {
 
 
 #pragma mark -
-#pragma mark MVKCmdSetResetEvent
+#pragma mark MVKCmdSetEvent
 
-/** Abstract Vulkan command to set or reset an event. */
-class MVKCmdSetResetEvent : public MVKCommand {
+/** Vulkan command to set an event. */
+class MVKCmdSetEvent : public MVKCommand {
 
 public:
 	VkResult setContent(MVKCommandBuffer* cmdBuff,
 						VkEvent event,
-						VkPipelineStageFlags stageMask);
-
-protected:
-	MVKEvent* _mvkEvent;
-
-};
-
-
-#pragma mark -
-#pragma mark MVKCmdSetEvent
+						const VkDependencyInfo* pDependencyInfo);
 
-/** Vulkan command to set an event. */
-class MVKCmdSetEvent : public MVKCmdSetResetEvent {
+	VkResult setContent(MVKCommandBuffer* cmdBuff,
+						VkEvent event,
+						VkPipelineStageFlags stageMask);
 
-public:
 	void encode(MVKCommandEncoder* cmdEncoder) override;
 
 protected:
 	MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
 
+	MVKEvent* _mvkEvent;
 };
 
 
 #pragma mark -
 #pragma mark MVKCmdResetEvent
 
 /** Vulkan command to reset an event. */
-class MVKCmdResetEvent : public MVKCmdSetResetEvent {
+class MVKCmdResetEvent : public MVKCommand {
 
 public:
+	VkResult setContent(MVKCommandBuffer* cmdBuff,
+						VkEvent event,
+						VkPipelineStageFlags2 stageMask);
+
 	void encode(MVKCommandEncoder* cmdEncoder) override;
 
 protected:
 	MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
 
+	MVKEvent* _mvkEvent;
 };
 
 
@@ -339,6 +337,11 @@ template <size_t N>
 class MVKCmdWaitEvents : public MVKCommand {
 
 public:
+	VkResult setContent(MVKCommandBuffer* cmdBuff,
+						uint32_t eventCount,
+						const VkEvent* pEvents,
+						const VkDependencyInfo* pDependencyInfos);
+
 	VkResult setContent(MVKCommandBuffer* cmdBuff,
 						uint32_t eventCount,
 						const VkEvent* pEvents,

MoltenVK/MoltenVK/Commands/MVKCmdPipeline.mm

@@ -29,6 +29,29 @@
 #pragma mark -
 #pragma mark MVKCmdPipelineBarrier
 
+template <size_t N>
+VkResult MVKCmdPipelineBarrier<N>::setContent(MVKCommandBuffer* cmdBuff,
+											  const VkDependencyInfo* pDependencyInfo) {
+	_dependencyFlags = pDependencyInfo->dependencyFlags;
+
+	_barriers.clear();	// Clear for reuse
+	_barriers.reserve(pDependencyInfo->memoryBarrierCount + 
+					  pDependencyInfo->bufferMemoryBarrierCount +
+					  pDependencyInfo->imageMemoryBarrierCount);
+
+	for (uint32_t i = 0; i < pDependencyInfo->memoryBarrierCount; i++) {
+		_barriers.emplace_back(pDependencyInfo->pMemoryBarriers[i]);
+	}
+	for (uint32_t i = 0; i < pDependencyInfo->bufferMemoryBarrierCount; i++) {
+		_barriers.emplace_back(pDependencyInfo->pBufferMemoryBarriers[i]);
+	}
+	for (uint32_t i = 0; i < pDependencyInfo->imageMemoryBarrierCount; i++) {
+		_barriers.emplace_back(pDependencyInfo->pImageMemoryBarriers[i]);
+	}
+
+	return VK_SUCCESS;
+}
+
 template <size_t N>
 VkResult MVKCmdPipelineBarrier<N>::setContent(MVKCommandBuffer* cmdBuff,
 											  VkPipelineStageFlags srcStageMask,
@@ -40,21 +63,19 @@
 											  const VkBufferMemoryBarrier* pBufferMemoryBarriers,
 											  uint32_t imageMemoryBarrierCount,
 											  const VkImageMemoryBarrier* pImageMemoryBarriers) {
-	_srcStageMask = srcStageMask;
-	_dstStageMask = dstStageMask;
 	_dependencyFlags = dependencyFlags;
 
 	_barriers.clear();	// Clear for reuse
 	_barriers.reserve(memoryBarrierCount + bufferMemoryBarrierCount + imageMemoryBarrierCount);
 
 	for (uint32_t i = 0; i < memoryBarrierCount; i++) {
-		_barriers.emplace_back(pMemoryBarriers[i]);
+		_barriers.emplace_back(pMemoryBarriers[i], srcStageMask, dstStageMask);
 	}
 	for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) {
-		_barriers.emplace_back(pBufferMemoryBarriers[i]);
+		_barriers.emplace_back(pBufferMemoryBarriers[i], srcStageMask, dstStageMask);
 	}
 	for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) {
-		_barriers.emplace_back(pImageMemoryBarriers[i]);
+		_barriers.emplace_back(pImageMemoryBarriers[i], srcStageMask, dstStageMask);
 	}
 
 	return VK_SUCCESS;
@@ -67,13 +88,9 @@
 	// Calls below invoke MTLBlitCommandEncoder so must apply this first.
 	// Check if pipeline barriers are available and we are in a renderpass.
 	if (cmdEncoder->getDevice()->_pMetalFeatures->memoryBarriers && cmdEncoder->_mtlRenderEncoder) {
-		MTLRenderStages srcStages = mvkMTLRenderStagesFromVkPipelineStageFlags(_srcStageMask, false);
-		MTLRenderStages dstStages = mvkMTLRenderStagesFromVkPipelineStageFlags(_dstStageMask, true);
-
-		id<MTLResource> resources[_barriers.size()];
-		uint32_t rezCnt = 0;
-
 		for (auto& b : _barriers) {
+			MTLRenderStages srcStages = mvkMTLRenderStagesFromVkPipelineStageFlags(b.srcStageMask, false);
+			MTLRenderStages dstStages = mvkMTLRenderStagesFromVkPipelineStageFlags(b.dstStageMask, true);
 			switch (b.type) {
 				case MVKPipelineBarrier::Memory: {
 					MTLBarrierScope scope = (mvkMTLBarrierScopeFromVkAccessFlags(b.srcAccessMask) |
@@ -84,27 +101,30 @@
 					break;
 				}
 
-				case MVKPipelineBarrier::Buffer:
-					resources[rezCnt++] = b.mvkBuffer->getMTLBuffer();
+				case MVKPipelineBarrier::Buffer: {
+					id<MTLResource> mtlRez = b.mvkBuffer->getMTLBuffer();
+					[cmdEncoder->_mtlRenderEncoder memoryBarrierWithResources: &mtlRez
+																		count: 1
+																  afterStages: srcStages
+																 beforeStages: dstStages];
 					break;
-
-				case MVKPipelineBarrier::Image:
-                    for (uint8_t planeIndex = 0; planeIndex < b.mvkImage->getPlaneCount(); planeIndex++) {
-                        resources[rezCnt++] = b.mvkImage->getMTLTexture(planeIndex);
-                    }
+				}
+				case MVKPipelineBarrier::Image: {
+					uint32_t plnCnt = b.mvkImage->getPlaneCount();
+					id<MTLResource> mtlRezs[plnCnt];
+					for (uint8_t plnIdx = 0; plnIdx < plnCnt; plnIdx++) {
+						mtlRezs[plnIdx] = b.mvkImage->getMTLTexture(plnIdx);
+					}
+					[cmdEncoder->_mtlRenderEncoder memoryBarrierWithResources: mtlRezs
+																		count: plnCnt
+																  afterStages: srcStages
+																 beforeStages: dstStages];
 					break;
-
+				}
 				default:
 					break;
 			}
 		}
-
-		if (rezCnt) {
-			[cmdEncoder->_mtlRenderEncoder memoryBarrierWithResources: resources
-																count: rezCnt
-														  afterStages: srcStages
-														 beforeStages: dstStages];
-		}
 	} else if (cmdEncoder->getDevice()->_pMetalFeatures->textureBarriers) {
 #if !MVK_MACCAT
 		if (coversTextures()) { [cmdEncoder->_mtlRenderEncoder textureBarrier]; }
@@ -138,15 +158,15 @@
 	for (auto& b : _barriers) {
 		switch (b.type) {
 			case MVKPipelineBarrier::Memory:
-				mvkDvc->applyMemoryBarrier(_srcStageMask, _dstStageMask, b, cmdEncoder, cmdUse);
+				mvkDvc->applyMemoryBarrier(b, cmdEncoder, cmdUse);
 				break;
 
 			case MVKPipelineBarrier::Buffer:
-				b.mvkBuffer->applyBufferMemoryBarrier(_srcStageMask, _dstStageMask, b, cmdEncoder, cmdUse);
+				b.mvkBuffer->applyBufferMemoryBarrier(b, cmdEncoder, cmdUse);
 				break;
 
 			case MVKPipelineBarrier::Image:
-				b.mvkImage->applyImageMemoryBarrier(_srcStageMask, _dstStageMask, b, cmdEncoder, cmdUse);
+				b.mvkImage->applyImageMemoryBarrier(b, cmdEncoder, cmdUse);
 				break;
 
 			default:
@@ -493,19 +513,23 @@
 
 
 #pragma mark -
-#pragma mark MVKCmdSetResetEvent
+#pragma mark MVKCmdSetEvent
 
-VkResult MVKCmdSetResetEvent::setContent(MVKCommandBuffer* cmdBuff,
-										 VkEvent event,
-										 VkPipelineStageFlags stageMask) {
+VkResult MVKCmdSetEvent::setContent(MVKCommandBuffer* cmdBuff,
+									VkEvent event,
+									VkPipelineStageFlags stageMask) {
 	_mvkEvent = (MVKEvent*)event;
 
 	return VK_SUCCESS;
 }
 
+VkResult MVKCmdSetEvent::setContent(MVKCommandBuffer* cmdBuff,
+									VkEvent event,
+									const VkDependencyInfo* pDependencyInfo) {
+	_mvkEvent = (MVKEvent*)event;
 
-#pragma mark -
-#pragma mark MVKCmdSetEvent
+	return VK_SUCCESS;
+}
 
 void MVKCmdSetEvent::encode(MVKCommandEncoder* cmdEncoder) {
 	cmdEncoder->signalEvent(_mvkEvent, true);
@@ -515,6 +539,14 @@
 #pragma mark -
 #pragma mark MVKCmdResetEvent
 
+VkResult MVKCmdResetEvent::setContent(MVKCommandBuffer* cmdBuff,
+									  VkEvent event,
+									  VkPipelineStageFlags2 stageMask) {
+	_mvkEvent = (MVKEvent*)event;
+
+	return VK_SUCCESS;
+}
+
 void MVKCmdResetEvent::encode(MVKCommandEncoder* cmdEncoder) {
 	cmdEncoder->signalEvent(_mvkEvent, false);
 }
@@ -523,6 +555,20 @@
 #pragma mark -
 #pragma mark MVKCmdWaitEvents
 
+template <size_t N>
+VkResult MVKCmdWaitEvents<N>::setContent(MVKCommandBuffer* cmdBuff,
+										 uint32_t eventCount,
+										 const VkEvent* pEvents,
+										 const VkDependencyInfo* pDependencyInfos) {
+	_mvkEvents.clear();	// Clear for reuse
+	_mvkEvents.reserve(eventCount);
+	for (uint32_t i = 0; i < eventCount; i++) {
+		_mvkEvents.push_back((MVKEvent*)pEvents[i]);
+	}
+
+	return VK_SUCCESS;
+}
+
 template <size_t N>
 VkResult MVKCmdWaitEvents<N>::setContent(MVKCommandBuffer* cmdBuff,
 										 uint32_t eventCount,

MoltenVK/MoltenVK/Commands/MVKCmdQueries.h

@@ -85,7 +85,7 @@ class MVKCmdWriteTimestamp : public MVKCmdQuery {
 
 public:
 	VkResult setContent(MVKCommandBuffer* cmdBuff,
-						VkPipelineStageFlagBits pipelineStage,
+						VkPipelineStageFlags2 stage,
 						VkQueryPool queryPool,
 						uint32_t query);
 
@@ -94,7 +94,7 @@ class MVKCmdWriteTimestamp : public MVKCmdQuery {
 protected:
 	MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
 
-    VkPipelineStageFlagBits _pipelineStage;
+	VkPipelineStageFlags2 _stage;
 };
 
 

MoltenVK/MoltenVK/Commands/MVKCmdQueries.mm

@@ -77,13 +77,13 @@
 #pragma mark MVKCmdWriteTimestamp
 
 VkResult MVKCmdWriteTimestamp::setContent(MVKCommandBuffer* cmdBuff,
-										  VkPipelineStageFlagBits pipelineStage,
+										  VkPipelineStageFlags2 stage,
 										  VkQueryPool queryPool,
 										  uint32_t query) {
 
 	VkResult rslt = MVKCmdQuery::setContent(cmdBuff, queryPool, query);
 
-	_pipelineStage = pipelineStage;
+	_stage = stage;
 
 	cmdBuff->recordTimestampCommand();