From 89bb820f7aae5c9f806059591c70a3708c686abb Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 16 May 2016 09:58:50 +0800 Subject: [PATCH] threading: put layer functions into a namespace Put all layer fucntions/data into threading namespace. I had to add some wrappers to make everything work. This also removes vkEnumerateInstance*Properties from procmap. procmap is used in vkGetDeviceProcAddr and it should not contain vkEnumerateInstance*Properties in the first place. --- generator.py | 26 ++++++++++++++++---------- layers/threading.cpp | 46 +++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 59 insertions(+), 13 deletions(-) diff --git a/generator.py b/generator.py index eead211..abb0dbf 100644 --- a/generator.py +++ b/generator.py @@ -2629,15 +2629,13 @@ class ThreadOutputGenerator(OutputGenerator): OutputGenerator.beginFile(self, genOpts) # C-specific # - # Multiple inclusion protection & C++ wrappers. + # Multiple inclusion protection & C++ namespace. if (genOpts.protectFile and self.genOpts.filename): headerSym = '__' + re.sub('\.h', '_h_', os.path.basename(self.genOpts.filename)) write('#ifndef', headerSym, file=self.outFile) write('#define', headerSym, '1', file=self.outFile) self.newline() - write('#ifdef __cplusplus', file=self.outFile) - write('extern "C" {', file=self.outFile) - write('#endif', file=self.outFile) + write('namespace threading {', file=self.outFile) self.newline() # # User-supplied prefix text, if any (list of strings) @@ -2646,7 +2644,7 @@ class ThreadOutputGenerator(OutputGenerator): write(s, file=self.outFile) def endFile(self): # C-specific - # Finish C++ wrapper and multiple inclusion protection + # Finish C++ namespace and multiple inclusion protection self.newline() # record intercepted procedures write('// intercepts', file=self.outFile) @@ -2654,9 +2652,7 @@ class ThreadOutputGenerator(OutputGenerator): write('\n'.join(self.intercepts), file=self.outFile) write('};\n', file=self.outFile) self.newline() - write('#ifdef __cplusplus', file=self.outFile) - write('}', file=self.outFile) - write('#endif', file=self.outFile) + write('} // namespace threading', file=self.outFile) if (self.genOpts.protectFile and self.genOpts.filename): self.newline() write('#endif', file=self.outFile) @@ -2743,6 +2739,14 @@ class ThreadOutputGenerator(OutputGenerator): # # Command generation def genCmd(self, cmdinfo, name): + # Commands shadowed by interface functions and are not implemented + interface_functions = [ + 'vkEnumerateInstanceLayerProperties', + 'vkEnumerateInstanceExtensionProperties', + 'vkEnumerateDeviceLayerProperties', + ] + if name in interface_functions: + return special_functions = [ 'vkGetDeviceProcAddr', 'vkGetInstanceProcAddr', @@ -2750,14 +2754,16 @@ class ThreadOutputGenerator(OutputGenerator): 'vkDestroyDevice', 'vkCreateInstance', 'vkDestroyInstance', - 'vkEnumerateInstanceLayerProperties', - 'vkEnumerateInstanceExtensionProperties', 'vkAllocateCommandBuffers', 'vkFreeCommandBuffers', 'vkCreateDebugReportCallbackEXT', 'vkDestroyDebugReportCallbackEXT', ] if name in special_functions: + decls = self.makeCDecls(cmdinfo.elem) + self.appendSection('command', '') + self.appendSection('command', '// declare only') + self.appendSection('command', decls[0]) self.intercepts += [ ' {"%s", reinterpret_cast(%s)},' % (name,name) ] return if "KHR" in name: diff --git a/layers/threading.cpp b/layers/threading.cpp index d98018c..85ca669 100644 --- a/layers/threading.cpp +++ b/layers/threading.cpp @@ -39,6 +39,8 @@ #include "thread_check.h" +namespace threading { + static void initThreading(layer_data *my_data, const VkAllocationCallbacks *pAllocator) { layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "google_threading"); @@ -333,16 +335,54 @@ VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool c } } +} // namespace threading + +// vk_layer_logging.h expects these to be defined + +VKAPI_ATTR VkResult VKAPI_CALL +vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) { + return threading::vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); +} + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, + VkDebugReportCallbackEXT msgCallback, + const VkAllocationCallbacks *pAllocator) { + threading::vkDestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); +} + +VKAPI_ATTR void VKAPI_CALL +vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, + size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { + threading::vkDebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); +} + +// loader-layer interface v0 + VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { - return util_GetExtensionProperties(ARRAY_SIZE(threading_extensions), threading_extensions, pCount, pProperties); + return util_GetExtensionProperties(ARRAY_SIZE(threading::threading_extensions), threading::threading_extensions, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(ARRAY_SIZE(globalLayerProps), globalLayerProps, pCount, pProperties); + return util_GetLayerProperties(ARRAY_SIZE(threading::globalLayerProps), threading::globalLayerProps, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(ARRAY_SIZE(deviceLayerProps), deviceLayerProps, pCount, pProperties); + return util_GetLayerProperties(ARRAY_SIZE(threading::deviceLayerProps), threading::deviceLayerProps, pCount, pProperties); +} + +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char *pLayerName, uint32_t *pCount, + VkExtensionProperties *pProperties) { + return threading::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties); +} + +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { + return threading::vkGetDeviceProcAddr(dev, funcName); +} + +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { + return threading::vkGetInstanceProcAddr(instance, funcName); } -- 2.7.4