layers: Refactor threading layer to use chassis
Added:
thread_safety_validation.h
thread_safety.cpp (codegen)
thread_safety.h (codegen)
Removed:
threading.cpp
threading.h
thread_check.h (codegen)
Also modified the chassis to allow control over pre/post calls on
a per-validation-object basis.
Change-Id: I63600d6e7ea1e14ae4796fe949d36420c7dd4dec
diff --git a/scripts/thread_safety_generator.py b/scripts/thread_safety_generator.py
new file mode 100644
index 0000000..ae80b91
--- /dev/null
+++ b/scripts/thread_safety_generator.py
@@ -0,0 +1,546 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2016 The Khronos Group Inc.
+# Copyright (c) 2015-2016 Valve Corporation
+# Copyright (c) 2015-2016 LunarG, Inc.
+# Copyright (c) 2015-2016 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 <stroyan@google.com>
+# Author: Mark Lobodzinski <mark@lunarg.com>
+
+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,
+ 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, 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 layer_chassis_dispatch_generator.py for modifications.
+
+/* Copyright (c) 2015-2018 The Khronos Group Inc.
+ * Copyright (c) 2015-2018 Valve Corporation
+ * Copyright (c) 2015-2018 LunarG, Inc.
+ * Copyright (c) 2015-2018 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 <mark@lunarg.com>
+ */"""
+
+ 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) {
+ FinishReadObject(device);
+ FinishWriteObject(pAllocateInfo->commandPool);
+
+ // Record mapping from command buffer to command pool
+ for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) {
+ std::lock_guard<std::mutex> lock(command_pool_lock);
+ 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) {
+ 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);
+ 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);
+ std::lock_guard<std::mutex> lock(command_pool_lock);
+ 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) {
+ 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);
+}
+
+"""
+
+
+ # This is an ordered list of sections in the header file.
+ TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum',
+ 'group', 'bitmask', 'funcpointer', 'struct']
+ ALL_SECTIONS = TYPE_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])
+
+ # 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 is not 'type') and (elem.tail is not None)) and '*' in elem.tail:
+ ispointer = True
+ return ispointer
+
+ # Check if an object is a non-dispatchable handle
+ def isHandleTypeNonDispatchable(self, handletype):
+ handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']")
+ if handle is not None and handle.find('type').text == 'VK_DEFINE_NON_DISPATCHABLE_HANDLE':
+ return True
+ else:
+ return False
+
+ # Check if an object is a dispatchable handle
+ def isHandleTypeDispatchable(self, handletype):
+ handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']")
+ if handle is not None and handle.find('type').text == 'VK_DEFINE_HANDLE':
+ return True
+ else:
+ return False
+
+ def makeThreadUseBlock(self, cmd, functionprefix):
+ """Generate C function pointer typedef for <command> 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 += 'for (uint32_t index=0;index<' + param.attrib.get('len') + ';index++) {\n'
+ paramdecl += ' ' + functionprefix + 'WriteObject(' + paramname.text + '[index]);\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 += '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:
+ # 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'
+ 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 (self.isHandleTypeDispatchable(paramtype) or self.isHandleTypeNonDispatchable(paramtype)) 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 += 'for (uint32_t index = 0; index < ' + dereference + param_len + '; index++) {\n'
+ paramdecl += ' ' + functionprefix + 'ReadObject(' + paramname.text + '[index]);\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)
+ #
+ # TODO: LUGMAL -- remove this and add our copyright
+ # User-supplied prefix text, if any (list of strings)
+ if (genOpts.prefixText):
+ for s in genOpts.prefixText:
+ write(s, 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_validation.h"', file=self.outFile)
+ self.newline()
+ write(self.inline_custom_source_preamble, file=self.outFile)
+
+ def endFile(self):
+ # 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)
+ self.sections = dict([(section, []) for section in self.ALL_SECTIONS])
+ #write('// ending beginFeature', file=self.outFile)
+ def endFeature(self):
+ # C-specific
+ # Actually write the interface to the output file.
+ #write('// starting endFeature', file=self.outFile)
+ if (self.emit):
+ self.newline()
+ if (self.genOpts.protectFeature):
+ write('#ifndef', self.featureName, file=self.outFile)
+ # If type declarations are needed by other features based on
+ # this one, it may be necessary to suppress the ExtraProtect,
+ # or move it below the 'for section...' loop.
+ #write('// endFeature looking at self.featureExtraProtect', file=self.outFile)
+ if (self.featureExtraProtect is not None):
+ write('#ifdef', self.featureExtraProtect, file=self.outFile)
+ #write('#define', self.featureName, '1', file=self.outFile)
+ for section in self.TYPE_SECTIONS:
+ #write('// endFeature writing section'+section, file=self.outFile)
+ contents = self.sections[section]
+ if contents:
+ write('\n'.join(contents), file=self.outFile)
+ self.newline()
+ #write('// endFeature looking at self.sections[command]', file=self.outFile)
+ if (self.sections['command']):
+ write('\n'.join(self.sections['command']), end=u'', file=self.outFile)
+ self.newline()
+ if (self.featureExtraProtect is not None):
+ write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)
+ if (self.genOpts.protectFeature):
+ write('#endif /*', self.featureName, '*/', file=self.outFile)
+ # Finish processing in superclass
+ OutputGenerator.endFeature(self)
+ #write('// ending endFeature', file=self.outFile)
+ #
+ # Append a definition to the specified section
+ def appendSection(self, section, text):
+ # self.sections[section].append('SECTION: ' + section + '\n')
+ self.sections[section].append(text)
+ #
+ # Type generation
+ def genType(self, typeinfo, name, alias):
+ pass
+ #
+ # Struct (e.g. C "struct" type) generation.
+ # This is a special case of the <type> tag where the contents are
+ # interpreted as a set of <member> tags instead of freeform C
+ # C type declarations. The <member> tags are just like <param>
+ # 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
+ # <enum> 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
+ # TODO: Many of these no longer need to be manually written routines. Winnow list.
+ special_functions = [
+ 'vkCreateDevice',
+ 'vkCreateInstance',
+ 'vkAllocateCommandBuffers',
+ 'vkFreeCommandBuffers',
+ 'vkResetCommandPool',
+ 'vkDestroyCommandPool',
+ 'vkAllocateDescriptorSets',
+ 'vkQueuePresentKHR',
+ ]
+ 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)
+
+ 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', '}')
+
+ post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord')
+
+ # PostCallRecord
+ 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)
+
+ post_decl = pre_decl.replace('PreCallRecord', 'PostCallRecord')
+
+ # PostCallRecord
+ 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