layers/threading.h - third_party/vulkan_loader_and_validation_layers - Git at Google

 /* Copyright (c) 2015-2016 The Khronos Group Inc.
  * Copyright (c) 2015-2016 Valve Corporation
  * Copyright (c) 2015-2016 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Author: Cody Northrop <cody@lunarg.com>
  * Author: Mike Stroyan <mike@LunarG.com>
  */

 #ifndef THREADING_H
 #define THREADING_H
 #include <condition_variable>
 #include <mutex>
 #include <vector>
 #include "vk_layer_config.h"
 #include "vk_layer_logging.h"

 #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) ||       \
     defined(__aarch64__) || defined(__powerpc64__)
 // If pointers are 64-bit, then there can be separate counters for each
 // NONDISPATCHABLE_HANDLE type.  Otherwise they are all typedef uint64_t.
 #define DISTINCT_NONDISPATCHABLE_HANDLES
 #endif

 // Draw State ERROR codes
 enum THREADING_CHECKER_ERROR {
     THREADING_CHECKER_NONE,                // Used for INFO & other non-error messages
     THREADING_CHECKER_MULTIPLE_THREADS,    // Object used simultaneously by multiple threads
     THREADING_CHECKER_SINGLE_THREAD_REUSE, // Object used simultaneously by recursion in single thread
 };

 struct object_use_data {
     loader_platform_thread_id thread;
     int reader_count;
     int writer_count;
 };

 struct layer_data;

 namespace threading {
 volatile bool vulkan_in_use = false;
 volatile bool vulkan_multi_threaded = false;
 // starting check if an application is using vulkan from multiple threads.
 inline bool startMultiThread() {
     if (vulkan_multi_threaded) {
         return true;
     }
     if (vulkan_in_use) {
         vulkan_multi_threaded = true;
         return true;
     }
     vulkan_in_use = true;
     return false;
 }

 // finishing check if an application is using vulkan from multiple threads.
 inline void finishMultiThread() { vulkan_in_use = false; }
 } // namespace threading

 template <typename T> class counter {
   public:
     const char *typeName;
     VkDebugReportObjectTypeEXT objectType;
     std::unordered_map<T, object_use_data> uses;
     std::mutex counter_lock;
     std::condition_variable counter_condition;
     void startWrite(debug_report_data *report_data, T object) {
         bool skipCall = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
         std::unique_lock<std::mutex> lock(counter_lock);
         if (uses.find(object) == uses.end()) {
             // There is no current use of the object.  Record writer thread.
             struct object_use_data *use_data = &uses[object];
             use_data->reader_count = 0;
             use_data->writer_count = 1;
             use_data->thread = tid;
         } else {
             struct object_use_data *use_data = &uses[object];
             if (use_data->reader_count == 0) {
                 // There are no readers.  Two writers just collided.
                 if (use_data->thread != tid) {
                     skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
                                         0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                         "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
                                         typeName, use_data->thread, tid);
                     if (skipCall) {
                         // Wait for thread-safe access to object instead of skipping call.
                         while (uses.find(object) != uses.end()) {
                             counter_condition.wait(lock);
                         }
                         // There is now no current use of the object.  Record writer thread.
                         struct object_use_data *use_data = &uses[object];
                         use_data->thread = tid;
                         use_data->reader_count = 0;
                         use_data->writer_count = 1;
                     } else {
                         // Continue with an unsafe use of the object.
                         use_data->thread = tid;
                         use_data->writer_count += 1;
                     }
                 } else {
                     // This is either safe multiple use in one call, or recursive use.
                     // There is no way to make recursion safe.  Just forge ahead.
                     use_data->writer_count += 1;
                 }
             } else {
                 // There are readers.  This writer collided with them.
                 if (use_data->thread != tid) {
                     skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
                                         0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                         "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
                                         typeName, use_data->thread, tid);
                     if (skipCall) {
                         // Wait for thread-safe access to object instead of skipping call.
                         while (uses.find(object) != uses.end()) {
                             counter_condition.wait(lock);
                         }
                         // There is now no current use of the object.  Record writer thread.
                         struct object_use_data *use_data = &uses[object];
                         use_data->thread = tid;
                         use_data->reader_count = 0;
                         use_data->writer_count = 1;
                     } else {
                         // Continue with an unsafe use of the object.
                         use_data->thread = tid;
                         use_data->writer_count += 1;
                     }
                 } else {
                     // This is either safe multiple use in one call, or recursive use.
                     // There is no way to make recursion safe.  Just forge ahead.
                     use_data->writer_count += 1;
                 }
             }
         }
     }

     void finishWrite(T object) {
         // Object is no longer in use
         std::unique_lock<std::mutex> lock(counter_lock);
         uses[object].writer_count -= 1;
         if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
             uses.erase(object);
         }
         // Notify any waiting threads that this object may be safe to use
         lock.unlock();
         counter_condition.notify_all();
     }

     void startRead(debug_report_data *report_data, T object) {
         bool skipCall = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
         std::unique_lock<std::mutex> lock(counter_lock);
         if (uses.find(object) == uses.end()) {
             // There is no current use of the object.  Record reader count
             struct object_use_data *use_data = &uses[object];
             use_data->reader_count = 1;
             use_data->writer_count = 0;
             use_data->thread = tid;
         } else if (uses[object].writer_count > 0 && uses[object].thread != tid) {
             // There is a writer of the object.
             skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
                                 0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                 "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld", typeName,
                                 uses[object].thread, tid);
             if (skipCall) {
                 // Wait for thread-safe access to object instead of skipping call.
                 while (uses.find(object) != uses.end()) {
                     counter_condition.wait(lock);
                 }
                 // There is no current use of the object.  Record reader count
                 struct object_use_data *use_data = &uses[object];
                 use_data->reader_count = 1;
                 use_data->writer_count = 0;
                 use_data->thread = tid;
             } else {
                 uses[object].reader_count += 1;
             }
         } else {
             // There are other readers of the object.  Increase reader count
             uses[object].reader_count += 1;
         }
     }
     void finishRead(T object) {
         std::unique_lock<std::mutex> lock(counter_lock);
         uses[object].reader_count -= 1;
         if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
             uses.erase(object);
         }
         // Notify any waiting threads that this object may be safe to use
         lock.unlock();
         counter_condition.notify_all();
     }
     counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {
         typeName = name;
         objectType = type;
     }
 };

 struct layer_data {
     VkInstance instance;

     debug_report_data *report_data;
     std::vector<VkDebugReportCallbackEXT> logging_callback;
     VkLayerDispatchTable *device_dispatch_table;
     VkLayerInstanceDispatchTable *instance_dispatch_table;
     // The following are for keeping track of the temporary callbacks that can
     // be used in vkCreateInstance and vkDestroyInstance:
     uint32_t num_tmp_callbacks;
     VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos;
     VkDebugReportCallbackEXT *tmp_callbacks;
     counter<VkCommandBuffer> c_VkCommandBuffer;
     counter<VkDevice> c_VkDevice;
     counter<VkInstance> c_VkInstance;
     counter<VkQueue> c_VkQueue;
 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
     counter<VkBuffer> c_VkBuffer;
     counter<VkBufferView> c_VkBufferView;
     counter<VkCommandPool> c_VkCommandPool;
     counter<VkDescriptorPool> c_VkDescriptorPool;
     counter<VkDescriptorSet> c_VkDescriptorSet;
     counter<VkDescriptorSetLayout> c_VkDescriptorSetLayout;
     counter<VkDeviceMemory> c_VkDeviceMemory;
     counter<VkEvent> c_VkEvent;
     counter<VkFence> c_VkFence;
     counter<VkFramebuffer> c_VkFramebuffer;
     counter<VkImage> c_VkImage;
     counter<VkImageView> c_VkImageView;
     counter<VkPipeline> c_VkPipeline;
     counter<VkPipelineCache> c_VkPipelineCache;
     counter<VkPipelineLayout> c_VkPipelineLayout;
     counter<VkQueryPool> c_VkQueryPool;
     counter<VkRenderPass> c_VkRenderPass;
     counter<VkSampler> c_VkSampler;
     counter<VkSemaphore> c_VkSemaphore;
     counter<VkShaderModule> c_VkShaderModule;
     counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT;
     counter<VkObjectTableNVX> c_VkObjectTableNVX;
     counter<VkIndirectCommandsLayoutNVX>c_VkIndirectCommandsLayoutNVX;
 #else  // DISTINCT_NONDISPATCHABLE_HANDLES
     counter<uint64_t> c_uint64_t;
 #endif // DISTINCT_NONDISPATCHABLE_HANDLES

     layer_data()
         : report_data(nullptr), num_tmp_callbacks(0), tmp_dbg_create_infos(nullptr), tmp_callbacks(nullptr),
           c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT),
           c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT),
           c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT),
           c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT),
 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
           c_VkBuffer("VkBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT),
           c_VkBufferView("VkBufferView", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT),
           c_VkCommandPool("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT),
           c_VkDescriptorPool("VkDescriptorPool", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT),
           c_VkDescriptorSet("VkDescriptorSet", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT),
           c_VkDescriptorSetLayout("VkDescriptorSetLayout", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT),
           c_VkDeviceMemory("VkDeviceMemory", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT),
           c_VkEvent("VkEvent", VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT), c_VkFence("VkFence", VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT),
           c_VkFramebuffer("VkFramebuffer", VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT),
           c_VkImage("VkImage", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT),
           c_VkImageView("VkImageView", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT),
           c_VkPipeline("VkPipeline", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT),
           c_VkPipelineCache("VkPipelineCache", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT),
           c_VkPipelineLayout("VkPipelineLayout", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT),
           c_VkQueryPool("VkQueryPool", VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT),
           c_VkRenderPass("VkRenderPass", VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT),
           c_VkSampler("VkSampler", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT),
           c_VkSemaphore("VkSemaphore", VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT),
           c_VkShaderModule("VkShaderModule", VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT),
           c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT),
           c_VkObjectTableNVX("VkObjectTableNVX", VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT),
           c_VkIndirectCommandsLayoutNVX("VkIndirectCommandsLayoutNVX", VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT)
 #else  // DISTINCT_NONDISPATCHABLE_HANDLES
           c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT)
 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
               {};
 };

 #define WRAPPER(type)                                                                                                              \
     static void startWriteObject(struct layer_data *my_data, type object) {                                                        \
         my_data->c_##type.startWrite(my_data->report_data, object);                                                                \
     }                                                                                                                              \
     static void finishWriteObject(struct layer_data *my_data, type object) { my_data->c_##type.finishWrite(object); }              \
     static void startReadObject(struct layer_data *my_data, type object) {                                                         \
         my_data->c_##type.startRead(my_data->report_data, object);                                                                 \
     }                                                                                                                              \
     static void finishReadObject(struct layer_data *my_data, type object) { my_data->c_##type.finishRead(object); }

 WRAPPER(VkDevice)
 WRAPPER(VkInstance)
 WRAPPER(VkQueue)
 #ifdef DISTINCT_NONDISPATCHABLE_HANDLES
 WRAPPER(VkBuffer)
 WRAPPER(VkBufferView)
 WRAPPER(VkCommandPool)
 WRAPPER(VkDescriptorPool)
 WRAPPER(VkDescriptorSet)
 WRAPPER(VkDescriptorSetLayout)
 WRAPPER(VkDeviceMemory)
 WRAPPER(VkEvent)
 WRAPPER(VkFence)
 WRAPPER(VkFramebuffer)
 WRAPPER(VkImage)
 WRAPPER(VkImageView)
 WRAPPER(VkPipeline)
 WRAPPER(VkPipelineCache)
 WRAPPER(VkPipelineLayout)
 WRAPPER(VkQueryPool)
 WRAPPER(VkRenderPass)
 WRAPPER(VkSampler)
 WRAPPER(VkSemaphore)
 WRAPPER(VkShaderModule)
 WRAPPER(VkDebugReportCallbackEXT)
 WRAPPER(VkObjectTableNVX)
 WRAPPER(VkIndirectCommandsLayoutNVX)
 #else  // DISTINCT_NONDISPATCHABLE_HANDLES
 WRAPPER(uint64_t)
 #endif // DISTINCT_NONDISPATCHABLE_HANDLES


 static std::unordered_map<void *, layer_data *> layer_data_map;
 static std::mutex command_pool_lock;
 static std::unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;

 // VkCommandBuffer needs check for implicit use of command pool
 static void startWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) {
     if (lockPool) {
         std::unique_lock<std::mutex> lock(command_pool_lock);
         VkCommandPool pool = command_pool_map[object];
         lock.unlock();
         startWriteObject(my_data, pool);
     }
     my_data->c_VkCommandBuffer.startWrite(my_data->report_data, object);
 }
 static void finishWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) {
     my_data->c_VkCommandBuffer.finishWrite(object);
     if (lockPool) {
         std::unique_lock<std::mutex> lock(command_pool_lock);
         VkCommandPool pool = command_pool_map[object];
         lock.unlock();
         finishWriteObject(my_data, pool);
     }
 }
 static void startReadObject(struct layer_data *my_data, VkCommandBuffer object) {
     std::unique_lock<std::mutex> lock(command_pool_lock);
     VkCommandPool pool = command_pool_map[object];
     lock.unlock();
     startReadObject(my_data, pool);
     my_data->c_VkCommandBuffer.startRead(my_data->report_data, object);
 }
 static void finishReadObject(struct layer_data *my_data, VkCommandBuffer object) {
     my_data->c_VkCommandBuffer.finishRead(object);
     std::unique_lock<std::mutex> lock(command_pool_lock);
     VkCommandPool pool = command_pool_map[object];
     lock.unlock();
     finishReadObject(my_data, pool);
 }
 #endif // THREADING_H
	/* Copyright (c) 2015-2016 The Khronos Group Inc.
	* Copyright (c) 2015-2016 Valve Corporation
	* Copyright (c) 2015-2016 LunarG, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	* Author: Cody Northrop <cody@lunarg.com>
	* Author: Mike Stroyan <mike@LunarG.com>
	*/

	#ifndef THREADING_H
	#define THREADING_H
	#include <condition_variable>
	#include <mutex>
	#include <vector>
	#include "vk_layer_config.h"
	#include "vk_layer_logging.h"

	#if defined(__LP64__) \|\| defined(_WIN64) \|\| defined(__x86_64__) \|\| defined(_M_X64) \|\| defined(__ia64) \|\| defined(_M_IA64) \|\| \
	defined(__aarch64__) \|\| defined(__powerpc64__)
	// If pointers are 64-bit, then there can be separate counters for each
	// NONDISPATCHABLE_HANDLE type. Otherwise they are all typedef uint64_t.
	#define DISTINCT_NONDISPATCHABLE_HANDLES
	#endif

	// Draw State ERROR codes
	enum THREADING_CHECKER_ERROR {
	THREADING_CHECKER_NONE, // Used for INFO & other non-error messages
	THREADING_CHECKER_MULTIPLE_THREADS, // Object used simultaneously by multiple threads
	THREADING_CHECKER_SINGLE_THREAD_REUSE, // Object used simultaneously by recursion in single thread
	};

	struct object_use_data {
	loader_platform_thread_id thread;
	int reader_count;
	int writer_count;
	};

	struct layer_data;

	namespace threading {
	volatile bool vulkan_in_use = false;
	volatile bool vulkan_multi_threaded = false;
	// starting check if an application is using vulkan from multiple threads.
	inline bool startMultiThread() {
	if (vulkan_multi_threaded) {
	return true;
	}
	if (vulkan_in_use) {
	vulkan_multi_threaded = true;
	return true;
	}
	vulkan_in_use = true;
	return false;
	}

	// finishing check if an application is using vulkan from multiple threads.
	inline void finishMultiThread() { vulkan_in_use = false; }
	} // namespace threading

	template <typename T> class counter {
	public:
	const char *typeName;
	VkDebugReportObjectTypeEXT objectType;
	std::unordered_map<T, object_use_data> uses;
	std::mutex counter_lock;
	std::condition_variable counter_condition;
	void startWrite(debug_report_data *report_data, T object) {
	bool skipCall = false;
	loader_platform_thread_id tid = loader_platform_get_thread_id();
	std::unique_lock<std::mutex> lock(counter_lock);
	if (uses.find(object) == uses.end()) {
	// There is no current use of the object. Record writer thread.
	struct object_use_data *use_data = &uses[object];
	use_data->reader_count = 0;
	use_data->writer_count = 1;
	use_data->thread = tid;
	} else {
	struct object_use_data *use_data = &uses[object];
	if (use_data->reader_count == 0) {
	// There are no readers. Two writers just collided.
	if (use_data->thread != tid) {
	skipCall \|= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
	0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
	"THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
	typeName, use_data->thread, tid);
	if (skipCall) {
	// Wait for thread-safe access to object instead of skipping call.
	while (uses.find(object) != uses.end()) {
	counter_condition.wait(lock);
	}
	// There is now no current use of the object. Record writer thread.
	struct object_use_data *use_data = &uses[object];
	use_data->thread = tid;
	use_data->reader_count = 0;
	use_data->writer_count = 1;
	} else {
	// Continue with an unsafe use of the object.
	use_data->thread = tid;
	use_data->writer_count += 1;
	}
	} else {
	// This is either safe multiple use in one call, or recursive use.
	// There is no way to make recursion safe. Just forge ahead.
	use_data->writer_count += 1;
	}
	} else {
	// There are readers. This writer collided with them.
	if (use_data->thread != tid) {
	skipCall \|= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
	0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
	"THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
	typeName, use_data->thread, tid);
	if (skipCall) {
	// Wait for thread-safe access to object instead of skipping call.
	while (uses.find(object) != uses.end()) {
	counter_condition.wait(lock);
	}
	// There is now no current use of the object. Record writer thread.
	struct object_use_data *use_data = &uses[object];
	use_data->thread = tid;
	use_data->reader_count = 0;
	use_data->writer_count = 1;
	} else {
	// Continue with an unsafe use of the object.
	use_data->thread = tid;
	use_data->writer_count += 1;
	}
	} else {
	// This is either safe multiple use in one call, or recursive use.
	// There is no way to make recursion safe. Just forge ahead.
	use_data->writer_count += 1;
	}
	}
	}
	}

	void finishWrite(T object) {
	// Object is no longer in use
	std::unique_lock<std::mutex> lock(counter_lock);
	uses[object].writer_count -= 1;
	if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
	uses.erase(object);
	}
	// Notify any waiting threads that this object may be safe to use
	lock.unlock();
	counter_condition.notify_all();
	}

	void startRead(debug_report_data *report_data, T object) {
	bool skipCall = false;
	loader_platform_thread_id tid = loader_platform_get_thread_id();
	std::unique_lock<std::mutex> lock(counter_lock);
	if (uses.find(object) == uses.end()) {
	// There is no current use of the object. Record reader count
	struct object_use_data *use_data = &uses[object];
	use_data->reader_count = 1;
	use_data->writer_count = 0;
	use_data->thread = tid;
	} else if (uses[object].writer_count > 0 && uses[object].thread != tid) {
	// There is a writer of the object.
	skipCall \|= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
	0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
	"THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld", typeName,
	uses[object].thread, tid);
	if (skipCall) {
	// Wait for thread-safe access to object instead of skipping call.
	while (uses.find(object) != uses.end()) {
	counter_condition.wait(lock);
	}
	// There is no current use of the object. Record reader count
	struct object_use_data *use_data = &uses[object];
	use_data->reader_count = 1;
	use_data->writer_count = 0;
	use_data->thread = tid;
	} else {
	uses[object].reader_count += 1;
	}
	} else {
	// There are other readers of the object. Increase reader count
	uses[object].reader_count += 1;
	}
	}
	void finishRead(T object) {
	std::unique_lock<std::mutex> lock(counter_lock);
	uses[object].reader_count -= 1;
	if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
	uses.erase(object);
	}
	// Notify any waiting threads that this object may be safe to use
	lock.unlock();
	counter_condition.notify_all();
	}
	counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {
	typeName = name;
	objectType = type;
	}
	};

	struct layer_data {
	VkInstance instance;

	debug_report_data *report_data;
	std::vector<VkDebugReportCallbackEXT> logging_callback;
	VkLayerDispatchTable *device_dispatch_table;
	VkLayerInstanceDispatchTable *instance_dispatch_table;
	// The following are for keeping track of the temporary callbacks that can
	// be used in vkCreateInstance and vkDestroyInstance:
	uint32_t num_tmp_callbacks;
	VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos;
	VkDebugReportCallbackEXT *tmp_callbacks;
	counter<VkCommandBuffer> c_VkCommandBuffer;
	counter<VkDevice> c_VkDevice;
	counter<VkInstance> c_VkInstance;
	counter<VkQueue> c_VkQueue;
	#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
	counter<VkBuffer> c_VkBuffer;
	counter<VkBufferView> c_VkBufferView;
	counter<VkCommandPool> c_VkCommandPool;
	counter<VkDescriptorPool> c_VkDescriptorPool;
	counter<VkDescriptorSet> c_VkDescriptorSet;
	counter<VkDescriptorSetLayout> c_VkDescriptorSetLayout;
	counter<VkDeviceMemory> c_VkDeviceMemory;
	counter<VkEvent> c_VkEvent;
	counter<VkFence> c_VkFence;
	counter<VkFramebuffer> c_VkFramebuffer;
	counter<VkImage> c_VkImage;
	counter<VkImageView> c_VkImageView;
	counter<VkPipeline> c_VkPipeline;
	counter<VkPipelineCache> c_VkPipelineCache;
	counter<VkPipelineLayout> c_VkPipelineLayout;
	counter<VkQueryPool> c_VkQueryPool;
	counter<VkRenderPass> c_VkRenderPass;
	counter<VkSampler> c_VkSampler;
	counter<VkSemaphore> c_VkSemaphore;
	counter<VkShaderModule> c_VkShaderModule;
	counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT;
	counter<VkObjectTableNVX> c_VkObjectTableNVX;
	counter<VkIndirectCommandsLayoutNVX>c_VkIndirectCommandsLayoutNVX;
	#else // DISTINCT_NONDISPATCHABLE_HANDLES
	counter<uint64_t> c_uint64_t;
	#endif // DISTINCT_NONDISPATCHABLE_HANDLES

	layer_data()
	: report_data(nullptr), num_tmp_callbacks(0), tmp_dbg_create_infos(nullptr), tmp_callbacks(nullptr),
	c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT),
	c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT),
	c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT),
	c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT),
	#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
	c_VkBuffer("VkBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT),
	c_VkBufferView("VkBufferView", VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT),
	c_VkCommandPool("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT),
	c_VkDescriptorPool("VkDescriptorPool", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT),
	c_VkDescriptorSet("VkDescriptorSet", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT),
	c_VkDescriptorSetLayout("VkDescriptorSetLayout", VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT),
	c_VkDeviceMemory("VkDeviceMemory", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT),
	c_VkEvent("VkEvent", VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT), c_VkFence("VkFence", VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT),
	c_VkFramebuffer("VkFramebuffer", VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT),
	c_VkImage("VkImage", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT),
	c_VkImageView("VkImageView", VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT),
	c_VkPipeline("VkPipeline", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT),
	c_VkPipelineCache("VkPipelineCache", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT),
	c_VkPipelineLayout("VkPipelineLayout", VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT),
	c_VkQueryPool("VkQueryPool", VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT),
	c_VkRenderPass("VkRenderPass", VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT),
	c_VkSampler("VkSampler", VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT),
	c_VkSemaphore("VkSemaphore", VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT),
	c_VkShaderModule("VkShaderModule", VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT),
	c_VkDebugReportCallbackEXT("VkDebugReportCallbackEXT", VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT),
	c_VkObjectTableNVX("VkObjectTableNVX", VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT),
	c_VkIndirectCommandsLayoutNVX("VkIndirectCommandsLayoutNVX", VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT)
	#else // DISTINCT_NONDISPATCHABLE_HANDLES
	c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT)
	#endif // DISTINCT_NONDISPATCHABLE_HANDLES
	{};
	};

	#define WRAPPER(type) \
	static void startWriteObject(struct layer_data *my_data, type object) { \
	my_data->c_##type.startWrite(my_data->report_data, object); \
	} \
	static void finishWriteObject(struct layer_data *my_data, type object) { my_data->c_##type.finishWrite(object); } \
	static void startReadObject(struct layer_data *my_data, type object) { \
	my_data->c_##type.startRead(my_data->report_data, object); \
	} \
	static void finishReadObject(struct layer_data *my_data, type object) { my_data->c_##type.finishRead(object); }

	WRAPPER(VkDevice)
	WRAPPER(VkInstance)
	WRAPPER(VkQueue)
	#ifdef DISTINCT_NONDISPATCHABLE_HANDLES
	WRAPPER(VkBuffer)
	WRAPPER(VkBufferView)
	WRAPPER(VkCommandPool)
	WRAPPER(VkDescriptorPool)
	WRAPPER(VkDescriptorSet)
	WRAPPER(VkDescriptorSetLayout)
	WRAPPER(VkDeviceMemory)
	WRAPPER(VkEvent)
	WRAPPER(VkFence)
	WRAPPER(VkFramebuffer)
	WRAPPER(VkImage)
	WRAPPER(VkImageView)
	WRAPPER(VkPipeline)
	WRAPPER(VkPipelineCache)
	WRAPPER(VkPipelineLayout)
	WRAPPER(VkQueryPool)
	WRAPPER(VkRenderPass)
	WRAPPER(VkSampler)
	WRAPPER(VkSemaphore)
	WRAPPER(VkShaderModule)
	WRAPPER(VkDebugReportCallbackEXT)
	WRAPPER(VkObjectTableNVX)
	WRAPPER(VkIndirectCommandsLayoutNVX)
	#else // DISTINCT_NONDISPATCHABLE_HANDLES
	WRAPPER(uint64_t)
	#endif // DISTINCT_NONDISPATCHABLE_HANDLES


	static std::unordered_map<void , layer_data > layer_data_map;
	static std::mutex command_pool_lock;
	static std::unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;

	// VkCommandBuffer needs check for implicit use of command pool
	static void startWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) {
	if (lockPool) {
	std::unique_lock<std::mutex> lock(command_pool_lock);
	VkCommandPool pool = command_pool_map[object];
	lock.unlock();
	startWriteObject(my_data, pool);
	}
	my_data->c_VkCommandBuffer.startWrite(my_data->report_data, object);
	}
	static void finishWriteObject(struct layer_data *my_data, VkCommandBuffer object, bool lockPool = true) {
	my_data->c_VkCommandBuffer.finishWrite(object);
	if (lockPool) {
	std::unique_lock<std::mutex> lock(command_pool_lock);
	VkCommandPool pool = command_pool_map[object];
	lock.unlock();
	finishWriteObject(my_data, pool);
	}
	}
	static void startReadObject(struct layer_data *my_data, VkCommandBuffer object) {
	std::unique_lock<std::mutex> lock(command_pool_lock);
	VkCommandPool pool = command_pool_map[object];
	lock.unlock();
	startReadObject(my_data, pool);
	my_data->c_VkCommandBuffer.startRead(my_data->report_data, object);
	}
	static void finishReadObject(struct layer_data *my_data, VkCommandBuffer object) {
	my_data->c_VkCommandBuffer.finishRead(object);
	std::unique_lock<std::mutex> lock(command_pool_lock);
	VkCommandPool pool = command_pool_map[object];
	lock.unlock();
	finishReadObject(my_data, pool);
	}
	#endif // THREADING_H