diff options
| -rw-r--r-- | layers/swapchain.cpp | 180 |
1 files changed, 66 insertions, 114 deletions
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp index c01a731e..9aca384a 100644 --- a/layers/swapchain.cpp +++ b/layers/swapchain.cpp @@ -26,6 +26,7 @@ * Author: Ian Elliott <ianelliott@google.com> */ +#include <mutex> #include <stdio.h> #include <string.h> #include <vk_loader_platform.h> @@ -35,8 +36,7 @@ #include "vk_enum_string_helper.h" #include "vk_layer_utils.h" -static int globalLockInitialized = 0; -static loader_platform_thread_mutex globalLock; +static std::mutex global_lock; // The following is for logging error messages: static std::unordered_map<void *, layer_data *> layer_data_map; @@ -234,11 +234,6 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreate static void init_swapchain(layer_data *my_data, const VkAllocationCallbacks *pAllocator) { layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_swapchain"); - - if (!globalLockInitialized) { - loader_platform_thread_create_mutex(&globalLock); - globalLockInitialized = 1; - } } static const char *surfaceTransformStr(VkSurfaceTransformFlagBitsKHR value) { @@ -302,7 +297,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance // Call down the call chain: my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator); - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); // Do additional internal cleanup: if (pInstance) { @@ -351,14 +346,6 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance delete my_data->instance_dispatch_table; layer_data_map.erase(key); - if (layer_data_map.empty()) { - // Release mutex when destroying last instance - loader_platform_thread_unlock_mutex(&globalLock); - loader_platform_thread_delete_mutex(&globalLock); - globalLockInitialized = 0; - } else { - loader_platform_thread_unlock_mutex(&globalLock); - } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL @@ -371,13 +358,12 @@ vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32 pQueueFamilyProperties); // Record the result of this query: - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; if (pPhysicalDevice && pQueueFamilyPropertyCount && !pQueueFamilyProperties) { pPhysicalDevice->gotQueueFamilyPropertyCount = true; pPhysicalDevice->numOfQueueFamilies = *pQueueFamilyPropertyCount; } - loader_platform_thread_unlock_mutex(&globalLock); } #ifdef VK_USE_PLATFORM_ANDROID_KHR @@ -387,7 +373,7 @@ vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoK VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -411,9 +397,9 @@ vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoK if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -427,10 +413,8 @@ vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoK // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } #endif // VK_USE_PLATFORM_ANDROID_KHR @@ -442,7 +426,7 @@ vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCre VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -466,9 +450,9 @@ vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCre if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -482,10 +466,8 @@ vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCre // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -495,7 +477,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentatio VkBool32 result = VK_FALSE; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the platform extension was enabled: @@ -510,7 +492,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentatio LOG_ERROR_QUEUE_FAMILY_INDEX_TOO_LARGE(VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, pPhysicalDevice, "VkPhysicalDevice", queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -528,7 +510,7 @@ vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoK VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -552,9 +534,9 @@ vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoK if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -568,10 +550,8 @@ vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoK // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -581,7 +561,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresent VkBool32 result = VK_FALSE; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the platform extension was enabled: @@ -596,7 +576,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresent LOG_ERROR_QUEUE_FAMILY_INDEX_TOO_LARGE(VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, pPhysicalDevice, "VkPhysicalDevice", queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -614,7 +594,7 @@ vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR * VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -638,9 +618,9 @@ vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR * if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -654,10 +634,8 @@ vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR * // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -666,7 +644,7 @@ vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, VkBool32 result = VK_FALSE; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the platform extension was enabled: @@ -681,7 +659,7 @@ vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, LOG_ERROR_QUEUE_FAMILY_INDEX_TOO_LARGE(VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, pPhysicalDevice, "VkPhysicalDevice", queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -698,7 +676,7 @@ vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCre VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -722,9 +700,9 @@ vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCre if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -738,10 +716,8 @@ vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCre // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -751,7 +727,7 @@ vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, ui VkBool32 result = VK_FALSE; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the platform extension was enabled: @@ -766,7 +742,7 @@ vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, ui LOG_ERROR_QUEUE_FAMILY_INDEX_TOO_LARGE(VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, pPhysicalDevice, "VkPhysicalDevice", queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -784,7 +760,7 @@ vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pC VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); // Validate that the platform extension was enabled: @@ -808,9 +784,9 @@ vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pC if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pInstance = &(my_data->instanceMap[instance]); @@ -824,10 +800,8 @@ vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pC // Point to the associated SwpInstance: pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface]; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -837,7 +811,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentati VkBool32 result = VK_FALSE; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the platform extension was enabled: @@ -852,7 +826,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentati LOG_ERROR_QUEUE_FAMILY_INDEX_TOO_LARGE(VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, pPhysicalDevice, "VkPhysicalDevice", queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -867,7 +841,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpSurface *pSurface = &my_data->surfaceMap[surface]; // Regardless of skipCall value, do some internal cleanup: @@ -903,7 +877,7 @@ vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocatio } my_data->surfaceMap.erase(surface); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -919,7 +893,7 @@ vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, // Call down the call chain: result = my_data->instance_dispatch_table->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); SwpInstance *pInstance = &(my_data->instanceMap[instance]); if ((result == VK_SUCCESS) && pInstance && pPhysicalDevices && (*pPhysicalDeviceCount > 0)) { // Record the VkPhysicalDevices returned by the ICD: @@ -939,7 +913,6 @@ vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } @@ -964,7 +937,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice p return result; } - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); @@ -974,7 +947,6 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice p my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice); createDeviceRegisterExtensions(physicalDevice, pCreateInfo, *pDevice); - loader_platform_thread_unlock_mutex(&globalLock); return result; } @@ -987,7 +959,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons my_data->device_dispatch_table->DestroyDevice(device, pAllocator); // Do some internal cleanup: - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); SwpDevice *pDevice = &my_data->deviceMap[device]; if (pDevice) { // Delete the SwpDevice associated with this device: @@ -1017,7 +989,6 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons } delete my_data->device_dispatch_table; layer_data_map.erase(key); - loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, @@ -1026,7 +997,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupport VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the surface extension was enabled: @@ -1053,10 +1024,10 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupport if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; @@ -1080,10 +1051,8 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupport } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1093,7 +1062,7 @@ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSur VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the surface extension was enabled: @@ -1109,10 +1078,10 @@ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSur if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; @@ -1122,10 +1091,8 @@ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSur // FIXME: NEED TO COPY THIS DATA, BECAUSE pSurfaceCapabilities POINTS TO APP-ALLOCATED DATA pPhysicalDevice->surfaceCapabilities = *pSurfaceCapabilities; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1135,7 +1102,7 @@ vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceK VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the surface extension was enabled: @@ -1151,10 +1118,10 @@ vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceK if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; @@ -1180,10 +1147,8 @@ vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceK } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1193,7 +1158,7 @@ vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSur VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpPhysicalDevice *pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; // Validate that the surface extension was enabled: @@ -1209,10 +1174,10 @@ vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSur if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->instance_dispatch_table->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pPhysicalDevice = &my_data->physicalDeviceMap[physicalDevice]; @@ -1238,10 +1203,8 @@ vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSur } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1571,14 +1534,14 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice dev VkSwapchainKHR *pSwapchain) { VkResult result = VK_SUCCESS; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); bool skipCall = validateCreateSwapchainKHR(device, pCreateInfo, pSwapchain); if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->device_dispatch_table->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); if (result == VK_SUCCESS) { // Remember the swapchain's handle, and link it to the device: @@ -1602,10 +1565,8 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice dev pSurface->swapchains[*pSwapchain] = &my_data->swapchainMap[*pSwapchain]; } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1618,7 +1579,7 @@ vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocat // execution bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpDevice *pDevice = &my_data->deviceMap[device]; // Validate that the swapchain extension was enabled: @@ -1655,7 +1616,7 @@ vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocat } my_data->swapchainMap.erase(swapchain); } - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); if (!skipCall) { // Call down the call chain: @@ -1668,7 +1629,7 @@ vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSw VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpDevice *pDevice = &my_data->deviceMap[device]; // Validate that the swapchain extension was enabled: @@ -1684,9 +1645,9 @@ vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSw if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->device_dispatch_table->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pSwapchain = &my_data->swapchainMap[swapchain]; @@ -1709,10 +1670,8 @@ vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSw } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1733,7 +1692,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice de VkResult result = VK_SUCCESS; bool skipCall = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); SwpDevice *pDevice = &my_data->deviceMap[device]; // Validate that the swapchain extension was enabled: @@ -1783,9 +1742,9 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice de if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->device_dispatch_table->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); // Obtain this pointer again after locking: pSwapchain = &my_data->swapchainMap[swapchain]; @@ -1793,10 +1752,8 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice de // Change the state of the image (now acquired by the application): pSwapchain->images[*pImageIndex].acquiredByApp = true; } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1835,7 +1792,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, // Note: pPresentInfo->pResults is allowed to be NULL } - loader_platform_thread_lock_mutex(&globalLock); + std::unique_lock<std::mutex> lock(global_lock); for (uint32_t i = 0; pPresentInfo && (i < pPresentInfo->swapchainCount); i++) { uint32_t index = pPresentInfo->pImageIndices[i]; SwpSwapchain *pSwapchain = &my_data->swapchainMap[pPresentInfo->pSwapchains[i]]; @@ -1884,9 +1841,9 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, if (!skipCall) { // Call down the call chain: - loader_platform_thread_unlock_mutex(&globalLock); + lock.unlock(); result = my_data->device_dispatch_table->QueuePresentKHR(queue, pPresentInfo); - loader_platform_thread_lock_mutex(&globalLock); + lock.lock(); if (pPresentInfo && ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) { for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) { @@ -1899,10 +1856,8 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, } } } - loader_platform_thread_unlock_mutex(&globalLock); return result; } - loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -1916,7 +1871,7 @@ vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex my_data->device_dispatch_table->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); // Remember the queue's handle, and link it to the device: - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); SwpDevice *pDevice = &my_data->deviceMap[device]; my_data->queueMap[&pQueue].queue = *pQueue; if (pDevice) { @@ -1924,7 +1879,6 @@ vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex } my_data->queueMap[&pQueue].pDevice = pDevice; my_data->queueMap[&pQueue].queueFamilyIndex = queueFamilyIndex; - loader_platform_thread_unlock_mutex(&globalLock); } } @@ -1935,9 +1889,8 @@ vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackC VkResult result = my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); if (VK_SUCCESS == result) { - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); result = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback); - loader_platform_thread_unlock_mutex(&globalLock); } return result; } @@ -1947,9 +1900,8 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkIns const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - loader_platform_thread_lock_mutex(&globalLock); + std::lock_guard<std::mutex> lock(global_lock); layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator); - loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL |