diff --git a/layers/object_tracker.h b/layers/object_tracker.h
index 664bf61..2e61a15 100644
--- a/layers/object_tracker.h
+++ b/layers/object_tracker.h
@@ -27,6 +27,8 @@
  * Author: Tobin Ehlis <tobin@lunarg.com>
  */
 
+#include <mutex>
+
 #include "vulkan/vk_layer.h"
 #include "vk_layer_extension_utils.h"
 #include "vk_enum_string_helper.h"
@@ -99,8 +101,7 @@
 static unordered_map<uint64_t, OBJTRACK_NODE *> swapchainImageMap;
 
 static long long unsigned int object_track_index = 0;
-static int objLockInitialized = 0;
-static loader_platform_thread_mutex objLock;
+static std::mutex global_lock;
 
 // Objects stored in a global map w/ struct containing basic info
 // unordered_map<const void*, OBJTRACK_NODE*> objMap;
@@ -330,16 +331,6 @@
 static void init_object_tracker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
 
     layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_object_tracker");
-
-    if (!objLockInitialized) {
-        // TODO/TBD: Need to delete this mutex sometime.  How???  One
-        // suggestion is to call this during vkCreateInstance(), and then we
-        // can clean it up during vkDestroyInstance().  However, that requires
-        // that the layer have per-instance locks.  We need to come back and
-        // address this soon.
-        loader_platform_thread_create_mutex(&objLock);
-        objLockInitialized = 1;
-    }
 }
 
 //
@@ -647,15 +638,15 @@
 void explicit_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice gpu, uint32_t *pCount, VkQueueFamilyProperties *pProperties) {
     get_dispatch_table(object_tracker_instance_table_map, gpu)->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
 
-    loader_platform_thread_lock_mutex(&objLock);
-    if (pProperties != NULL)
+    std::lock_guard<std::mutex> lock(global_lock);
+    if (pProperties != NULL) {
         setGpuQueueInfoState(*pCount, pProperties);
-    loader_platform_thread_unlock_mutex(&objLock);
+    }
 }
 
 VkResult explicit_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
                                VkDevice *pDevice) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::lock_guard<std::mutex> lock(global_lock);
     VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
@@ -663,7 +654,6 @@
     PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
     PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
     if (fpCreateDevice == NULL) {
-        loader_platform_thread_unlock_mutex(&objLock);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -672,7 +662,6 @@
 
     VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result != VK_SUCCESS) {
-        loader_platform_thread_unlock_mutex(&objLock);
         return result;
     }
 
@@ -689,21 +678,20 @@
         create_device((VkInstance)pNewObjNode->belongsTo, *pDevice, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT);
     }
 
-    loader_platform_thread_unlock_mutex(&objLock);
     return result;
 }
 
 VkResult explicit_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
                                            VkPhysicalDevice *pPhysicalDevices) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_instance(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
     VkResult result = get_dispatch_table(object_tracker_instance_table_map, instance)
                           ->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     if (result == VK_SUCCESS) {
         if (pPhysicalDevices) {
             for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
@@ -711,30 +699,29 @@
             }
         }
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     return result;
 }
 
 void explicit_GetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue *pQueue) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     get_dispatch_table(object_tracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
 
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     addQueueInfo(queueNodeIndex, *pQueue);
     create_queue(device, *pQueue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT);
-    loader_platform_thread_unlock_mutex(&objLock);
 }
 
 VkResult explicit_MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags,
                             void **ppData) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= set_device_memory_status(device, mem, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, OBJSTATUS_GPU_MEM_MAPPED);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall == VK_TRUE)
         return VK_ERROR_VALIDATION_FAILED_EXT;
 
@@ -746,10 +733,10 @@
 
 void explicit_UnmapMemory(VkDevice device, VkDeviceMemory mem) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= reset_device_memory_status(device, mem, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, OBJSTATUS_GPU_MEM_MAPPED);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall == VK_TRUE)
         return;
 
@@ -757,7 +744,7 @@
 }
 
 VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     validateQueueFlags(queue, "QueueBindSparse");
 
     for (uint32_t i = 0; i < bindInfoCount; i++) {
@@ -768,8 +755,7 @@
         for (uint32_t j = 0; j < pBindInfo[i].imageBindCount; j++)
             validate_image(queue, pBindInfo[i].pImageBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false);
     }
-
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     VkResult result =
         get_dispatch_table(object_tracker_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
@@ -779,10 +765,10 @@
 VkResult explicit_AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
                                          VkCommandBuffer *pCommandBuffers) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     skipCall |= validate_command_pool(device, pAllocateInfo->commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     if (skipCall) {
         return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -791,12 +777,12 @@
     VkResult result =
         get_dispatch_table(object_tracker_device_table_map, device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
 
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
         alloc_command_buffer(device, pAllocateInfo->commandPool, pCommandBuffers[i], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                              pAllocateInfo->level);
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     return result;
 }
@@ -804,7 +790,7 @@
 VkResult explicit_AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
                                          VkDescriptorSet *pDescriptorSets) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     skipCall |=
         validate_descriptor_pool(device, pAllocateInfo->descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false);
@@ -812,7 +798,7 @@
         skipCall |= validate_descriptor_set_layout(device, pAllocateInfo->pSetLayouts[i],
                                                    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, false);
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
 
@@ -820,12 +806,12 @@
         get_dispatch_table(object_tracker_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 
     if (VK_SUCCESS == result) {
-        loader_platform_thread_lock_mutex(&objLock);
+        lock.lock();
         for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
             alloc_descriptor_set(device, pAllocateInfo->descriptorPool, pDescriptorSets[i],
                                  VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT);
         }
-        loader_platform_thread_unlock_mutex(&objLock);
+        lock.unlock();
     }
 
     return result;
@@ -833,24 +819,23 @@
 
 void explicit_FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
                                  const VkCommandBuffer *pCommandBuffers) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     validate_command_pool(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false);
     validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     get_dispatch_table(object_tracker_device_table_map, device)
         ->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     for (uint32_t i = 0; i < commandBufferCount; i++) {
         free_command_buffer(device, commandPool, *pCommandBuffers);
         pCommandBuffers++;
     }
-    loader_platform_thread_unlock_mutex(&objLock);
 }
 
 void explicit_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     // A swapchain's images are implicitly deleted when the swapchain is deleted.
     // Remove this swapchain's images from our map of such images.
     unordered_map<uint64_t, OBJTRACK_NODE *>::iterator itr = swapchainImageMap.begin();
@@ -863,52 +848,51 @@
         }
     }
     destroy_swapchain_khr(device, swapchain);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     get_dispatch_table(object_tracker_device_table_map, device)->DestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
 void explicit_FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAllocator) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
 
     get_dispatch_table(object_tracker_device_table_map, device)->FreeMemory(device, mem, pAllocator);
 
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     destroy_device_memory(device, mem);
-    loader_platform_thread_unlock_mutex(&objLock);
 }
 
 VkResult explicit_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count,
                                      const VkDescriptorSet *pDescriptorSets) {
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     validate_descriptor_pool(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false);
     validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     VkResult result = get_dispatch_table(object_tracker_device_table_map, device)
                           ->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
 
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     for (uint32_t i = 0; i < count; i++) {
         free_descriptor_set(device, descriptorPool, *pDescriptorSets++);
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     return result;
 }
 
 void explicit_DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     skipCall |= validate_descriptor_pool(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall) {
         return;
     }
     // A DescriptorPool's descriptor sets are implicitly deleted when the pool is deleted.
     // Remove this pool's descriptor sets from our descriptorSet map.
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     unordered_map<uint64_t, OBJTRACK_NODE *>::iterator itr = VkDescriptorSetMap.begin();
     while (itr != VkDescriptorSetMap.end()) {
         OBJTRACK_NODE *pNode = (*itr).second;
@@ -918,20 +902,20 @@
         }
     }
     destroy_descriptor_pool(device, descriptorPool);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     get_dispatch_table(object_tracker_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
 void explicit_DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     skipCall |= validate_command_pool(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall) {
         return;
     }
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     // A CommandPool's command buffers are implicitly deleted when the pool is deleted.
     // Remove this pool's cmdBuffers from our cmd buffer map.
     unordered_map<uint64_t, OBJTRACK_NODE *>::iterator itr = VkCommandBufferMap.begin();
@@ -945,15 +929,15 @@
         }
     }
     destroy_command_pool(device, commandPool);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     get_dispatch_table(object_tracker_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator);
 }
 
 VkResult explicit_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, VkImage *pSwapchainImages) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
 
@@ -961,11 +945,11 @@
                           ->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
 
     if (pSwapchainImages != NULL) {
-        loader_platform_thread_lock_mutex(&objLock);
+        lock.lock();
         for (uint32_t i = 0; i < *pCount; i++) {
             create_swapchain_image_obj(device, pSwapchainImages[i], swapchain);
         }
-        loader_platform_thread_unlock_mutex(&objLock);
+        lock.unlock();
     }
     return result;
 }
@@ -975,7 +959,7 @@
                                           const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator,
                                           VkPipeline *pPipelines) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     if (pCreateInfos) {
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
@@ -1004,18 +988,18 @@
     if (pipelineCache) {
         skipCall |= validate_pipeline_cache(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false);
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
     VkResult result = get_dispatch_table(object_tracker_device_table_map, device)
                           ->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     if (result == VK_SUCCESS) {
         for (uint32_t idx2 = 0; idx2 < createInfoCount; ++idx2) {
             create_pipeline(device, pPipelines[idx2], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
         }
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     return result;
 }
 
@@ -1024,7 +1008,7 @@
                                          const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator,
                                          VkPipeline *pPipelines) {
     VkBool32 skipCall = VK_FALSE;
-    loader_platform_thread_lock_mutex(&objLock);
+    std::unique_lock<std::mutex> lock(global_lock);
     skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
     if (pCreateInfos) {
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
@@ -1045,17 +1029,17 @@
     if (pipelineCache) {
         skipCall |= validate_pipeline_cache(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false);
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
     VkResult result = get_dispatch_table(object_tracker_device_table_map, device)
                           ->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    loader_platform_thread_lock_mutex(&objLock);
+    lock.lock();
     if (result == VK_SUCCESS) {
         for (uint32_t idx1 = 0; idx1 < createInfoCount; ++idx1) {
             create_pipeline(device, pPipelines[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
         }
     }
-    loader_platform_thread_unlock_mutex(&objLock);
+    lock.unlock();
     return result;
 }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 0f32807..16654e1 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -962,7 +962,7 @@
         gedi_txt.append('VkInstance instance,')
         gedi_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedi_txt.append('{')
-        gedi_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
+        gedi_txt.append('    std::unique_lock<std::mutex> lock(global_lock);')
         gedi_txt.append('    validate_instance(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);')
         gedi_txt.append('')
         gedi_txt.append('    destroy_instance(instance, instance);')
@@ -1010,14 +1010,9 @@
         gedi_txt.append('    layer_data_map.erase(pInstanceTable);')
         gedi_txt.append('')
         gedi_txt.append('    instanceExtMap.erase(pInstanceTable);')
-        gedi_txt.append('    loader_platform_thread_unlock_mutex(&objLock);')
+        gedi_txt.append('    lock.unlock();')
         # The loader holds a mutex that protects this from other threads
         gedi_txt.append('    object_tracker_instance_table_map.erase(key);')
-        gedi_txt.append('    if (object_tracker_instance_table_map.empty()) {')
-        gedi_txt.append('        // Release mutex when destroying last instance.')
-        gedi_txt.append('        loader_platform_thread_delete_mutex(&objLock);')
-        gedi_txt.append('        objLockInitialized = 0;')
-        gedi_txt.append('    }')
         gedi_txt.append('}')
         gedi_txt.append('')
         return "\n".join(gedi_txt)
@@ -1029,7 +1024,7 @@
         gedd_txt.append('VkDevice device,')
         gedd_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedd_txt.append('{')
-        gedd_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
+        gedd_txt.append('    std::unique_lock<std::mutex> lock(global_lock);')
         gedd_txt.append('    validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);')
         gedd_txt.append('')
         gedd_txt.append('    destroy_device(device, device);')
@@ -1053,7 +1048,7 @@
         gedd_txt.append("    // Clean up Queue's MemRef Linked Lists")
         gedd_txt.append('    destroyQueueMemRefLists();')
         gedd_txt.append('')
-        gedd_txt.append('    loader_platform_thread_unlock_mutex(&objLock);')
+        gedd_txt.append('    lock.unlock();')
         gedd_txt.append('')
         gedd_txt.append('    dispatch_key key = get_dispatch_key(device);')
         gedd_txt.append('    VkLayerDispatchTable *pDisp = get_dispatch_table(object_tracker_device_table_map, device);')
@@ -1287,11 +1282,12 @@
                 typ = proto.params[-1].ty.strip('*').replace('const ', '');
                 name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', typ)
                 name = re.sub('([a-z0-9])([A-Z])', r'\1_\2', name).lower()[3:]
-                create_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
-                create_line += '    if (result == VK_SUCCESS) {\n'
-                create_line += '        create_%s(%s, *%s, %s);\n' % (name, param0_name, proto.params[-1].name, obj_type_mapping[typ])
+                create_line =  '    {\n'
+                create_line += '        std::lock_guard<std::mutex> lock(global_lock);\n'
+                create_line += '        if (result == VK_SUCCESS) {\n'
+                create_line += '            create_%s(%s, *%s, %s);\n' % (name, param0_name, proto.params[-1].name, obj_type_mapping[typ])
+                create_line += '        }\n'
                 create_line += '    }\n'
-                create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
             if 'FreeCommandBuffers' in proto.name:
                 typ = proto.params[-1].ty.strip('*').replace('const ', '');
                 name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', typ)
@@ -1307,19 +1303,23 @@
                 name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', typ)
                 name = re.sub('([a-z0-9])([A-Z])', r'\1_\2', name).lower()[3:]
                 funcs.append('%s\n' % self.lineinfo.get())
-                destroy_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
-                destroy_line += '    destroy_%s(%s, %s);\n' % (name, param0_name, proto.params[-2].name)
-                destroy_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
+                destroy_line =  '    {\n'
+                destroy_line += '        std::lock_guard<std::mutex> lock(global_lock);\n'
+                destroy_line += '        destroy_%s(%s, %s);\n' % (name, param0_name, proto.params[-2].name)
+                destroy_line += '    }\n'
             indent = '    '
             if len(struct_uses) > 0:
                 using_line += '%sVkBool32 skipCall = VK_FALSE;\n' % (indent)
                 if not mutex_unlock:
-                    using_line += '%sloader_platform_thread_lock_mutex(&objLock);\n' % (indent)
+                    using_line += '%s{\n' % (indent)
+                    indent += '    '
+                    using_line += '%sstd::lock_guard<std::mutex> lock(global_lock);\n' % (indent)
                     mutex_unlock = True
                 using_line += '// objects to validate: %s\n' % str(sorted(struct_uses))
-                using_line += self._gen_obj_validate_code(struct_uses, obj_type_mapping, proto.name, valid_null_object_names, param0_name, '    ', '', 0)
+                using_line += self._gen_obj_validate_code(struct_uses, obj_type_mapping, proto.name, valid_null_object_names, param0_name, indent, '', 0)
             if mutex_unlock:
-                using_line += '%sloader_platform_thread_unlock_mutex(&objLock);\n' % (indent)
+                indent = indent[4:]
+                using_line += '%s}\n' % (indent)
             if len(struct_uses) > 0:
                 using_line += '    if (skipCall)\n'
                 if proto.ret == "VkBool32":