From b3328762fcfacb6437963562d342ae37734a13ac Mon Sep 17 00:00:00 2001 From: Tobin Ehlis Date: Mon, 16 Mar 2015 10:44:40 -0600 Subject: layers: Update DrawState to use generated struct size functions Update struct size codegen to handle callback void* case and ppMemBarriers void** cases conservatively for now. --- layers/CMakeLists.txt | 1 + layers/draw_state.c | 145 ++------------------------------------------------ xgl_helper.py | 69 +++++++++++++++--------- 3 files changed, 51 insertions(+), 164 deletions(-) diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt index c8c6ca72..7ad4c17f 100644 --- a/layers/CMakeLists.txt +++ b/layers/CMakeLists.txt @@ -79,6 +79,7 @@ add_custom_target(generate_xgl_layer_helpers DEPENDS xgl_struct_string_helper_no_addr.h xgl_struct_string_helper_cpp.h xgl_struct_string_helper_no_addr_cpp.h + xgl_struct_size_helper.h xgl_struct_wrappers.h xgl_struct_wrappers.cpp xgl_struct_graphviz_helper.h diff --git a/layers/draw_state.c b/layers/draw_state.c index c374d5b4..bf86cfd4 100644 --- a/layers/draw_state.c +++ b/layers/draw_state.c @@ -29,6 +29,7 @@ #include "xgl_dispatch_table_helper.h" #include "xgl_struct_string_helper.h" #include "xgl_struct_graphviz_helper.h" +#include "xgl_struct_size_helper.h" #include "draw_state.h" #include "layers_config.h" // The following is #included again to catch certain OS-specific functions @@ -63,142 +64,6 @@ static uint32_t getTIDIndex() { assert(g_maxTID < MAX_TID); return retVal; } -// Return the size of the underlying struct based on struct type -static size_t sTypeStructSize(XGL_STRUCTURE_TYPE sType) -{ - switch (sType) - { - case XGL_STRUCTURE_TYPE_APPLICATION_INFO: - return sizeof(XGL_APPLICATION_INFO); - case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO: - return sizeof(XGL_DEVICE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: - return sizeof(XGL_MEMORY_ALLOC_INFO); - case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO: - return sizeof(XGL_MEMORY_OPEN_INFO); - case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: - return sizeof(XGL_PEER_MEMORY_OPEN_INFO); - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: - return sizeof(XGL_BUFFER_VIEW_ATTACH_INFO); - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: - return sizeof(XGL_IMAGE_VIEW_ATTACH_INFO); - case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO: - return sizeof(XGL_EVENT_WAIT_INFO); - case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: - return sizeof(XGL_IMAGE_VIEW_CREATE_INFO); - case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: - return sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: - return sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO); - case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO: - return sizeof(XGL_SHADER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: - return sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: - return sizeof(XGL_SAMPLER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: - return sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: - return sizeof(XGL_CMD_BUFFER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO: - return sizeof(XGL_EVENT_CREATE_INFO); - case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO: - return sizeof(XGL_FENCE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO: - return sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO: - return sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO); - case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: - return sizeof(XGL_QUERY_POOL_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: - return sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: - return sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: - return sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: - return sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO: - return sizeof(XGL_IMAGE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO: - return sizeof(XGL_BUFFER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: - return sizeof(XGL_BUFFER_VIEW_CREATE_INFO); - case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: - return sizeof(XGL_FRAMEBUFFER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: - return sizeof(XGL_CMD_BUFFER_BEGIN_INFO); - case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: - return sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO); - case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: - return sizeof(XGL_RENDER_PASS_CREATE_INFO); - case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO: - return sizeof(XGL_LAYER_CREATE_INFO); - case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER: - return sizeof(XGL_PIPELINE_BARRIER); - case XGL_STRUCTURE_TYPE_MEMORY_BARRIER: - return sizeof(XGL_MEMORY_BARRIER); - case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: - return sizeof(XGL_BUFFER_MEMORY_BARRIER); - case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: - return sizeof(XGL_IMAGE_MEMORY_BARRIER); - case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO: - return sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO); - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return sizeof(XGL_UPDATE_SAMPLERS); - case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return sizeof(XGL_UPDATE_SAMPLER_TEXTURES); - case XGL_STRUCTURE_TYPE_UPDATE_IMAGES: - return sizeof(XGL_UPDATE_IMAGES); - case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS: - return sizeof(XGL_UPDATE_BUFFERS); - case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY: - return sizeof(XGL_UPDATE_AS_COPY); - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO: - return sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO); - case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO: - return sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO); - default: - return 0; - } -} -// Return the size of the underlying struct based on sType -static size_t dynStateCreateInfoSize(XGL_STRUCTURE_TYPE sType) -{ - switch (sType) - { - case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO); - case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - return sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO); - default: - return 0; - } -} // Return a string representation of CMD_TYPE enum static char* cmdTypeToString(CMD_TYPE cmd) { @@ -325,11 +190,11 @@ static void insertDynamicState(const XGL_DYNAMIC_STATE_OBJECT state, const GENER pStateNode->pNext = g_pDynamicStateHead[bindPoint]; g_pDynamicStateHead[bindPoint] = pStateNode; pStateNode->stateObj = state; - pStateNode->pCreateInfo = (GENERIC_HEADER*)malloc(dynStateCreateInfoSize(pCreateInfo->sType)); + pStateNode->pCreateInfo = (GENERIC_HEADER*)malloc(get_dynamic_struct_size(pCreateInfo)); #if ALLOC_DEBUG printf("Alloc2 #%lu pStateNode->pCreateInfo addr(%p)\n", ++g_alloc_count, (void*)pStateNode->pCreateInfo); #endif - memcpy(pStateNode->pCreateInfo, pCreateInfo, dynStateCreateInfoSize(pCreateInfo->sType)); + memcpy(pStateNode->pCreateInfo, pCreateInfo, get_dynamic_struct_size(pCreateInfo)); // VP has embedded ptr so need to handle that as special case if (XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == pCreateInfo->sType) { XGL_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pStateNode->pCreateInfo; @@ -559,12 +424,12 @@ static void initPipeline(PIPELINE_NODE *pPipeline, const XGL_GRAPHICS_PIPELINE_C GENERIC_HEADER *pTrav = (GENERIC_HEADER*)pCreateInfo->pNext; while (pTrav) { // Shadow the struct - pShadowTrav->pNext = (GENERIC_HEADER*)malloc(sTypeStructSize(pTrav->sType)); + pShadowTrav->pNext = (GENERIC_HEADER*)malloc(get_dynamic_struct_size(pTrav)); #if ALLOC_DEBUG printf("Alloc6 #%lu pShadowTrav->pNext addr(%p)\n", ++g_alloc_count, (void*)pShadowTrav->pNext); #endif // Typically pNext is const so have to cast to avoid warning when we modify it here - memcpy((void*)pShadowTrav->pNext, pTrav, sTypeStructSize(pTrav->sType)); + memcpy((void*)pShadowTrav->pNext, pTrav, get_dynamic_struct_size(pTrav)); pShadowTrav = (GENERIC_HEADER*)pShadowTrav->pNext; // Special copy of Vtx info as it has embedded array if (XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO == pTrav->sType) { diff --git a/xgl_helper.py b/xgl_helper.py index c554573b..e120864b 100755 --- a/xgl_helper.py +++ b/xgl_helper.py @@ -997,7 +997,11 @@ class StructWrapperGen: if self.struct_dict[s][m]['dyn_array']: if self.struct_dict[s][m]['full_type'].count('*') > 1: if not is_type(self.struct_dict[s][m]['type'], 'struct') and not 'char' in self.struct_dict[s][m]['type'].lower(): - sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(%s));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'], self.struct_dict[s][m]['type'])) + if 'ppMemBarriers' == self.struct_dict[s][m]['name']: + # TODO : For now be conservative and consider all memBarrier ptrs as largest possible struct + sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'])) + else: + sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(%s));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type'], self.struct_dict[s][m]['type'])) else: # This is an array of char* or array of struct ptrs if not i_decl: sh_funcs.append('%suint32_t i = 0;' % (indent)) @@ -1027,7 +1031,7 @@ class StructWrapperGen: sh_funcs.append('%sstructSize += sizeof(%s)*(1+strlen(pStruct->%s));' % (indent, self.struct_dict[s][m]['type'], self.struct_dict[s][m]['name'])) elif is_type(self.struct_dict[s][m]['type'], 'struct'): sh_funcs.append('%sstructSize += %s(pStruct->%s);' % (indent, self._get_size_helper_func_name(self.struct_dict[s][m]['type']), self.struct_dict[s][m]['name'])) - else: + elif 'void' not in self.struct_dict[s][m]['type'].lower(): sh_funcs.append('%sstructSize += sizeof(%s);' % (indent, self.struct_dict[s][m]['type'])) elif 'size_t' == self.struct_dict[s][m]['type'].lower(): sh_funcs.append('%sstructSize += pStruct->%s;' % (indent, self.struct_dict[s][m]['name'])) @@ -1035,28 +1039,44 @@ class StructWrapperGen: indent = ' ' sh_funcs.append('%s}' % (indent)) sh_funcs.append("%sreturn structSize;\n}" % (indent)) - # Now generate generic function to loop over struct chain (or handle generic structs) - sh_funcs.append('size_t get_struct_chain_size(const void* pStruct)\n{') - sh_funcs.append(' // Just use XGL_APPLICATION_INFO as struct until actual type is resolved') - sh_funcs.append(' XGL_APPLICATION_INFO* pNext = (XGL_APPLICATION_INFO*)pStruct;') - sh_funcs.append(' size_t structSize = 0;') - sh_funcs.append(' while (pNext) {') - sh_funcs.append(' switch (pNext->sType) {') - for e in enum_type_dict: - if '_STRUCTURE_TYPE' in e: - for v in sorted(enum_type_dict[e]): - struct_name = v.replace("_STRUCTURE_TYPE", "") - sh_funcs.append(' case %s:\n {' % (v)) - sh_funcs.append(' structSize += %s((%s*)pNext);' % (self._get_size_helper_func_name(struct_name), struct_name)) - sh_funcs.append(' break;') - sh_funcs.append(' }') - sh_funcs.append(" default:") - sh_funcs.append(" assert(0);") - sh_funcs.append(" structSize += 0;") - sh_funcs.append(' }') - sh_funcs.append(' pNext = (XGL_APPLICATION_INFO*)pNext->pNext;') - sh_funcs.append(' }') - sh_funcs.append(' return structSize;\n}') + # Now generate generic functions to loop over entire struct chain (or just handle single generic structs) + for follow_chain in [True, False]: + if follow_chain: + sh_funcs.append('size_t get_struct_chain_size(const void* pStruct)\n{') + else: + sh_funcs.append('size_t get_dynamic_struct_size(const void* pStruct)\n{') + indent = ' ' + sh_funcs.append('%s// Just use XGL_APPLICATION_INFO as struct until actual type is resolved' % (indent)) + sh_funcs.append('%sXGL_APPLICATION_INFO* pNext = (XGL_APPLICATION_INFO*)pStruct;' % (indent)) + sh_funcs.append('%ssize_t structSize = 0;' % (indent)) + if follow_chain: + sh_funcs.append('%swhile (pNext) {' % (indent)) + indent = ' ' + sh_funcs.append('%sswitch (pNext->sType) {' % (indent)) + indent += ' ' + for e in enum_type_dict: + if '_STRUCTURE_TYPE' in e: + for v in sorted(enum_type_dict[e]): + struct_name = v.replace("_STRUCTURE_TYPE", "") + sh_funcs.append('%scase %s:' % (indent, v)) + sh_funcs.append('%s{' % (indent)) + indent += ' ' + sh_funcs.append('%sstructSize += %s((%s*)pNext);' % (indent, self._get_size_helper_func_name(struct_name), struct_name)) + sh_funcs.append('%sbreak;' % (indent)) + indent = indent[:-4] + sh_funcs.append('%s}' % (indent)) + sh_funcs.append('%sdefault:' % (indent)) + indent += ' ' + sh_funcs.append('%sassert(0);' % (indent)) + sh_funcs.append('%sstructSize += 0;' % (indent)) + indent = indent[:-4] + indent = indent[:-4] + sh_funcs.append('%s}' % (indent)) + if follow_chain: + sh_funcs.append('%spNext = (XGL_APPLICATION_INFO*)pNext->pNext;' % (indent)) + indent = indent[:-4] + sh_funcs.append('%s}' % (indent)) + sh_funcs.append('%sreturn structSize;\n}' % indent) return "\n".join(sh_funcs) def _generateSizeHelperHeader(self): @@ -1066,6 +1086,7 @@ class StructWrapperGen: header.append("#include <%s>\n" % f) header.append('\n// Function Prototypes\n') header.append("size_t get_struct_chain_size(const void* pStruct);\n") + header.append("size_t get_dynamic_struct_size(const void* pStruct);\n") return "".join(header) def _generateHeader(self): -- cgit v1.2.3