#!/usr/bin/python3 -i # # Copyright (c) 2015-2019 The Khronos Group Inc. # Copyright (c) 2015-2019 Valve Corporation # Copyright (c) 2015-2019 LunarG, Inc. # Copyright (c) 2015-2019 Google 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: Mike Stroyan # Author: Mark Lobodzinski import os,re,sys from generator import * from common_codegen import * # ThreadGeneratorOptions - subclass of GeneratorOptions. # # Adds options used by ThreadOutputGenerator objects during threading # layer generation. # # Additional members # prefixText - list of strings to prefix generated header with # (usually a copyright statement + calling convention macros). # protectFile - True if multiple inclusion protection should be # generated (based on the filename) around the entire header. # protectFeature - True if #ifndef..#endif protection should be # generated around a feature interface in the header file. # genFuncPointers - True if function pointer typedefs should be # generated # protectProto - If conditional protection should be generated # around prototype declarations, set to either '#ifdef' # to require opt-in (#ifdef protectProtoStr) or '#ifndef' # to require opt-out (#ifndef protectProtoStr). Otherwise # set to None. # protectProtoStr - #ifdef/#ifndef symbol to use around prototype # declarations, if protectProto is set # apicall - string to use for the function declaration prefix, # such as APICALL on Windows. # apientry - string to use for the calling convention macro, # in typedefs, such as APIENTRY. # apientryp - string to use for the calling convention macro # in function pointer typedefs, such as APIENTRYP. # indentFuncProto - True if prototype declarations should put each # parameter on a separate line # indentFuncPointer - True if typedefed function pointers should put each # parameter on a separate line # alignFuncParam - if nonzero and parameters are being put on a # separate line, align parameter names at the specified column class ThreadGeneratorOptions(GeneratorOptions): def __init__(self, conventions = None, filename = None, directory = '.', apiname = None, profile = None, versions = '.*', emitversions = '.*', defaultExtensions = None, addExtensions = None, removeExtensions = None, emitExtensions = None, sortProcedure = regSortFeatures, prefixText = "", genFuncPointers = True, protectFile = True, protectFeature = True, apicall = '', apientry = '', apientryp = '', indentFuncProto = True, indentFuncPointer = False, alignFuncParam = 0, expandEnumerants = True): GeneratorOptions.__init__(self, conventions, filename, directory, apiname, profile, versions, emitversions, defaultExtensions, addExtensions, removeExtensions, emitExtensions, sortProcedure) self.prefixText = prefixText self.genFuncPointers = genFuncPointers self.protectFile = protectFile self.protectFeature = protectFeature self.apicall = apicall self.apientry = apientry self.apientryp = apientryp self.indentFuncProto = indentFuncProto self.indentFuncPointer = indentFuncPointer self.alignFuncParam = alignFuncParam self.expandEnumerants = expandEnumerants # ThreadOutputGenerator - subclass of OutputGenerator. # Generates Thread checking framework # # ---- methods ---- # ThreadOutputGenerator(errFile, warnFile, diagFile) - args as for # OutputGenerator. Defines additional internal state. # ---- methods overriding base class ---- # beginFile(genOpts) # endFile() # beginFeature(interface, emit) # endFeature() # genType(typeinfo,name) # genStruct(typeinfo,name) # genGroup(groupinfo,name) # genEnum(enuminfo, name) # genCmd(cmdinfo) class ThreadOutputGenerator(OutputGenerator): """Generate specified API interfaces in a specific style, such as a C header""" inline_copyright_message = """ // This file is ***GENERATED***. Do Not Edit. // See thread_safety_generator.py for modifications. /* Copyright (c) 2015-2019 The Khronos Group Inc. * Copyright (c) 2015-2019 Valve Corporation * Copyright (c) 2015-2019 LunarG, Inc. * Copyright (c) 2015-2019 Google 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: Mark Lobodzinski */""" # Note that the inline_custom_header_preamble template below contains three embedded template expansion identifiers. # These get replaced with generated code sections, and are labeled: # o COUNTER_CLASS_DEFINITIONS_TEMPLATE # o COUNTER_CLASS_INSTANCES_TEMPLATE # o COUNTER_CLASS_BODIES_TEMPLATE inline_custom_header_preamble = """ #pragma once #include #include #include #include #include #include VK_DEFINE_NON_DISPATCHABLE_HANDLE(DISTINCT_NONDISPATCHABLE_PHONY_HANDLE) // The following line must match the vulkan_core.h condition guarding VK_DEFINE_NON_DISPATCHABLE_HANDLE #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || 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 // Make sure we catch any disagreement between us and the vulkan definition static_assert(std::is_pointer::value, "Mismatched non-dispatchable handle handle, expected pointer type."); #else // Make sure we catch any disagreement between us and the vulkan definition static_assert(std::is_same::value, "Mismatched non-dispatchable handle handle, expected uint64_t."); #endif // Suppress unused warning on Linux #if defined(__GNUC__) #define DECORATE_UNUSED __attribute__((unused)) #else #define DECORATE_UNUSED #endif // clang-format off static const char DECORATE_UNUSED *kVUID_Threading_Info = "UNASSIGNED-Threading-Info"; static const char DECORATE_UNUSED *kVUID_Threading_MultipleThreads = "UNASSIGNED-Threading-MultipleThreads"; static const char DECORATE_UNUSED *kVUID_Threading_SingleThreadReuse = "UNASSIGNED-Threading-SingleThreadReuse"; // clang-format on #undef DECORATE_UNUSED struct object_use_data { loader_platform_thread_id thread; int reader_count; int writer_count; }; // This is a wrapper around unordered_map that optimizes for the common case // of only containing a single element. The "first" element's use is stored // inline in the class and doesn't require hashing or memory (de)allocation. // TODO: Consider generalizing this from one element to N elements (where N // is a template parameter). template class small_unordered_map { bool first_data_allocated; Key first_data_key; T first_data; std::unordered_map uses; public: small_unordered_map() : first_data_allocated(false) {} bool contains(const Key& object) const { if (first_data_allocated && object == first_data_key) { return true; // check size() first to avoid hashing object unnecessarily. } else if (uses.size() == 0) { return false; } else { return uses.find(object) != uses.end(); } } T& operator[](const Key& object) { if (first_data_allocated && first_data_key == object) { return first_data; } else if (!first_data_allocated && uses.size() == 0) { first_data_allocated = true; first_data_key = object; return first_data; } else { return uses[object]; } } typename std::unordered_map::size_type erase(const Key& object) { if (first_data_allocated && first_data_key == object) { first_data_allocated = false; return 1; } else { return uses.erase(object); } } }; #define THREAD_SAFETY_BUCKETS_LOG2 6 #define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2) template inline uint32_t ThreadSafetyHashObject(T object) { uint64_t u64 = (uint64_t)(uintptr_t)object; uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64; hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2)); hash &= (THREAD_SAFETY_BUCKETS-1); return hash; } template class counter { public: const char *typeName; VkDebugReportObjectTypeEXT objectType; debug_report_data **report_data; // Per-bucket locking, to reduce contention. struct CounterBucket { small_unordered_map uses; std::mutex counter_lock; }; CounterBucket buckets[THREAD_SAFETY_BUCKETS]; CounterBucket &GetBucket(T object) { return buckets[ThreadSafetyHashObject(object)]; } void StartWrite(T object) { if (object == VK_NULL_HANDLE) { return; } auto &bucket = GetBucket(object); bool skip = false; loader_platform_thread_id tid = loader_platform_get_thread_id(); std::unique_lock lock(bucket.counter_lock); if (!bucket.uses.contains(object)) { // There is no current use of the object. Record writer thread. struct object_use_data *use_data = &bucket.uses[object]; use_data->reader_count = 0; use_data->writer_count = 1; use_data->thread = tid; } else { struct object_use_data *use_data = &bucket.uses[object]; if (use_data->reader_count == 0) { // There are no readers. Two writers just collided. if (use_data->thread != tid) { skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), kVUID_Threading_MultipleThreads, "THREADING ERROR : object of type %s is simultaneously used in " "thread 0x%" PRIx64 " and thread 0x%" PRIx64, typeName, (uint64_t)use_data->thread, (uint64_t)tid); if (skip) { WaitForObjectIdle(bucket, object, lock); // There is now no current use of the object. Record writer thread. struct object_use_data *new_use_data = &bucket.uses[object]; new_use_data->thread = tid; new_use_data->reader_count = 0; new_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) { skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), kVUID_Threading_MultipleThreads, "THREADING ERROR : object of type %s is simultaneously used in " "thread 0x%" PRIx64 " and thread 0x%" PRIx64, typeName, (uint64_t)use_data->thread, (uint64_t)tid); if (skip) { WaitForObjectIdle(bucket, object, lock); // There is now no current use of the object. Record writer thread. struct object_use_data *new_use_data = &bucket.uses[object]; new_use_data->thread = tid; new_use_data->reader_count = 0; new_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) { if (object == VK_NULL_HANDLE) { return; } auto &bucket = GetBucket(object); // Object is no longer in use std::unique_lock lock(bucket.counter_lock); struct object_use_data *use_data = &bucket.uses[object]; use_data->writer_count -= 1; if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) { bucket.uses.erase(object); } } void StartRead(T object) { if (object == VK_NULL_HANDLE) { return; } auto &bucket = GetBucket(object); bool skip = false; loader_platform_thread_id tid = loader_platform_get_thread_id(); std::unique_lock lock(bucket.counter_lock); if (!bucket.uses.contains(object)) { // There is no current use of the object. Record reader count struct object_use_data *use_data = &bucket.uses[object]; use_data->reader_count = 1; use_data->writer_count = 0; use_data->thread = tid; } else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) { // There is a writer of the object. skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), kVUID_Threading_MultipleThreads, "THREADING ERROR : object of type %s is simultaneously used in " "thread 0x%" PRIx64 " and thread 0x%" PRIx64, typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid); if (skip) { WaitForObjectIdle(bucket, object, lock); // There is no current use of the object. Record reader count struct object_use_data *use_data = &bucket.uses[object]; use_data->reader_count = 1; use_data->writer_count = 0; use_data->thread = tid; } else { bucket.uses[object].reader_count += 1; } } else { // There are other readers of the object. Increase reader count bucket.uses[object].reader_count += 1; } } void FinishRead(T object) { if (object == VK_NULL_HANDLE) { return; } auto &bucket = GetBucket(object); std::unique_lock lock(bucket.counter_lock); struct object_use_data *use_data = &bucket.uses[object]; use_data->reader_count -= 1; if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) { bucket.uses.erase(object); } } counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) { typeName = name; objectType = type; report_data = rep_data; } private: void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock &lock) { // Wait for thread-safe access to object instead of skipping call. // Don't use condition_variable to wait because it should be extremely // rare to have collisions, but signaling would be very frequent. while (bucket.uses.contains(object)) { lock.unlock(); std::this_thread::sleep_for(std::chrono::microseconds(1)); lock.lock(); } } }; class ThreadSafety : public ValidationObject { public: // Override chassis read/write locks for this validation object // This override takes a deferred lock. i.e. it is not acquired. std::unique_lock write_lock() { return std::unique_lock(validation_object_mutex, std::defer_lock); } // Per-bucket locking, to reduce contention. struct CommandBufferBucket { std::mutex command_pool_lock; small_unordered_map command_pool_map; }; CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS]; CommandBufferBucket &GetBucket(VkCommandBuffer object) { return buckets[ThreadSafetyHashObject(object)]; } counter c_VkCommandBuffer; counter c_VkDevice; counter c_VkInstance; counter c_VkQueue; #ifdef DISTINCT_NONDISPATCHABLE_HANDLES // Special entry to allow tracking of command pool Reset and Destroy counter c_VkCommandPoolContents; COUNTER_CLASS_DEFINITIONS_TEMPLATE #else // DISTINCT_NONDISPATCHABLE_HANDLES // Special entry to allow tracking of command pool Reset and Destroy counter c_VkCommandPoolContents; counter c_uint64_t; #endif // DISTINCT_NONDISPATCHABLE_HANDLES ThreadSafety() : c_VkCommandBuffer("VkCommandBuffer", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, &report_data), c_VkDevice("VkDevice", VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, &report_data), c_VkInstance("VkInstance", VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, &report_data), c_VkQueue("VkQueue", VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, &report_data), c_VkCommandPoolContents("VkCommandPool", VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, &report_data), #ifdef DISTINCT_NONDISPATCHABLE_HANDLES COUNTER_CLASS_INSTANCES_TEMPLATE #else // DISTINCT_NONDISPATCHABLE_HANDLES c_uint64_t("NON_DISPATCHABLE_HANDLE", VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, &report_data) #endif // DISTINCT_NONDISPATCHABLE_HANDLES {}; #define WRAPPER(type) \ void StartWriteObject(type object) { \ c_##type.StartWrite(object); \ } \ void FinishWriteObject(type object) { \ c_##type.FinishWrite(object); \ } \ void StartReadObject(type object) { \ c_##type.StartRead(object); \ } \ void FinishReadObject(type object) { \ c_##type.FinishRead(object); \ } WRAPPER(VkDevice) WRAPPER(VkInstance) WRAPPER(VkQueue) #ifdef DISTINCT_NONDISPATCHABLE_HANDLES COUNTER_CLASS_BODIES_TEMPLATE #else // DISTINCT_NONDISPATCHABLE_HANDLES WRAPPER(uint64_t) #endif // DISTINCT_NONDISPATCHABLE_HANDLES // VkCommandBuffer needs check for implicit use of command pool void StartWriteObject(VkCommandBuffer object, bool lockPool = true) { if (lockPool) { auto &bucket = GetBucket(object); std::unique_lock lock(bucket.command_pool_lock); VkCommandPool pool = bucket.command_pool_map[object]; lock.unlock(); StartWriteObject(pool); } c_VkCommandBuffer.StartWrite(object); } void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) { c_VkCommandBuffer.FinishWrite(object); if (lockPool) { auto &bucket = GetBucket(object); std::unique_lock lock(bucket.command_pool_lock); VkCommandPool pool = bucket.command_pool_map[object]; lock.unlock(); FinishWriteObject(pool); } } void StartReadObject(VkCommandBuffer object) { auto &bucket = GetBucket(object); std::unique_lock lock(bucket.command_pool_lock); VkCommandPool pool = bucket.command_pool_map[object]; lock.unlock(); // We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool // while *not* establishing a read guard against the command pool counter itself to avoid false postives for // non-externally sync'd command buffers c_VkCommandPoolContents.StartRead(pool); c_VkCommandBuffer.StartRead(object); } void FinishReadObject(VkCommandBuffer object) { auto &bucket = GetBucket(object); c_VkCommandBuffer.FinishRead(object); std::unique_lock lock(bucket.command_pool_lock); VkCommandPool pool = bucket.command_pool_map[object]; lock.unlock(); c_VkCommandPoolContents.FinishRead(pool); } """ inline_custom_source_preamble = """ void ThreadSafety::PreCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) { StartReadObject(device); StartWriteObject(pAllocateInfo->commandPool); } void ThreadSafety::PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers, VkResult result) { FinishReadObject(device); FinishWriteObject(pAllocateInfo->commandPool); // Record mapping from command buffer to command pool if(pCommandBuffers) { for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) { auto &bucket = GetBucket(pCommandBuffers[index]); std::lock_guard lock(bucket.command_pool_lock); bucket.command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool; } } } void ThreadSafety::PreCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { StartReadObject(device); StartWriteObject(pAllocateInfo->descriptorPool); // Host access to pAllocateInfo::descriptorPool must be externally synchronized } void ThreadSafety::PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets, VkResult result) { FinishReadObject(device); FinishWriteObject(pAllocateInfo->descriptorPool); // Host access to pAllocateInfo::descriptorPool must be externally synchronized } void ThreadSafety::PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) { const bool lockCommandPool = false; // pool is already directly locked StartReadObject(device); StartWriteObject(commandPool); if(pCommandBuffers) { // Even though we're immediately "finishing" below, we still are testing for concurrency with any call in process // so this isn't a no-op for (uint32_t index = 0; index < commandBufferCount; index++) { StartWriteObject(pCommandBuffers[index], lockCommandPool); } // The driver may immediately reuse command buffers in another thread. // These updates need to be done before calling down to the driver. for (uint32_t index = 0; index < commandBufferCount; index++) { FinishWriteObject(pCommandBuffers[index], lockCommandPool); } // Holding the lock for the shortest time while we update the map for (uint32_t index = 0; index < commandBufferCount; index++) { auto &bucket = GetBucket(pCommandBuffers[index]); std::lock_guard lock(bucket.command_pool_lock); bucket.command_pool_map.erase(pCommandBuffers[index]); } } } void ThreadSafety::PostCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) { FinishReadObject(device); FinishWriteObject(commandPool); } void ThreadSafety::PreCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { StartReadObject(device); StartWriteObject(commandPool); // Check for any uses of non-externally sync'd command buffers (for example from vkCmdExecuteCommands) c_VkCommandPoolContents.StartWrite(commandPool); // Host access to commandPool must be externally synchronized } void ThreadSafety::PostCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult result) { FinishReadObject(device); FinishWriteObject(commandPool); c_VkCommandPoolContents.FinishWrite(commandPool); // Host access to commandPool must be externally synchronized } void ThreadSafety::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { StartReadObject(device); StartWriteObject(commandPool); // Check for any uses of non-externally sync'd command buffers (for example from vkCmdExecuteCommands) c_VkCommandPoolContents.StartWrite(commandPool); // Host access to commandPool must be externally synchronized } void ThreadSafety::PostCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { FinishReadObject(device); FinishWriteObject(commandPool); c_VkCommandPoolContents.FinishWrite(commandPool); } // GetSwapchainImages can return a non-zero count with a NULL pSwapchainImages pointer. Let's avoid crashes by ignoring // pSwapchainImages. void ThreadSafety::PreCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { StartReadObject(device); StartReadObject(swapchain); } void ThreadSafety::PostCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages, VkResult result) { FinishReadObject(device); FinishReadObject(swapchain); } """ # This is an ordered list of sections in the header file. ALL_SECTIONS = ['command'] def __init__(self, errFile = sys.stderr, warnFile = sys.stderr, diagFile = sys.stdout): OutputGenerator.__init__(self, errFile, warnFile, diagFile) # Internal state - accumulators for different inner block text self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) self.non_dispatchable_types = set() self.object_to_debug_report_type = { 'VkInstance' : 'VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT', 'VkPhysicalDevice' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT', 'VkDevice' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT', 'VkQueue' : 'VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT', 'VkSemaphore' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT', 'VkCommandBuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT', 'VkFence' : 'VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT', 'VkDeviceMemory' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT', 'VkBuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT', 'VkImage' : 'VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT', 'VkEvent' : 'VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT', 'VkQueryPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT', 'VkBufferView' : 'VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT', 'VkImageView' : 'VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT', 'VkShaderModule' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT', 'VkPipelineCache' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT', 'VkPipelineLayout' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT', 'VkRenderPass' : 'VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT', 'VkPipeline' : 'VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT', 'VkDescriptorSetLayout' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT', 'VkSampler' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT', 'VkDescriptorPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT', 'VkDescriptorSet' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT', 'VkFramebuffer' : 'VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT', 'VkCommandPool' : 'VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT', 'VkSurfaceKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT', 'VkSwapchainKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT', 'VkDisplayKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT', 'VkDisplayModeKHR' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT', 'VkObjectTableNVX' : 'VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT', 'VkIndirectCommandsLayoutNVX' : 'VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT', 'VkSamplerYcbcrConversion' : 'VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT', 'VkDescriptorUpdateTemplate' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT', 'VkAccelerationStructureNV' : 'VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT', 'VkDebugReportCallbackEXT' : 'VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT', 'VkValidationCacheEXT' : 'VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT' } # Check if the parameter passed in is a pointer to an array def paramIsArray(self, param): return param.attrib.get('len') is not None # Check if the parameter passed in is a pointer def paramIsPointer(self, param): ispointer = False for elem in param: if elem.tag == 'type' and elem.tail is not None and '*' in elem.tail: ispointer = True return ispointer def makeThreadUseBlock(self, cmd, functionprefix): """Generate C function pointer typedef for Element""" paramdecl = '' # Find and add any parameters that are thread unsafe params = cmd.findall('param') for param in params: paramname = param.find('name') if False: # self.paramIsPointer(param): paramdecl += ' // not watching use of pointer ' + paramname.text + '\n' else: externsync = param.attrib.get('externsync') if externsync == 'true': if self.paramIsArray(param): paramdecl += 'if (' + paramname.text + ') {\n' paramdecl += ' for (uint32_t index=0; index < ' + param.attrib.get('len') + '; index++) {\n' paramdecl += ' ' + functionprefix + 'WriteObject(' + paramname.text + '[index]);\n' paramdecl += ' }\n' paramdecl += '}\n' else: paramdecl += functionprefix + 'WriteObject(' + paramname.text + ');\n' elif (param.attrib.get('externsync')): if self.paramIsArray(param): # Externsync can list pointers to arrays of members to synchronize paramdecl += 'if (' + paramname.text + ') {\n' paramdecl += ' for (uint32_t index=0; index < ' + param.attrib.get('len') + '; index++) {\n' second_indent = ' ' for member in externsync.split(","): # Replace first empty [] in member name with index element = member.replace('[]','[index]',1) if '[]' in element: # TODO: These null checks can be removed if threading ends up behind parameter # validation in layer order element_ptr = element.split('[]')[0] paramdecl += ' if (' + element_ptr + ') {\n' # Replace any second empty [] in element name with inner array index based on mapping array # names like "pSomeThings[]" to "someThingCount" array size. This could be more robust by # mapping a param member name to a struct type and "len" attribute. limit = element[0:element.find('s[]')] + 'Count' dotp = limit.rfind('.p') limit = limit[0:dotp+1] + limit[dotp+2:dotp+3].lower() + limit[dotp+3:] paramdecl += ' for (uint32_t index2=0; index2 < '+limit+'; index2++) {\n' element = element.replace('[]','[index2]') second_indent = ' ' paramdecl += ' ' + second_indent + functionprefix + 'WriteObject(' + element + ');\n' paramdecl += ' }\n' paramdecl += ' }\n' else: paramdecl += ' ' + second_indent + functionprefix + 'WriteObject(' + element + ');\n' paramdecl += ' }\n' paramdecl += '}\n' else: # externsync can list members to synchronize for member in externsync.split(","): member = str(member).replace("::", "->") member = str(member).replace(".", "->") paramdecl += ' ' + functionprefix + 'WriteObject(' + member + ');\n' else: paramtype = param.find('type') if paramtype is not None: paramtype = paramtype.text else: paramtype = 'None' if paramtype in self.handle_types and paramtype != 'VkPhysicalDevice': if self.paramIsArray(param) and ('pPipelines' != paramname.text): # Add pointer dereference for array counts that are pointer values dereference = '' for candidate in params: if param.attrib.get('len') == candidate.find('name').text: if self.paramIsPointer(candidate): dereference = '*' param_len = str(param.attrib.get('len')).replace("::", "->") paramdecl += 'if (' + paramname.text + ') {\n' paramdecl += ' for (uint32_t index = 0; index < ' + dereference + param_len + '; index++) {\n' paramdecl += ' ' + functionprefix + 'ReadObject(' + paramname.text + '[index]);\n' paramdecl += ' }\n' paramdecl += '}\n' elif not self.paramIsPointer(param): # Pointer params are often being created. # They are not being read from. paramdecl += functionprefix + 'ReadObject(' + paramname.text + ');\n' explicitexternsyncparams = cmd.findall("param[@externsync]") if (explicitexternsyncparams is not None): for param in explicitexternsyncparams: externsyncattrib = param.attrib.get('externsync') paramname = param.find('name') paramdecl += '// Host access to ' if externsyncattrib == 'true': if self.paramIsArray(param): paramdecl += 'each member of ' + paramname.text elif self.paramIsPointer(param): paramdecl += 'the object referenced by ' + paramname.text else: paramdecl += paramname.text else: paramdecl += externsyncattrib paramdecl += ' must be externally synchronized\n' # Find and add any "implicit" parameters that are thread unsafe implicitexternsyncparams = cmd.find('implicitexternsyncparams') if (implicitexternsyncparams is not None): for elem in implicitexternsyncparams: paramdecl += '// ' paramdecl += elem.text paramdecl += ' must be externally synchronized between host accesses\n' if (paramdecl == ''): return None else: return paramdecl def beginFile(self, genOpts): OutputGenerator.beginFile(self, genOpts) # Initialize members that require the tree self.handle_types = GetHandleTypes(self.registry.tree) # TODO: LUGMAL -- remove this and add our copyright # User-supplied prefix text, if any (list of strings) write(self.inline_copyright_message, file=self.outFile) self.header_file = (genOpts.filename == 'thread_safety.h') self.source_file = (genOpts.filename == 'thread_safety.cpp') if not self.header_file and not self.source_file: print("Error: Output Filenames have changed, update generator source.\n") sys.exit(1) if self.source_file: write('#include "chassis.h"', file=self.outFile) write('#include "thread_safety.h"', file=self.outFile) self.newline() write(self.inline_custom_source_preamble, file=self.outFile) def endFile(self): # Create class definitions counter_class_defs = '' counter_class_instances = '' counter_class_bodies = '' for obj in sorted(self.non_dispatchable_types): counter_class_defs += ' counter<%s> c_%s;\n' % (obj, obj) if obj in self.object_to_debug_report_type: obj_type = self.object_to_debug_report_type[obj] else: obj_type = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' counter_class_instances += ' c_%s("%s", %s, &report_data),\n' % (obj, obj, obj_type) counter_class_bodies += 'WRAPPER(%s)\n' % obj if self.header_file: class_def = self.inline_custom_header_preamble.replace('COUNTER_CLASS_DEFINITIONS_TEMPLATE', counter_class_defs) class_def = class_def.replace('COUNTER_CLASS_INSTANCES_TEMPLATE', counter_class_instances[:-2]) # Kill last comma class_def = class_def.replace('COUNTER_CLASS_BODIES_TEMPLATE', counter_class_bodies) write(class_def, file=self.outFile) write('\n'.join(self.sections['command']), file=self.outFile) if self.header_file: write('};', file=self.outFile) # Finish processing in superclass OutputGenerator.endFile(self) def beginFeature(self, interface, emit): #write('// starting beginFeature', file=self.outFile) # Start processing in superclass OutputGenerator.beginFeature(self, interface, emit) # C-specific # Accumulate includes, defines, types, enums, function pointer typedefs, # end function prototypes separately for this feature. They're only # printed in endFeature(). self.featureExtraProtect = GetFeatureProtect(interface) if (self.featureExtraProtect is not None): self.appendSection('command', '\n#ifdef %s' % self.featureExtraProtect) #write('// ending beginFeature', file=self.outFile) def endFeature(self): # C-specific if (self.emit): if (self.featureExtraProtect is not None): self.appendSection('command', '#endif // %s' % self.featureExtraProtect) # Finish processing in superclass OutputGenerator.endFeature(self) # # Append a definition to the specified section def appendSection(self, section, text): self.sections[section].append(text) # # Type generation def genType(self, typeinfo, name, alias): OutputGenerator.genType(self, typeinfo, name, alias) if self.handle_types.IsNonDispatchable(name): self.non_dispatchable_types.add(name) # # Struct (e.g. C "struct" type) generation. # This is a special case of the tag where the contents are # interpreted as a set of tags instead of freeform C # C type declarations. The tags are just like # tags - they are a declaration of a struct or union member. # Only simple member declarations are supported (no nested # structs etc.) def genStruct(self, typeinfo, typeName, alias): OutputGenerator.genStruct(self, typeinfo, typeName, alias) body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n' # paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam) for member in typeinfo.elem.findall('.//member'): body += self.makeCParamDecl(member, self.genOpts.alignFuncParam) body += ';\n' body += '} ' + typeName + ';\n' self.appendSection('struct', body) # # Group (e.g. C "enum" type) generation. # These are concatenated together with other types. def genGroup(self, groupinfo, groupName, alias): pass # Enumerant generation # tags may specify their values in several ways, but are usually # just integers. def genEnum(self, enuminfo, name, alias): pass # # Command generation def genCmd(self, cmdinfo, name, alias): # Commands shadowed by interface functions and are not implemented special_functions = [ 'vkCreateDevice', 'vkCreateInstance', 'vkAllocateCommandBuffers', 'vkFreeCommandBuffers', 'vkResetCommandPool', 'vkDestroyCommandPool', 'vkAllocateDescriptorSets', 'vkQueuePresentKHR', 'vkGetSwapchainImagesKHR', ] if name == 'vkQueuePresentKHR' or (name in special_functions and self.source_file): return if (("DebugMarker" in name or "DebugUtilsObject" in name) and "EXT" in name): self.appendSection('command', '// TODO - not wrapping EXT function ' + name) return # Determine first if this function needs to be intercepted startthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'Start') if startthreadsafety is None: return finishthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'Finish') OutputGenerator.genCmd(self, cmdinfo, name, alias) # setup common to call wrappers # first parameter is always dispatchable dispatchable_type = cmdinfo.elem.find('param/type').text dispatchable_name = cmdinfo.elem.find('param/name').text decls = self.makeCDecls(cmdinfo.elem) result_type = cmdinfo.elem.find('proto/type') if self.source_file: pre_decl = decls[0][:-1] pre_decl = pre_decl.split("VKAPI_CALL ")[1] pre_decl = 'void ThreadSafety::PreCallRecord' + pre_decl + ' {' # PreCallRecord self.appendSection('command', '') self.appendSection('command', pre_decl) self.appendSection('command', " " + "\n ".join(str(startthreadsafety).rstrip().split("\n"))) self.appendSection('command', '}') # PostCallRecord post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord') if result_type.text == 'VkResult': post_decl = post_decl.replace(')', ',\n VkResult result)') self.appendSection('command', '') self.appendSection('command', post_decl) self.appendSection('command', " " + "\n ".join(str(finishthreadsafety).rstrip().split("\n"))) self.appendSection('command', '}') if self.header_file: pre_decl = decls[0][:-1] pre_decl = pre_decl.split("VKAPI_CALL ")[1] pre_decl = 'void PreCallRecord' + pre_decl + ';' # PreCallRecord self.appendSection('command', '') self.appendSection('command', pre_decl) # PostCallRecord post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord') if result_type.text == 'VkResult': post_decl = post_decl.replace(')', ',\n VkResult result)') self.appendSection('command', '') self.appendSection('command', post_decl) # # override makeProtoName to drop the "vk" prefix def makeProtoName(self, name, tail): return self.genOpts.apientry + name[2:] + tail