Made some fixes for Deferred Operations

The changes are as follows:

* Moved the code around to fit with the ordering system
* Added a function to get available cpu cores
* Renamed variables with _ in front of them
* Added mutexes and lock guards for the getters and setters of the max concurrency and result variables
* Made max concurrency dynamic by returning 0 when the operation is finished

Common/MVKOSExtensions.h

@@ -164,3 +164,9 @@ uint64_t mvkGetUsedMemorySize();
 
 /** Returns the size of a page of host memory on this platform. */
 uint64_t mvkGetHostMemoryPageSize();
+
+#pragma mark -
+#pragma mark Threading
+
+/** Returns the amount of avaliable CPU cores. */
+uint32_t mvkGetAvaliableCPUCores();

Common/MVKOSExtensions.mm

@@ -138,3 +138,10 @@ uint64_t mvkGetUsedMemorySize() {
 
 uint64_t mvkGetHostMemoryPageSize() { return sysconf(_SC_PAGESIZE); }
 
+#pragma mark -
+#pragma mark Threading
+
+/** Returns the amount of avaliable CPU cores. */
+uint32_t mvkGetAvaliableCPUCores() {
+    return (uint32_t)[[NSProcessInfo processInfo] activeProcessorCount];
+}

MoltenVK/MoltenVK/GPUObjects/MVKDevice.h

@@ -50,8 +50,8 @@ class MVKSwapchain;
 class MVKDeviceMemory;
 class MVKFence;
 class MVKSemaphore;
-class MVKDeferredOperation;
 class MVKTimelineSemaphore;
+class MVKDeferredOperation;
 class MVKEvent;
 class MVKSemaphoreImpl;
 class MVKQueryPool;

MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm

@@ -3699,6 +3699,11 @@ MVKSemaphore* MVKDevice::createSemaphore(const VkSemaphoreCreateInfo* pCreateInf
 	}
 }
 
+void MVKDevice::destroySemaphore(MVKSemaphore* mvkSem4,
+								 const VkAllocationCallbacks* pAllocator) {
+	if (mvkSem4) { mvkSem4->destroy(); }
+}
+
 MVKDeferredOperation* MVKDevice::createDeferredOperation(const VkAllocationCallbacks* pAllocator) {
     return new MVKDeferredOperation(this);
 }
@@ -3708,11 +3713,6 @@ void MVKDevice::destroyDeferredOperation(MVKDeferredOperation* mvkDeferredOperat
     if(mvkDeferredOperation) { mvkDeferredOperation->destroy(); }
 }
 
-void MVKDevice::destroySemaphore(MVKSemaphore* mvkSem4,
-								 const VkAllocationCallbacks* pAllocator) {
-	if (mvkSem4) { mvkSem4->destroy(); }
-}
-
 MVKEvent* MVKDevice::createEvent(const VkEventCreateInfo* pCreateInfo,
 								 const VkAllocationCallbacks* pAllocator) {
 	const VkExportMetalObjectCreateInfoEXT* pExportInfo = nullptr;

MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm

@@ -718,6 +718,11 @@ void MVKInstance::initProcAddrs() {
 	ADD_DVC_1_3_PROMOTED_ENTRY_POINT(vkSetPrivateData, EXT, EXT_PRIVATE_DATA);
 
 	// Device extension functions.
+    ADD_DVC_EXT_ENTRY_POINT(vkCreateDeferredOperationKHR, KHR_DEFERRED_HOST_OPERATIONS);
+    ADD_DVC_EXT_ENTRY_POINT(vkDeferredOperationJoinKHR, KHR_DEFERRED_HOST_OPERATIONS);
+    ADD_DVC_EXT_ENTRY_POINT(vkDestroyDeferredOperationKHR, KHR_DEFERRED_HOST_OPERATIONS);
+    ADD_DVC_EXT_ENTRY_POINT(vkGetDeferredOperationMaxConcurrencyKHR, KHR_DEFERRED_HOST_OPERATIONS);
+    ADD_DVC_EXT_ENTRY_POINT(vkGetDeferredOperationResultKHR, KHR_DEFERRED_HOST_OPERATIONS);
 	ADD_DVC_EXT_ENTRY_POINT(vkMapMemory2KHR, KHR_MAP_MEMORY_2);
 	ADD_DVC_EXT_ENTRY_POINT(vkUnmapMemory2KHR, KHR_MAP_MEMORY_2);
 	ADD_DVC_EXT_ENTRY_POINT(vkCmdPushDescriptorSetKHR, KHR_PUSH_DESCRIPTOR);
@@ -731,11 +736,6 @@ void MVKInstance::initProcAddrs() {
 	ADD_DVC_EXT2_ENTRY_POINT(vkGetDeviceGroupSurfacePresentModesKHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
 	ADD_DVC_EXT2_ENTRY_POINT(vkGetPhysicalDevicePresentRectanglesKHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
 	ADD_DVC_EXT2_ENTRY_POINT(vkAcquireNextImage2KHR, KHR_SWAPCHAIN, KHR_DEVICE_GROUP);
-    ADD_DVC_EXT_ENTRY_POINT(vkCreateDeferredOperationKHR, KHR_DEFERRED_HOST_OPERATIONS);
-    ADD_DVC_EXT_ENTRY_POINT(vkDeferredOperationJoinKHR, KHR_DEFERRED_HOST_OPERATIONS);
-    ADD_DVC_EXT_ENTRY_POINT(vkDestroyDeferredOperationKHR, KHR_DEFERRED_HOST_OPERATIONS);
-    ADD_DVC_EXT_ENTRY_POINT(vkGetDeferredOperationMaxConcurrencyKHR, KHR_DEFERRED_HOST_OPERATIONS);
-    ADD_DVC_EXT_ENTRY_POINT(vkGetDeferredOperationResultKHR, KHR_DEFERRED_HOST_OPERATIONS);
 	ADD_DVC_EXT_ENTRY_POINT(vkDebugMarkerSetObjectTagEXT, EXT_DEBUG_MARKER);
 	ADD_DVC_EXT_ENTRY_POINT(vkDebugMarkerSetObjectNameEXT, EXT_DEBUG_MARKER);
 	ADD_DVC_EXT_ENTRY_POINT(vkCmdDebugMarkerBeginEXT, EXT_DEBUG_MARKER);

MoltenVK/MoltenVK/GPUObjects/MVKSync.h

@@ -665,27 +665,40 @@ public:
     VkResult join();
     
     /** Gets the max number of threads that can execute the deferred operation concurrently*/
-    uint32_t getMaxConcurrency() { return 1; } // Perhaps the number of CPU cores
+    uint32_t getMaxConcurrency() {
+        std::lock_guard<std::mutex> lock(_maxConcurrencyLock);
+        return _maxConcurrency;
+    }
     
     /** Gets the result of the execution of the deferred operation */
-    VkResult getResult() { return operationResult; }
+    VkResult getResult() {
+        std::lock_guard<std::mutex> lock(_resultLock);
+        return _operationResult;
+    }
     
     /** Sets all the variables needed for a deferred operation, however should never be called manually and only from other functions that take deferred operations*/
-    void deferOperation(MVKDeferredOperationFunctionPointer pointer, MVKDeferredOperationFunctionType type, std::vector<void*> parameters);
+    void deferOperation(MVKDeferredOperationFunctionPointer pointer, MVKDeferredOperationFunctionType type, std::vector<void*>&& parameters);
 #pragma mark Construction
     MVKDeferredOperation(MVKDevice* device) : MVKVulkanAPIDeviceObject(device) {}
 protected:
     /** Stores the result of the operation*/
-    VkResult operationResult = VK_SUCCESS;
+    VkResult _operationResult = VK_SUCCESS;
+    /** The mutex for the operation result being used to ensure thread safety. */
+    std::mutex _resultLock;
     
     /** Stores a pointer to the function*/
-    MVKDeferredOperationFunctionPointer functionPointer;
+    MVKDeferredOperationFunctionPointer _functionPointer;
     
     /** Stores what functions is being deferred*/
-    MVKDeferredOperationFunctionType functionType;
+    MVKDeferredOperationFunctionType _functionType;
     
     /** The parameters in the operation being deferred*/
-    std::vector<void*> functionParameters = {};
+    std::vector<void*> _functionParameters = {};
+    
+    /** Stores the max amount of threads that should be used.. */
+    uint32_t _maxConcurrency = 0;
+    /** The mutex for the max concurrency being used to ensure thread safety. */
+    std::mutex _maxConcurrencyLock;
     
     void propagateDebugName() override {}
 };

MoltenVK/MoltenVK/GPUObjects/MVKSync.mm

@@ -625,18 +625,30 @@ MVKMetalCompiler::~MVKMetalCompiler() {
 
 VkResult MVKDeferredOperation::join() {
     VkResult opResult;
-    switch(functionType)
+    switch(_functionType)
     {
         // Set operation result here by calling operation
         default: return VK_THREAD_DONE_KHR;
     };
-    operationResult = opResult;
+    
+    _resultLock.lock();
+    _operationResult = opResult;
+    _resultLock.unlock();
+    
+    _maxConcurrencyLock.lock();
+    _maxConcurrency = 0;
+    _maxConcurrencyLock.unlock();
+    
     return VK_SUCCESS;
 }
 
-void MVKDeferredOperation::deferOperation(MVKDeferredOperationFunctionPointer pointer, MVKDeferredOperationFunctionType type, std::vector<void*> parameters)
+void MVKDeferredOperation::deferOperation(MVKDeferredOperationFunctionPointer pointer, MVKDeferredOperationFunctionType type, std::vector<void*>&& parameters)
 {
-    functionPointer = pointer;
-    functionType = type;
-    functionParameters = parameters;
+    _functionPointer = pointer;
+    _functionType = type;
+    _functionParameters = parameters;
+    
+    _maxConcurrencyLock.lock();
+    _maxConcurrency = mvkGetAvaliableCPUCores();
+    _maxConcurrencyLock.unlock();
 }

MoltenVK/MoltenVK/Vulkan/vulkan.mm

@@ -2715,13 +2715,6 @@ MVK_PUBLIC_VULKAN_SYMBOL void vkDestroyDeferredOperationKHR(
     MVKTraceVulkanCallEnd();
 }
 
-#pragma mark -
-#pragma mark VK_KHR_dynamic_rendering extension
-
-MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdBeginRendering, KHR);
-MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdEndRendering, KHR);
-
-
 #pragma mark -
 #pragma mark VK_KHR_descriptor_update_template extension
 
@@ -2750,6 +2743,11 @@ MVK_PUBLIC_VULKAN_CORE_ALIAS(vkEnumeratePhysicalDeviceGroups, KHR);
 MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdDrawIndexedIndirectCount, KHR);
 MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdDrawIndirectCount, KHR);
 
+#pragma mark -
+#pragma mark VK_KHR_dynamic_rendering extension
+
+MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdBeginRendering, KHR);
+MVK_PUBLIC_VULKAN_CORE_ALIAS(vkCmdEndRendering, KHR);
 
 #pragma mark -
 #pragma mark VK_KHR_external_fence_capabilities extension