Merge pull request #2260 from billhollings/mtl3-arg-buff-support

Improvements to bindless resources and descriptor indexing

Docs/MoltenVK_Configuration_Parameters.md

@@ -616,22 +616,14 @@ cleared via a call to the `vkTrimCommandPoolKHR()` command.
 ---------------------------------------
 #### MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS
 
-##### Type: Enumeration
-- `0`: Don't use _Metal_ Argument Buffers.
-- `1`: Use _Metal_ Argument Buffers for all pipelines.
-- `2`: Use _Metal_ Argument Buffers only if the `VK_EXT_descriptor_indexing` extension is enabled.
-
-##### Default: `0`
+##### Type: Boolean
+##### Default: `1`
 
 Controls whether **MoltenVK** should use _Metal_ argument buffers for resources defined in descriptor sets,
 if _Metal_ argument buffers are supported on the platform. Using _Metal_ argument buffers dramatically
 increases the number of buffers, textures and samplers that can be bound to a pipeline shader, and in most
 cases improves performance.
 
-_**NOTE:**_ Currently, _Metal_ argument buffer support is in beta stage, and is only supported on _macOS 11.0+_,
-or on older versions of _macOS_ using an _Intel_ GPU. _Metal_ argument buffers support is not available on _iOS_ or _tvOS_.
-Development to support _iOS_ and _tvOS_ and a wider combination of GPU's on older _macOS_ versions is under way.
-
 
 ---------------------------------------
 #### MVK_CONFIG_USE_MTLHEAP

Docs/Whats_New.md

@@ -18,10 +18,19 @@ MoltenVK 1.2.10
 
 Released TBD
 
+- Improvements to bindless resources and descriptor indexing:
+  - Add support for Metal3 argument buffers.
+  - Support argument buffers on all platforms, when Metal 3 is available.
+  - Support argument buffers on macOS when Metal3 is not available.
+  - Use Metal argument buffers by default when they are available.
+  - Revert MVKConfiguration::useMetalArgumentBuffers and env var 
+    `MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS` to a boolean value, and enable it by default.
+  - Update max number of bindless buffers and textures per stage to 1M, per Apple Docs.
 - Add option to generate a GPU capture via a temporary named pipe from an external process.
 - Fix shader conversion failure when using native texture atomics.
 - MSL shader conversion, only pass resource bindings that apply to current shader stage.
 - Update documentation for minimum runtime OS requirements to indicate _macOS 10.15_, _iOS 13_, or _tvOS 13_.
+- Update `MVK_PRIVATE_API_VERSION` to version `42`.
 - Update to latest SPIRV-Cross:
   - MSL: Add option to force depth write in fragment shaders
   - MSL: Improve handling of padded descriptors with argument buffers

ExternalRevisions/SPIRV-Cross_repo_revision

@@ -1 +1 @@
-d47a140735cb44e511d0188a6318c365789e4699
+6fd1f75636b1c424b809ad8a84804654cf5ae48b

MoltenVK/MoltenVK/API/mvk_config.h

@@ -32,7 +32,7 @@ extern "C" {
 /**
  * This header is obsolete and deprecated, and is provided for legacy compatibility only.
  *
- * To configure MoltenVK, use one of the following mechanisms, 
+ * To configure MoltenVK, use one of the following mechanisms,
  * as documented in MoltenVK_Configuration_Parameters.md:
  *
  *   - The standard Vulkan VK_EXT_layer_settings extension (layer name "MoltenVK").

MoltenVK/MoltenVK/API/mvk_private_api.h

@@ -44,7 +44,7 @@ typedef unsigned long MTLArgumentBuffersTier;
  */
 
 
-#define MVK_PRIVATE_API_VERSION   41
+#define MVK_PRIVATE_API_VERSION   42
 
 
 #pragma mark -
@@ -140,14 +140,6 @@ typedef enum MVKConfigAdvertiseExtensionBits {
 } MVKConfigAdvertiseExtensionBits;
 typedef VkFlags MVKConfigAdvertiseExtensions;
 
-/** Identifies the use of Metal Argument Buffers. */
-typedef enum MVKUseMetalArgumentBuffers {
-	MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS_NEVER               = 0,	/**< Don't use Metal Argument Buffers. */
-	MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS_ALWAYS              = 1,	/**< Use Metal Argument Buffers for all pipelines. */
-	MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS_DESCRIPTOR_INDEXING = 2,	/**< Use Metal Argument Buffers only if VK_EXT_descriptor_indexing extension is enabled. */
-	MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS_MAX_ENUM            = 0x7FFFFFFF
-} MVKUseMetalArgumentBuffers;
-
 /** Identifies the Metal functionality used to support Vulkan semaphore functionality (VkSemaphore). */
 typedef enum MVKVkSemaphoreSupportStyle {
 	MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_SINGLE_QUEUE            = 0,	/**< Limit Vulkan to a single queue, with no explicit semaphore synchronization, and use Metal's implicit guarantees that all operations submitted to a queue will give the same result as if they had been run in submission order. */
@@ -240,7 +232,7 @@ typedef struct {
 	uint32_t apiVersionToAdvertise;                                            /**< MVK_CONFIG_API_VERSION_TO_ADVERTISE */
 	MVKConfigAdvertiseExtensions advertiseExtensions;                          /**< MVK_CONFIG_ADVERTISE_EXTENSIONS */
 	VkBool32 resumeLostDevice;                                                 /**< MVK_CONFIG_RESUME_LOST_DEVICE */
-	MVKUseMetalArgumentBuffers useMetalArgumentBuffers;                        /**< MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS */
+	VkBool32 useMetalArgumentBuffers;                                          /**< MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS */
 	MVKConfigCompressionAlgorithm shaderSourceCompressionAlgorithm;            /**< MVK_CONFIG_SHADER_COMPRESSION_ALGORITHM */
 	VkBool32 shouldMaximizeConcurrentCompilation;                              /**< MVK_CONFIG_SHOULD_MAXIMIZE_CONCURRENT_COMPILATION */
 	float timestampPeriodLowPassAlpha;                                         /**< MVK_CONFIG_TIMESTAMP_PERIOD_LOWPASS_ALPHA */
@@ -352,8 +344,8 @@ typedef struct {
     uint32_t minSubgroupSize;			        	/**< The minimum number of threads in a SIMD-group. */
     VkBool32 textureBarriers;                   	/**< If true, texture barriers are supported within Metal render passes. Deprecated. Will always be false on all platforms. */
     VkBool32 tileBasedDeferredRendering;        	/**< If true, this device uses tile-based deferred rendering. */
-	VkBool32 argumentBuffers;						/**< If true, Metal argument buffers are supported. */
-	VkBool32 descriptorSetArgumentBuffers;			/**< If true, a Metal argument buffer can be assigned to a descriptor set, and used on any pipeline and pipeline stage. If false, a different Metal argument buffer must be used for each pipeline-stage/descriptor-set combination. */
+	VkBool32 argumentBuffers;						/**< If true, Metal argument buffers are supported on the platform. */
+	VkBool32 descriptorSetArgumentBuffers;			/**< If true, Metal argument buffers can be used for descriptor sets. */
 	MVKFloatRounding clearColorFloatRounding;		/**< Identifies the type of rounding Metal uses for MTLClearColor float to integer conversions. */
 	MVKCounterSamplingFlags counterSamplingPoints;	/**< Identifies the points where pipeline GPU counter sampling may occur. */
 	VkBool32 programmableSamplePositions;			/**< If true, programmable MSAA sample positions are supported. */
@@ -364,6 +356,7 @@ typedef struct {
 	VkBool32 dynamicVertexStride;					/**< If true, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE is supported. */
 	VkBool32 needsCubeGradWorkaround;				/**< If true, sampling from cube textures with explicit gradients is broken and needs a workaround. */
 	VkBool32 nativeTextureAtomics;                  /**< If true, atomic operations on textures are supported natively. */
+	VkBool32 needsArgumentBufferEncoders;			/**< If true, Metal argument buffer encoders are needed to populate argument buffer content. */
 } MVKPhysicalDeviceMetalFeatures;
 
 

MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm

@@ -651,7 +651,7 @@ - (void)setDepthBoundsTestAMD:(BOOL)enable minDepth:(float)minDepth maxDepth:(fl
 
 	_boundDescriptorSets[descSetIndex] = descSet;
 
-	if (descSet->isUsingMetalArgumentBuffers()) {
+	if (descSet->hasMetalArgumentBuffer()) {
 		// If the descriptor set has changed, track new resource usage.
 		if (dsChanged) {
 			auto& usageDirty = _metalUsageDirtyDescriptors[descSetIndex];
@@ -671,46 +671,22 @@ - (void)setDepthBoundsTestAMD:(BOOL)enable minDepth:(float)minDepth maxDepth:(fl
 	}
 }
 
-// Encode the dirty descriptors to the Metal argument buffer, set the Metal command encoder
-// usage for each resource, and bind the Metal argument buffer to the command encoder.
+// Encode the Metal command encoder usage for each resource,
+// and bind the Metal argument buffer to the command encoder.
 void MVKResourcesCommandEncoderState::encodeMetalArgumentBuffer(MVKShaderStage stage) {
 	if ( !_cmdEncoder->isUsingMetalArgumentBuffers() ) { return; }
 
-	bool useDescSetArgBuff = _cmdEncoder->isUsingDescriptorSetMetalArgumentBuffers();
-
 	MVKPipeline* pipeline = getPipeline();
 	uint32_t dsCnt = pipeline->getDescriptorSetCount();
 	for (uint32_t dsIdx = 0; dsIdx < dsCnt; dsIdx++) {
 		auto* descSet = _boundDescriptorSets[dsIdx];
-		if ( !descSet ) { continue; }
+		if ( !(descSet && descSet->hasMetalArgumentBuffer()) ) { continue; }
 
 		auto* dsLayout = descSet->getLayout();
-
-		// The Metal arg encoder can only write to one arg buffer at a time (it holds the arg buffer),
-		// so we need to lock out other access to it while we are writing to it.
-		auto& mvkArgEnc = useDescSetArgBuff ? dsLayout->getMTLArgumentEncoder() : pipeline->getMTLArgumentEncoder(dsIdx, stage);
-		lock_guard<mutex> lock(mvkArgEnc.mtlArgumentEncodingLock);
-
-		id<MTLBuffer> mtlArgBuffer = nil;
-		NSUInteger metalArgBufferOffset = 0;
-		id<MTLArgumentEncoder> mtlArgEncoder = mvkArgEnc.getMTLArgumentEncoder();
-		if (useDescSetArgBuff) {
-			mtlArgBuffer = descSet->getMetalArgumentBuffer();
-			metalArgBufferOffset = descSet->getMetalArgumentBufferOffset();
-		} else {
-			// TODO: Source a different arg buffer & offset for each pipeline-stage/desccriptors set
-			// Also need to only encode the descriptors that are referenced in the shader.
-			// MVKMTLArgumentEncoder could include an MVKBitArray to track that and have it checked below.
-		}
-
-		if ( !(mtlArgEncoder && mtlArgBuffer) ) { continue; }
-
-		auto& argBuffDirtyDescs = descSet->getMetalArgumentBufferDirtyDescriptors();
 		auto& resourceUsageDirtyDescs = _metalUsageDirtyDescriptors[dsIdx];
 		auto& shaderBindingUsage = pipeline->getDescriptorBindingUse(dsIdx, stage);
-
-		bool mtlArgEncAttached = false;
 		bool shouldBindArgBuffToStage = false;
+
 		uint32_t dslBindCnt = dsLayout->getBindingCount();
 		for (uint32_t dslBindIdx = 0; dslBindIdx < dslBindCnt; dslBindIdx++) {
 			auto* dslBind = dsLayout->getBindingAt(dslBindIdx);
@@ -719,32 +695,22 @@ - (void)setDepthBoundsTestAMD:(BOOL)enable minDepth:(float)minDepth maxDepth:(fl
 				uint32_t elemCnt = dslBind->getDescriptorCount(descSet);
 				for (uint32_t elemIdx = 0; elemIdx < elemCnt; elemIdx++) {
 					uint32_t descIdx = dslBind->getDescriptorIndex(elemIdx);
-					bool argBuffDirty = argBuffDirtyDescs.getBit(descIdx, true);
-					bool resourceUsageDirty = resourceUsageDirtyDescs.getBit(descIdx, true);
-					if (argBuffDirty || resourceUsageDirty) {
-						// Don't attach the arg buffer to the arg encoder unless something actually needs
-						// to be written to it. We often might only be updating command encoder resource usage.
-						if (!mtlArgEncAttached && argBuffDirty) {
-							[mtlArgEncoder setArgumentBuffer: mtlArgBuffer offset: metalArgBufferOffset];
-							mtlArgEncAttached = true;
-						}
+					if (resourceUsageDirtyDescs.getBit(descIdx, true)) {
 						auto* mvkDesc = descSet->getDescriptorAt(descIdx);
-						mvkDesc->encodeToMetalArgumentBuffer(this, mtlArgEncoder,
-															 dsIdx, dslBind, elemIdx,
-															 stage, argBuffDirty, true);
+						mvkDesc->encodeResourceUsage(this, dslBind, stage);
 					}
 				}
 			}
 		}
+		descSet->encodeAuxBufferUsage(this, stage);
 
-		// If the arg buffer was attached to the arg encoder, detach it now.
-		if (mtlArgEncAttached) { [mtlArgEncoder setArgumentBuffer: nil offset: 0]; }
 
 		// If it is needed, bind the Metal argument buffer itself to the command encoder,
 		if (shouldBindArgBuffToStage) {
+			auto& mvkArgBuff = descSet->getMetalArgumentBuffer();
 			MVKMTLBufferBinding bb;
-			bb.mtlBuffer = descSet->getMetalArgumentBuffer();
-			bb.offset = descSet->getMetalArgumentBufferOffset();
+			bb.mtlBuffer = mvkArgBuff.getMetalArgumentBuffer();
+			bb.offset = mvkArgBuff.getMetalArgumentBufferOffset();
 			bb.index = dsIdx;
 			bindMetalArgumentBuffer(stage, bb);
 		}
@@ -753,7 +719,7 @@ - (void)setDepthBoundsTestAMD:(BOOL)enable minDepth:(float)minDepth maxDepth:(fl
 		// the contents of Metal argument buffers. Triggering an extraction of the arg buffer
 		// contents here, after filling it, seems to correct that.
 		// Sigh. A bug report has been filed with Apple.
-		if (getDevice()->isCurrentlyAutoGPUCapturing()) { [descSet->getMetalArgumentBuffer() contents]; }
+		if (getDevice()->isCurrentlyAutoGPUCapturing()) { [descSet->getMetalArgumentBuffer().getMetalArgumentBuffer() contents]; }
 	}
 }
 

MoltenVK/MoltenVK/Commands/MVKMTLBufferAllocation.h

@@ -45,7 +45,7 @@ class MVKMTLBufferAllocation : public MVKBaseObject, public MVKLinkableMixin<MVK
      * Returns a pointer to the begining of this allocation memory, taking into
      * consideration this allocation's offset into the underlying MTLBuffer.
      */
-    inline void* getContents() const { return (void*)((uintptr_t)_mtlBuffer.contents + _offset); }
+    void* getContents() const { return (void*)((uintptr_t)_mtlBuffer.contents + _offset); }
 
     /** Returns the pool whence this object was created. */
     MVKMTLBufferAllocationPool* getPool() const { return _pool; }